Work towards gridless difficult terrain pathfinding

This fixes a bug where gridless snapping would snap slightly below the target range

.gitignore

@@ -0,0 +1,5 @@
+/foundry*.js
+artifact/
+wasm/
+*.lock
+.vscode/

CHANGELOG.md

@@ -1,3 +1,193 @@
+## 1.12.8
+### Bugfixes
+- Fixed a bug that could cause grid cells to be highlighted in the wrong color
+
+### Compatibility
+- Fixed an interaction with the Wall Height module that could allow players to walk through walls
+
+
+## 1.12.7
+### Bugfixes
+- Fixed a bug that caused measurement templates to only snap to the corners of the grid (this was a regression introduced in 1.12.5)
+
+
+## 1.12.6
+### Bugfixes
+- Measured templates no longer snap to a virtual grid on gridless scenes (this was a regression introduced in 1.12.5)
+
+
+## 1.12.5
+### Compatibility
+- Drag Ruler is now compatible with DF Template Enhancements
+
+
+## 1.12.4
+### Bugfixes
+- Fixed a bug that could cause Drag Ruler to override the default ruler color on other player's clients
+
+
+## 1.12.3
+### Bugfixes
+- Fixed a bug that could cause foundry to freeze indefinitely when trying to pathfind to an unreachalbe location (thanks to JDCalvert)
+- Fixed a bug that caused the pathfinder to route through one-directional walls from the wrong direction (thanks to JDCalvert)
+- Fixed a bug that could cause Drag Ruler to write errors into the JS console during regular usage
+
+### Compatibility
+- Drag Ruler's generic speed provider is now aware of good defaults for DnD 4th Edition
+- Drag Ruler's pathfinder should now be compatible with the Wall Height and Levels modules (thanks to JDCalvert)
+
+
+## 1.12.2
+### Bugfixes
+- Fixed a bug where the pathfinder on gridless scenes sometimes wasn't able to find a way around corners with specific angles
+- Pathfinding will now be disabled when the hotkey to move tokens without animation is being pressed, to allow GMs to move their tokens through walls
+
+
+## 1.12.1
+### Hotfix
+- Version 1.12.0 was incorrectly packaged, which caused it to fail to load
+
+
+## 1.12.0
+### New features
+- Pathfinding is now supported on gridless scenes
+
+
+## 1.11.5
+### Bugfixes
+- Fixed a bug that was causing Drag Ruler to spam useless warnings into the console (this was a regression introduced in 1.11.4)
+
+
+## 1.11.4
+### Bugfixes
+- When changing the measurement mode via a keybinding (toggle snaping or toggle pathfinding) the updated ruler will now be sent to other players immediately
+- Fixed a bug that incorrectly showed a ruler to be snapped to other players despite the ruler not being snapped
+- Fixed a bug that could cause a token to move to an incorrect location if the token was being dragged and dropped very rapidly
+- Drag Ruler's token movement animations can now be properly waited for (this improves the interaction with modules like sequencer)
+
+### Translation
+- Updated Spanish translation (thanks to Viriato139ac#342)
+
+
+## 1.11.3
+### Bugfixes
+- The setting to automatically start pathfinding is now visible to players again (this was a regression introduced in 1.11.2)
+- Fixed a bug that would show the measurements of other players as if they were using the pathfinder, even if they were not using it.
+
+
+## 1.11.2
+### Bugfixes
+- Fixed a memory leak that could cause the rule to slow down after using the pathfinding functionality for a while
+
+### Misc
+- GMs are now always allowed to use the pathfinding tool. The setting now only prevents players from using it.
+
+### Compatibility
+- Drag Ruler's generic speed provider is now aware of good defaults for Dungeonslayers 4
+
+
+## 1.11.1
+### Bugfixes
+- Fixed a bug that would cause the pathfinding algorithm to make tokens of size 2 and 4 to take an unnecessary step
+
+
+## 1.11.0
+### New features
+- Drag Ruler now supports pathfinding. Pressing the assigned button will automatically calculate the shortest route to the point you're dragging your token to and add the necessary waypoints to the ruler.
+ - This feature is only available for gridded maps
+ - This feature can only be used if it's enabled by the GM in the module settings
+ - The routing algorithm *does not* take difficult terrain into account
+
+
+## 1.10.3
+### Compatibility
+- This release contains changes required to be compatible with Foundry 9.245
+
+
+## 1.10.2
+### Bugfixes
+- Fixed a bug that could cause squares to be highlighted in the wrong color when using waypoints on a 5/10/5 gird
+- When using Token Drag Vision, the temporary vision is now correctly cleaned up when dropping the token (resolves a conflict with the "Perfect Vision" module)
+
+
+## 1.10.1
+### Bugfixes
+- Fixed a bug that caused keybindings to break if no scene is active
+
+### Translation
+- Updated Spanish translation (thanks to Viriato139ac#342)
+
+
+## 1.10.0
+**BREAKING** Drag Ruler 1.10.0 and onward cannot update directly from Drag Ruler versions older than 1.3.0. If you've been using Drag Ruler 1.2.2 or earlier in your world make sure to update to any Version between (inclusive) Drag Ruler 1.3.0 and 1.9.1, launch your world and log in as GM at least once. After doing so you can safely update to v1.10.0 or newer versions. Updating directly from 1.2.2 or older to 1.10.0 or newer will cause Drag Ruler to forget your Speed Prover Settings.
+
+### New features
+- Drag Ruler's key bindings can now be assigned to custom keys by the user
+- Measuring difficult terrain on gridded maps with euclidean grid rule is now supported (for this to work the `Terrain Ruler` module needs to be enabled)
+
+### Compatibility
+- Drag Ruler now supports Foundry v9
+- Drag Ruler now utilizes libwrapper to increase interoperability with other modules
+
+### Translation
+- Added french translation (thanks to Elfenduli)
+- Updated japanese translation (thanks to touge)
+
+
+## 1.9.1
+### Bugfixes
+- Fixed a bug that caused the ruler to misbehave or not show up at all if the speed provider isn't configured (this was a regression introduced in 1.9.0)
+
+### Translation
+- Updated the spaish translation (thanks to Viriato139ac#342)
+
+
+## 1.9.0
+### New features
+- On Gridless scenes, tokens can now snap to their speed limits, to make full usage of a token's movement speed easier. This feature can be temporarily disabled by pressing Shift during drag and can be disabled completely in the settings.
+
+### Bugfixes
+- Non-square tokens (e.g. 2x1) now work correctly on square grids
+- When modifying difficult terrain that a token has already moved over, this the movement history of the token won't change anymore (this was a regression introduced in 1.8.0)
+- Fixed a bug that prevented pausing/unpausing the game when no scene was active
+
+### API
+- Added `dragRuler.getColorForDistanceAndToken` API endpoint that allows other modules to receive the highlight color for a specified distance with a given token.
+
+
+## 1.8.2
+### Compatibility
+- The generic speed provider defaults have been updated for lance 1.0 (thanks to BoltsJ!)
+- Eliminated a deprecation warning when both Drag Ruler and Hex Size Support are enabled (thanks Argonius-Angelus!)
+
+
+## 1.8.1
+### Bugfixes
+- Fixed a bug where the function that was bound to the spacebar key wouldn't work correctly when the "Toggle Snap To Grid" module was enabled
+
+### Translation
+- Updated Spanish translation (thanks to Viriato139ac#342)
+
+
+## 1.8.0
+### New features
+- Pressing escape during a drag now cancels the drag
+- Undoing a movement via Ctrl+Z will now also remove that movement from Drag Ruler's movement history
+- Drag Ruler can now configured to stay disabled by default when a Token/Template is being dragged. In that case it will activate once the button to place a waypoint is being pressed.
+
+### Bugfixes
+- Fixed a bug that caused the ruler to snap to grid when a waypoint was deleted while shift was being pressed (thanks to Michael Clavell!)
+- Fixed a bug that could leave behind a single waypoint on the canvas when canceling a dragging operation while moving the mouse
+
+### Compatibility
+- Drag Ruler is now compatible with the "Toggle Snap To Grid" module (thanks to Michael Clavell!)
+
+
+## 1.7.7
+### Compatibility
+- Updated the default settings for the swade game system. The new default speed attribute points to a speed value that gets adjusted for wounds.
+
+
 ## 1.7.6
 ### Translation
 - Added Korean translation (thanks to KLO#1490)

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Manuel Vögele
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,7 +1,7 @@
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/staebchenfisch)
 
 # Drag Ruler
-This module shows a ruler when you drag a token or measurement template to infrom you how far you've dragged it from it's start point. Additionally, if you're using a grid, the spaces the token will travel though will be colored depending on your tokens speed. By default three colors are being used: green for spaces that your token can reach by walking normally are colored green, spaces that can only be reached by dashing will be colored red and spaces that cannot be reached with the token's speed will be colored red. If you're using a gridless map the ruler color will change to convey this information.
+This module shows a ruler when you drag a token or measurement template to inform you how far you've dragged it from its start point. Additionally, if you're using a grid, the spaces the token will travel though will be colored depending on your tokens speed. By default, three colors are being used: green for spaces that your token can reach by walking normally are colored green, spaces that can only be reached by dashing will be colored yellow and spaces that cannot be reached with the token's speed will be colored red. If you're using a gridless map the ruler color will change to convey this information.
 
 ![Drag Ruler being used on a square grids](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/709774b25f7dd818a90591165f74b3e6dbc788cc/media/basic_square.webp)
 ![Drag Ruler being used on a gridless scene](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/709774b25f7dd818a90591165f74b3e6dbc788cc/media/basic_gridless.webp)
@@ -33,14 +33,24 @@ During combat, Drag Ruler will remember the path a token has taken during it's t
 
 
 ## Game systems with Drag Ruler integration
-Drag Ruler will work with all Foundry VTT game systems. However some game systems offer a special integration via the [Drag Ruler API](#api), that allows Drag Ruler to take the rules of the game system into account when dispaying speeds (such as weight carried or conditions that apply to the character), offering a smoother experience. While some game systems offer this integration natively, for other game systems there are modules providing the integration. If the integration is provided via a module you need to install and activate both Drag Ruler and the integration module to benefit from the integration.
+Drag Ruler will work with all Foundry VTT game systems. However, some game systems offer a special integration via the [Drag Ruler API](#api), that allows Drag Ruler to take the rules of the game system into account when dispaying speeds (such as weight carried or conditions that apply to the character), offering a smoother experience. While some game systems offer this integration natively, for other game systems there are modules providing the integration. If the integration is provided via a module you need to install and activate both Drag Ruler and the integration module to benefit from the integration.
 
 The game systems that offer Drag Ruler integration are:
 - Cypher System (starting with version 1.13.0)
+- DnD5e (via the module [DnD5e Drag Ruler Integration](https://foundryvtt.com/packages/elevation-drag-ruler))
+- GURPS 4th Edition Game Aid (Unofficial) (starting with version 0.9.1)
 - Ironclaw Second Edition (starting with version 0.2.2)
+- Lancer (via the module [Lancer Speed Provider](https://foundryvtt.com/packages/lancer-speed-provider))
+- Level Up: Advanced 5th Edition (Official) (via the module [A5E Drag Ruler Integration](https://foundryvtt.com/packages/a5edragruler))
 - Pathfinder 1 (starting with version 0.77.3)
 - Pathfinder 2e (via the module [PF2E Drag Ruler Integration](https://foundryvtt.com/packages/pf2e-dragruler/))
+- Shadowrun 5th Edition (via the module [Drag Ruler Integration for Shadowrun 5E](https://foundryvtt.com/packages/drag-ruler-integration-for-shadowrun-5e))
+- Shadow of the Demon Lord (starting with version 1.7.15)
+- Starfinder (via the module [Starfinder Drag Ruler Integration](https://foundryvtt.com/packages/starfinder-drag-ruler))
+- Stargate RPG (starting with version 1.6.0)
+- Symbaroum (via the module [Symbaroum drag ruler integration](https://foundryvtt.com/packages/symbaroum-drag-ruler-integration))
 - Tagmar RPG (starting with version 1.1.4)
+- TheWitcherTRPG (starting with version 0.0.62)
 - Tormenta20 (starting with version 1.1.37)
 - Shadow of the Demon Lord  (starting with version 1.7.15)
 - Wasteland Ventures (starting with version 0.1.0)

build_release.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+
+import json
+from pathlib import PurePath, Path
+import subprocess
+import tempfile
+import zipfile
+
+wasm_pack = Path("~/.cargo/bin/wasm-pack").expanduser()
+
+root_files = ["module.json", "README.md", "CHANGELOG.md", "LICENSE"]
+wasm_files = ["gridless_pathfinding_bg.wasm", "gridless_pathfinding.js"]
+output_dir = Path("artifact")
+copy_everything_directories = ["js", "lang", "templates"]
+wasm_dir = Path("wasm")
+root_dir = Path(".")
+rust_dir = Path("rust")
+build_dir_tmp = tempfile.TemporaryDirectory()
+build_dir = Path(build_dir_tmp.name)
+
+with open("module.json", "r") as file:
+	manifest = json.load(file)
+
+zip_root = PurePath(f'{manifest["name"]}')
+
+filename = f'{manifest["name"]}-{manifest["version"]}.zip'
+
+result = subprocess.run([wasm_pack, "build", "--target", "web", "--out-dir", build_dir, root_dir / rust_dir])
+if result.returncode != 0:
+	raise Exception("Wasm build failed")
+
+output_dir.mkdir(parents=True, exist_ok=True)
+
+def write_directory(archive, d):
+	for f in (root_dir / d).iterdir():
+		if f.is_dir():
+			write_directory(archive, f)
+		else:
+			assert(f.is_file())
+			archive.write(f, arcname=zip_root / d / f.name)
+
+with zipfile.ZipFile(output_dir / filename, mode="w", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as archive:
+	for f in root_files:
+		archive.write(root_dir / f, arcname=zip_root / f)
+	for d in copy_everything_directories:
+		write_directory(archive, d)
+	for f in wasm_files:
+		archive.write(build_dir / f, arcname=zip_root / wasm_dir / f)
+
+print(f"Successfully built {output_dir / filename}")

build_wasm.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+
+import sys
+import subprocess
+from pathlib import Path
+
+root_dir = Path(".")
+wasm_dir = root_dir / Path("wasm")
+rust_dir = root_dir / Path("rust")
+
+debug = " --debug" if len(sys.argv) >= 2 and sys.argv[1] == "--debug" else ""
+
+result = subprocess.run(["cargo", "watch", "-C" , rust_dir, "-s", f"wasm-pack build --target web --out-dir {wasm_dir.resolve()}{debug}"])

install_dev_dependencies.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+cargo install cargo-watch
+cargo install wasm-pack

js/api.js

@@ -2,7 +2,7 @@ import {measureDistances} from "./compatibility.js";
 import {getMovementHistory} from "./movement_tracking.js";
 import {GenericSpeedProvider, SpeedProvider} from "./speed_provider.js"
 import {settingsKey} from "./settings.js"
-import {getTokenShape} from "./util.js";
+import {getAreaFromPositionAndShape, getTokenShape} from "./util.js";
 
 export const availableSpeedProviders = {}
 export let currentSpeedProvider = undefined
@@ -103,12 +103,12 @@ export function getUnreachableColorFromSpeedProvider() {
 	}
 }
 
-export function getCostFromSpeedProvider(token, area) {
+export function getCostFromSpeedProvider(token, area, options) {
 	try {
 		if (currentSpeedProvider instanceof Function) {
-			return SpeedProvider.prototype.getCostForStep.call(undefined, token, area);
+			return SpeedProvider.prototype.getCostForStep.call(undefined, token, area, options);
 		}
-		return currentSpeedProvider.getCostForStep(token, area);
+		return currentSpeedProvider.getCostForStep(token, area, options);
 	}
 	catch (e) {
 		console.error(e);
@@ -116,15 +116,34 @@ export function getCostFromSpeedProvider(token, area) {
 	}
 }
 
+export function getColorForDistanceAndToken(distance, token, ranges=null) {
+	if (!ranges) {
+		ranges = getRangesFromSpeedProvider(token);
+	}
+	if (ranges.length === 0)
+		return null;
+	const currentRange = ranges.reduce((minRange, currentRange) => {
+		if (distance <= currentRange.range && currentRange.range < minRange.range)
+			return currentRange;
+		return minRange;
+	}, {range: Infinity, color: getUnreachableColorFromSpeedProvider()});
+	return currentRange.color;
+}
+
 export function getMovedDistanceFromToken(token) {
+	const terrainRulerAvailable = game.modules.get("terrain-ruler")?.active;
 	const history = getMovementHistory(token);
 	const segments = Ruler.dragRulerGetRaysFromWaypoints(history, {x: token.x, y: token.y}).map(ray => {return {ray}});
 	const shape = getTokenShape(token);
-	const distances = measureDistances(segments, token, shape);
+	const distances = measureDistances(segments, token, shape, {enableTerrainRuler: terrainRulerAvailable});
 	// Sum up the distances
 	return distances.reduce((acc, val) => acc + val, 0);
 }
 
+export function buildCostFunction(token, shape) {
+	return (x, y, costOptions={}) => getCostFromSpeedProvider(token, getAreaFromPositionAndShape({x, y}, shape), costOptions);
+}
+
 export function registerModule(moduleId, speedProvider) {
 	// Check if a module with the given id exists and is currently enabled
 	const module = game.modules.get(moduleId)

js/compatibility.js

@@ -1,7 +1,6 @@
-import {getCostFromSpeedProvider} from "./api.js";
+import {buildCostFunction} from "./api.js";
-import {getColorForDistance} from "./main.js"
 import {settingsKey} from "./settings.js";
-import {getAreaFromPositionAndShape, highlightTokenShape} from "./util.js";
+import {highlightTokenShape} from "./util.js";
 
 export function getHexSizeSupportTokenGridCenter(token) {
 	const tokenCenterOffset = CONFIG.hexSizeSupport.getCenterOffset(token)
@@ -10,30 +9,35 @@ export function getHexSizeSupportTokenGridCenter(token) {
 
 export function highlightMeasurementTerrainRuler(ray, startDistance, tokenShape=[{x: 0, y: 0}], alpha=1) {
 	for (const space of ray.terrainRulerVisitedSpaces.reverse()) {
-		const color = getColorForDistance.call(this, startDistance, space.distance)
+		const color = this.dragRulerGetColorForDistance(startDistance + space.distance);
 		highlightTokenShape.call(this, space, tokenShape, color, alpha)
 	}
 }
 
 export function measureDistances(segments, entity, shape, options={}) {
-	const isToken = entity instanceof Token;
 	const opts = duplicate(options)
-	if (!opts.gridSpaces)
+	if (canvas.grid.diagonalRule === "EUCL") {
+		opts.ignoreGrid = true;
+		opts.gridSpaes = false;
+	}
+	if (opts.enableTerrainRuler) {
 		opts.gridSpaces = true;
-	const terrainRulerAvailable = isToken && game.modules.get("terrain-ruler")?.active && (!game.modules.get("TerrainLayer")?.active || canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS);
-
-	if (terrainRulerAvailable) {
 		const firstNewSegmentIndex = segments.findIndex(segment => !segment.ray.dragRulerVisitedSpaces);
 		const previousSegments = segments.slice(0, firstNewSegmentIndex);
 		const newSegments = segments.slice(firstNewSegmentIndex);
 		const distances = previousSegments.map(segment => segment.ray.dragRulerVisitedSpaces[segment.ray.dragRulerVisitedSpaces.length - 1].distance);
 		previousSegments.forEach(segment => segment.ray.terrainRulerVisitedSpaces = duplicate(segment.ray.dragRulerVisitedSpaces));
-		opts.costFunction = (x, y) => getCostFromSpeedProvider(entity, getAreaFromPositionAndShape({x, y}, shape), {x, y});
+		opts.costFunction = buildCostFunction(entity, shape);
 		if (previousSegments.length > 0)
 			opts.terrainRulerInitialState = previousSegments[previousSegments.length - 1].ray.dragRulerFinalState;
 		return distances.concat(terrainRuler.measureDistances(newSegments, opts));
 	}
 	else {
+		// If another module wants to enable grid measurements but disable grid highlighting,
+		// manually set the *duplicate* option's gridSpaces value to true for the Foundry logic to work properly
+		if(!opts.ignoreGrid) {
+			opts.gridSpaces = true;
+		}
 		return canvas.grid.measureDistances(segments, opts);
 	}
 }
@@ -61,9 +65,6 @@ export function checkDependencies() {
 			if (game.modules.get("enhanced-terrain-layer")?.active) {
 				enabledTerrainModule = game.modules.get("enhanced-terrain-layer").data.title;
 			}
-			else if (game.modules.get("TerrainLayer")?.active) {
-				enabledTerrainModule = game.modules.get("TerrainLayer").data.title;
-			}
 			if (enabledTerrainModule) {
 				new Dialog({
 					title: game.i18n.localize("drag-ruler.dependencies.terrain-ruler.title"),

js/data_structures.js

@@ -0,0 +1,138 @@
+/**
+ * A combination queue/set where the elements are ordered (in ascending order, according to the given priority function)
+ * and unique (according to the given elementMatcher).
+ *
+ * If an element is added to the set and an equivalent element already exists, the lower-priority one is discarded.
+ */
+export class PriorityQueueSet {
+	constructor(elementMatcher, priorityFunction) {
+		this.first = null;
+		this.elementMatcher = elementMatcher;
+		this.priorityFunction = priorityFunction;
+	}
+
+	pushWithPriority(value) {
+		const newNode = {value, priority: this.priorityFunction(value), next: null};
+
+		// If the queue is currently empty, we can just set this new node as the first and we're done
+		if (!this.first) {
+			this.first = newNode;
+			return;
+		}
+
+		let inserted = false;
+		let previous;
+		let current = this.first;
+
+		// Loop through the existing elements
+		while (current) {
+			if (this.elementMatcher(current.value, value)) {
+				// We've found an equivalent element before one with a lower priority. This one has at least
+				// the same priority as the new one, so don't bother inserting
+				return;
+			} else if (newNode.priority <= current.priority) {
+				// We've found some element with lower priority than the new one, so insert the new one just before it
+				newNode.next = current;
+				if (previous) {
+					previous.next = newNode;
+				} else {
+					this.first = newNode;
+				}
+				inserted = true;
+
+				previous = current;
+				current = current.next;
+				break;
+			}
+			previous = current;
+			current = current.next;
+		}
+
+		if (inserted) {
+			// Go through the rest of the list and try to find an equivalent element to the new one.
+			// We know it has higher priority than the new one, so remove it.
+			while (current) {
+				if (this.elementMatcher(current.value, value)) {
+					if (previous) {
+						previous.next = current.next;
+					} else {
+						this.first = current.next;
+					}
+					return;
+				}
+				previous = current;
+				current = current.next;
+			}
+		} else {
+			// We reached the end of the queue without finding a lower-priority or existing element, so
+			// insert the new one at the end
+			previous.next = newNode;
+		}
+	}
+
+	hasNext() {
+		return !!this.first;
+	}
+
+	pop() {
+		const first = this.first;
+		this.first = first?.next;
+		return first?.value;
+	}
+}
+
+/**
+ * Queue that will only ever accept elements with a given value once. Elements must have a "value" field, the
+ * JSON representation of which will be used as the key to match
+ */
+export class ProcessOnceQueue {
+	constructor() {
+		this.first = null;
+		this.last = null;
+		this.previouslyQueued = new Set();
+	}
+
+	/**
+	 * Remove everything from the queue and forget all the previously-queued items
+	 */
+	reset() {
+		this.first = null;
+		this.last = null;
+		this.previouslyQueued.clear();
+	}
+
+	push(element) {
+		if (this.previouslyQueued.has(element)) {
+			return;
+		}
+		this.previouslyQueued.add(element);
+
+		const newNode = {
+			value: element,
+			next: null,
+			previous: null
+		}
+
+		if (!this.first) {
+			this.first = newNode;
+			this.last = newNode;
+		} else {
+			this.last.next = newNode;
+			newNode.previous = this.last;
+			this.last = newNode;
+		}
+	}
+
+	pop() {
+		const node = this.first;
+		this.first = node?.next;
+		if (!node?.next) {
+			this.last = null;
+		}
+		return node?.value;
+	}
+
+	hasNext() {
+		return !!this.first;
+	}
+}

js/foundry_fixes.js

@@ -16,3 +16,21 @@ export function getGridPositionFromPixels(xPixel, yPixel) {
 		return [y, x]
 	return [x, y]
 }
+
+export function getGridPositionFromPixelsObj(o) {
+	const r = {};
+	[r.x, r.y] = getGridPositionFromPixels(o.x, o.y);
+	return r;
+}
+
+export function getPixelsFromGridPositionObj(o) {
+	const r = {};
+	[r.x, r.y] = getPixelsFromGridPosition(o.x, o.y);
+	return r;
+}
+
+export function getCenterFromGridPositionObj(o) {
+	const r = getPixelsFromGridPositionObj(o);
+	[r.x, r.y] = canvas.grid.getCenter(r.x, r.y);
+	return r;
+}

js/foundry_imports.js

@@ -1,10 +1,12 @@
 import {highlightMeasurementTerrainRuler, measureDistances} from "./compatibility.js";
-import {getGridPositionFromPixels} from "./foundry_fixes.js";
+import {getGridPositionFromPixels, getGridPositionFromPixelsObj, getPixelsFromGridPositionObj} from "./foundry_fixes.js";
 import {Line} from "./geometry.js";
-import {getColorForDistance} from "./main.js"
+import {disableSnap, moveWithoutAnimation} from "./keybindings.js";
 import {trackRays} from "./movement_tracking.js"
+import {findPath, isPathfindingEnabled} from "./pathfinding.js";
+import {settingsKey} from "./settings.js";
 import {recalculate} from "./socket.js";
-import {applyTokenSizeOffset, getSnapPointForEntity, getSnapPointForToken, getTokenShape, highlightTokenShape, zip} from "./util.js";
+import {applyTokenSizeOffset, enumeratedZip, getSnapPointForEntity, getSnapPointForToken, getSnapPointForTokenObj, getTokenShape, highlightTokenShape, sum} from "./util.js";
 
 // This is a modified version of Ruler.moveToken from foundry 0.7.9
 export async function moveEntities(draggedEntity, selectedEntities) {
@@ -26,6 +28,9 @@ export async function moveEntities(draggedEntity, selectedEntities) {
 		const hasCollision = selectedEntities.some(token => {
 			const offset = calculateEntityOffset(token, draggedEntity);
 			const offsetRays = rays.filter(ray => !ray.isPrevious).map(ray => applyOffsetToRay(ray, offset))
+			if (window.WallHeight) {
+				window.WallHeight.addBoundsToRays(offsetRays, draggedEntity);
+			}
 			return offsetRays.some(r => canvas.walls.checkCollision(r));
 		})
 		if (hasCollision) {
@@ -70,7 +75,7 @@ async function animateEntities(entities, draggedEntity, draggedRays, wasPaused)
 	});
 
 	const isToken = draggedEntity instanceof Token;
-	const animate = isToken && !game.keyboard.isDown("Alt");
+	const animate = isToken && !moveWithoutAnimation;
 	const startWaypoint = animate ? 0 : entityAnimationData[0].rays.length - 1;
 
 	// This is a flag of the "Monk's Active Tile Triggers" module that signals that the movement should be cancelled early
@@ -89,7 +94,7 @@ async function animateEntities(entities, draggedEntity, draggedRays, wasPaused)
 		});
 		await draggedEntity.scene.updateEmbeddedDocuments(draggedEntity.constructor.embeddedName, updates, {animate});
 		if (animate)
-			await Promise.all(entityPaths.map(({entity, path}) => entity.animateMovement(path)));
+			await Promise.all(entityPaths.map(({entity}) => CanvasAnimation.getAnimation(entity.movementAnimationName)?.promise));
 
 		// This is a flag of the "Monk's Active Tile Triggers" module that signals that the movement should be cancelled early
 		if (this.cancelMovement) {
@@ -131,12 +136,10 @@ function scheduleMeasurement(destination, event) {
 	const mt = event._measureTime || 0;
 	const originalEvent = event.data.originalEvent;
 	if (Date.now() - mt > measurementInterval) {
-		this.measure(destination, {snap: !originalEvent.shiftKey});
+		this.measure(destination, {snap: !disableSnap});
 		event._measureTime = Date.now();
 		this._state = Ruler.STATES.MEASURING;
-		window.clearTimeout(this.deferredMeasurementTimeout);
+		cancelScheduledMeasurement.call(this);
-		this.deferredMeasurementTimeout = undefined;
-		this.deferredMeasurementResolve?.();
 	}
 	else {
 		this.deferredMeasurementData = {destination, event};
@@ -147,23 +150,76 @@ function scheduleMeasurement(destination, event) {
 	}
 }
 
+export function cancelScheduledMeasurement() {
+	window.clearTimeout(this.deferredMeasurementTimeout);
+	this.deferredMeasurementTimeout = undefined;
+	this.deferredMeasurementResolve?.();
+}
+
 // This is a modified version of Ruler.measure form foundry 0.7.9
-export function measure(destination, {gridSpaces=true, snap=false} = {}) {
+export function measure(destination, options={}) {
+
 	const isToken = this.draggedEntity instanceof Token;
 	if (isToken && !this.draggedEntity.isVisible)
 		return []
 
-	if (snap) {
+	options.snap = options.snap ?? !disableSnap;
+
+	if (options.snap) {
 		destination = getSnapPointForEntity(destination.x, destination.y, this.draggedEntity);
 	}
 
-	const terrainRulerAvailable = isToken && game.modules.get("terrain-ruler")?.active && (!game.modules.get("TerrainLayer")?.active || canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS);
+	this.dragRulerRemovePathfindingWaypoints();
+
+	if (isToken && isPathfindingEnabled.call(this)) {
+		const from = getGridPositionFromPixelsObj(this.waypoints[this.waypoints.length - 1]);
+		const to = getGridPositionFromPixelsObj(destination);
+		let path = findPath(from, to, this.draggedEntity, this.waypoints);
+		if (path)
+			path.shift();
+		if (path && path.length > 0) {
+			path = path.map(point => getSnapPointForTokenObj(getPixelsFromGridPositionObj(point), this.draggedEntity));
+
+			// If the token is snapped to the grid, the first point of the path is already handled by the ruler
+			if (path[0].x === this.waypoints[this.waypoints.length - 1].x && path[0].y === this.waypoints[this.waypoints.length - 1].y)
+				path = path.slice(1);
+
+			// If snapping is enabled, the last point of the path is already handled by the ruler
+			if (options.snap)
+				path = path.slice(0, path.length - 1);
+
+			for (const point of path) {
+				point.isPathfinding = true;
+				this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
+			}
+			this.waypoints = this.waypoints.concat(path);
+		}
+		else {
+			// Don't show a path if the pathfinding yields no result to show the user that the destination is unreachable
+			destination = this.waypoints[this.waypoints.length - 1];
+		}
+	}
+
+	if(options.gridSpaces === undefined) {
+		options.gridSpaces = canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS;
+	}
+
+	if (canvas.grid.diagonalRule === "EUCL") {
+		options.gridSpaces = false;
+		options.ignoreGrid = true;
+	}
+
+	if(options.ignoreGrid === undefined) {
+		options.ignoreGrid = false;
+	}
+
+	options.enableTerrainRuler = isToken && game.modules.get("terrain-ruler")?.active;
 
 	const waypoints = this.waypoints.concat([destination]);
 	// Move the waypoints to the center of the grid if a size is used that measures from edge to edge
 	const centeredWaypoints = isToken ? applyTokenSizeOffset(waypoints, this.draggedEntity) : duplicate(waypoints);
 	// Foundries native ruler requires the waypoints to sit in the dead center of the square to work properly
-	if (!terrainRulerAvailable)
+	if (!options.enableTerrainRuler && !options.ignoreGrid)
 		centeredWaypoints.forEach(w => [w.x, w.y] = canvas.grid.getCenter(w.x, w.y));
 
 	const r = this.ruler;
@@ -197,7 +253,7 @@ export function measure(destination, {gridSpaces=true, snap=false} = {}) {
 	const shape = isToken ? getTokenShape(this.draggedEntity) : null;
 
 	// Compute measured distance
-	const distances = measureDistances(centeredSegments, this.draggedEntity, shape, {gridSpaces});
+	const distances = measureDistances(centeredSegments, this.draggedEntity, shape, options);
 
 	let totalDistance = 0;
 	for (let [i, d] of distances.entries()) {
@@ -216,11 +272,11 @@ export function measure(destination, {gridSpaces=true, snap=false} = {}) {
 	// Draw measured path
 	r.clear();
 	let rulerColor
-	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS)
+	if (!options.gridSpaces || canvas.grid.type === CONST.GRID_TYPES.GRIDLESS)
-		rulerColor = getColorForDistance.call(this, totalDistance)
+		rulerColor = this.dragRulerGetColorForDistance(totalDistance);
 	else
 		rulerColor = this.color
-	for (const [s, cs] of zip(segments.reverse(), centeredSegments.reverse())) {
+	for (const [i, s, cs] of enumeratedZip([...segments].reverse(), [...centeredSegments].reverse())) {
 		const { label, text, last } = cs;
 
 		// Draw line segment
@@ -252,11 +308,14 @@ export function measure(destination, {gridSpaces=true, snap=false} = {}) {
 		}
 
 		// Highlight grid positions
-		if (isToken && canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS) {
+		if (isToken && canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS && options.gridSpaces) {
-			if (terrainRulerAvailable)
+			if (options.enableTerrainRuler) {
 				highlightMeasurementTerrainRuler.call(this, cs.ray, cs.startDistance, shape, opacityMultiplier)
-			else
+			}
-				highlightMeasurementNative.call(this, cs.ray, cs.startDistance, shape, opacityMultiplier);
+			else {
+				const previousSegments = centeredSegments.slice(0, segments.length - 1 - i);
+				highlightMeasurementNative.call(this, cs.ray, previousSegments, shape, opacityMultiplier);
+			}
 		}
 	}
 
@@ -269,7 +328,7 @@ export function measure(destination, {gridSpaces=true, snap=false} = {}) {
 	return segments;
 }
 
-export function highlightMeasurementNative(ray, startDistance, tokenShape=[{x: 0, y: 0}], alpha=1) {
+export function highlightMeasurementNative(ray, previousSegments, tokenShape=[{x: 0, y: 0}], alpha=1) {
 	const spacer = canvas.scene.data.gridType === CONST.GRID_TYPES.SQUARE ? 1.41 : 1;
 	const nMax = Math.max(Math.floor(ray.distance / (spacer * Math.min(canvas.grid.w, canvas.grid.h))), 1);
 	const tMax = Array.fromRange(nMax+1).map(t => t / nMax);
@@ -287,9 +346,11 @@ export function highlightMeasurementNative(ray, startDistance, tokenShape=[{x: 0
 		if ( x0 === x1 && y0 === y1 ) continue;
 
 		// Highlight the grid position
-		let [xg, yg] = canvas.grid.grid.getPixelsFromGridPosition(x1, y1);
+		let [xgtl, ygtl] = canvas.grid.grid.getPixelsFromGridPosition(x1, y1);
-		const subDistance = canvas.grid.measureDistances([{ray: new Ray(ray.A, {x: xg, y: yg})}], {gridSpaces: true})[0]
+		let [xg, yg] = canvas.grid.grid.getCenter(xgtl, ygtl);
-		const color = dragRuler.getColorForDistance.call(this, startDistance, subDistance)
+		const pathUntilSpace = previousSegments.concat([{ray: new Ray(ray.A, {x: xg, y: yg})}]);
+		const distance = sum(canvas.grid.measureDistances(pathUntilSpace, {gridSpaces: true}));
+		const color = this.dragRulerGetColorForDistance(distance);
 		const snapPoint = getSnapPointForToken(...canvas.grid.getTopLeft(x, y), this.draggedEntity);
 		const [snapX, snapY] = getGridPositionFromPixels(snapPoint.x + 1, snapPoint.y + 1);
 
@@ -300,9 +361,11 @@ export function highlightMeasurementNative(ray, startDistance, tokenShape=[{x: 0
 			let th = tMax[i - 1] - (0.5 / nMax);
 			let {x, y} = ray.project(th);
 			let [x1h, y1h] = canvas.grid.grid.getGridPositionFromPixels(x, y);
-			let [xgh, ygh] = canvas.grid.grid.getPixelsFromGridPosition(x1h, y1h);
+			let [xghtl, yghtl] = canvas.grid.grid.getPixelsFromGridPosition(x1h, y1h);
-			const subDistance = canvas.grid.measureDistances([{ray: new Ray(ray.A, {x: xgh, y: ygh})}], {gridSpaces: true})[0]
+			let [xgh, ygh] = canvas.grid.grid.getCenter(xghtl, yghtl);
-			const color = dragRuler.getColorForDistance.call(this, startDistance, subDistance)
+			const pathUntilSpace = previousSegments.concat([{ray: new Ray(ray.A, {x: xgh, y: ygh})}]);
+			const distance = sum(canvas.grid.measureDistances(pathUntilSpace, {gridSpaces: true}));
+			const color = this.dragRulerGetColorForDistance(distance);
 			const snapPoint = getSnapPointForToken(...canvas.grid.getTopLeft(x, y), this.draggedEntity);
 			const [snapX, snapY] = getGridPositionFromPixels(snapPoint.x + 1, snapPoint.y + 1);
 			highlightTokenShape.call(this, {x: snapX, y: snapY}, tokenShape, color, alpha);

js/hex_support.js

@@ -0,0 +1,93 @@
+/**
+ * Functions taken directly from the hex-size-support module (https://github.com/Ourobor/Hex-Size-Support/releases/tag/1.1.0).
+ * Unless otherwise stated, these functions are taken as-is.
+ */
+
+/**
+ * Altered version of this function.
+ * - Instead of taking a token as a parameter to retrieve the altOrientationFlag, receive the flag value directly
+ * - Instead of taking a grid parameter, get the grid value from the globas canvas
+ */
+export function findVertexSnapPoint(x, y, altOrientationFlag) {
+	const grid = canvas.grid.grid;
+	if (grid.columns) {
+		return findSnapPointCols(x, y, grid.h, grid.w, altOrientationFlag);
+	} else {
+		return findSnapPointRows(x, y, grid.h, grid.w, altOrientationFlag);
+	}
+}
+
+function findSnapPointRows(x, y, h, w, alt) {
+	let xOffset = 0.0
+	if (canvas.grid.grid.even) {
+		xOffset = -0.5
+	}
+
+	let yOffset1 = 0.75
+	let yOffset2 = 0.00
+	if (alt) {
+		yOffset1 = 0.25
+		yOffset2 = 1.00
+	}
+
+	let row1 = calculateSnapPointsRows(x, y, h, w, 0.5 + xOffset, yOffset1);
+	let row2 = calculateSnapPointsRows(x, y, h, w, 1.0 + xOffset, yOffset2);
+
+	let dist1 = Math.pow((row1.x - x), 2) + Math.pow((row1.y - y), 2)
+	let dist2 = Math.pow((row2.x - x), 2) + Math.pow((row2.y - y), 2)
+
+	if (dist1 < dist2) {
+		return row1
+	}
+	else {
+		return row2
+	}
+}
+
+function calculateSnapPointsRows(x, y, h, w, xOff, yOff) {
+	let c = Math.floor(((x + ((0.5 - xOff) * w)) / w) + 1)
+	let r = Math.floor(((y + ((0.75 - yOff) * h)) / (1.5 * h)) + 1)
+
+	let snapX = (c * w) - ((1 - xOff) * w)
+	let snapY = (r * h * 1.5) - ((1.5 - yOff) * h)
+
+	return {x: snapX, y: snapY}
+}
+
+function findSnapPointCols(x, y, h, w, alt) {
+	let yOffset = 0.0
+	if (canvas.grid.grid.even) {
+		yOffset = -0.5
+	}
+
+	let xOffset1 = 0.25
+	let xOffset2 = 1.00
+	if (alt) {
+		xOffset1 = 0.75
+		xOffset2 = 0.00
+	}
+
+	let row1 = calculateSnapPointsCols(x, y, h, w, xOffset1, 0.5 + yOffset);
+	let row2 = calculateSnapPointsCols(x, y, h, w, xOffset2, 1.0 + yOffset);
+
+	let dist1 = Math.pow((row1.x - x), 2) + Math.pow((row1.y - y), 2)
+	let dist2 = Math.pow((row2.x - x), 2) + Math.pow((row2.y - y), 2)
+
+	if (dist1 < dist2) {
+		return row1
+	}
+	else {
+		return row2
+	}
+
+}
+
+function calculateSnapPointsCols(x, y, h, w, xOff, yOff) {
+	let c = Math.floor(((x + ((0.75 - xOff) * w)) / (1.5 * w)) + 1)
+	let r = Math.floor(((y + ((0.5 - yOff) * h)) / h) + 1)
+
+	let snapX = (c * w * 1.5) - ((1.5 - xOff) * w)
+	let snapY = (r * h) - ((1 - yOff) * h)
+
+	return {x: snapX, y: snapY}
+}

js/keybindings.js

@@ -0,0 +1,140 @@
+import {settingsKey} from "./settings.js";
+import {getMeasurePosition, setSnapParameterOnOptions} from "./util.js";
+
+export let disableSnap = false;
+export let moveWithoutAnimation = false;
+export let togglePathfinding = false;
+
+export function registerKeybindings() {
+	game.keybindings.register(settingsKey, "cancelDrag", {
+		name: "drag-ruler.keybindings.cancelDrag",
+		onDown: cancelDrag,
+		uneditable: [{
+			key: "Escape",
+		}],
+		precedence: -1,
+	});
+
+	game.keybindings.register(settingsKey, "createWaypoint", {
+		name: "drag-ruler.keybindings.createWaypoint",
+		onDown: handleCreateWaypoint,
+		editable: [{
+			key: "Space"
+		}],
+		precedence: -1,
+	});
+
+	game.keybindings.register(settingsKey, "deleteWaypoint", {
+		name: "drag-ruler.keybindings.deleteWaypoint",
+		onDown: handleDeleteWaypoint,
+		precedence: -1,
+	});
+
+	game.keybindings.register(settingsKey, "disableSnap", {
+		name: "drag-ruler.keybindings.disableSnap.name",
+		hint: "drag-ruler.keybindings.disableSnap.hint",
+		onDown: handleDisableSnap,
+		onUp: handleDisableSnap,
+		editable: [{
+			key: "ShiftLeft",
+		}],
+		precedence: -1,
+	});
+
+	game.keybindings.register(settingsKey, "moveWithoutAnimation", {
+		name: "drag-ruler.keybindings.moveWithoutAnimation.name",
+		hint: "drag-ruler.keybindings.moveWithoutAnimation.hint",
+		onDown: handleMoveWithoutAnimation,
+		onUp: handleMoveWithoutAnimation,
+		editable: [{
+			key: "AltLeft",
+		}],
+		precedence: -1,
+	});
+
+	game.keybindings.register(settingsKey, "togglePathfinding", {
+		name: "drag-ruler.keybindings.togglePathfinding.name",
+		hint: "drag-ruler.keybindings.togglePathfinding.hint",
+		onDown: handleTogglePathfinding,
+		onUp: handleTogglePathfinding,
+		precedence: -1,
+		restricted: !game.settings.get(settingsKey, "allowPathfinding"),
+	});
+}
+
+function handleDeleteWaypoint() {
+	const ruler = canvas.controls.ruler;
+	if (!ruler?.draggedEntity)
+		return false;
+	ruler.dragRulerDeleteWaypoint();
+	return true;
+}
+
+function handleCreateWaypoint() {
+	const ruler = canvas.controls.ruler;
+	// .draggedEntity is used here because .isDragRuler only returns true once the ruler started measuring
+	// Ruler can end up being undefined here if no canvas is active
+	if (!ruler?.draggedEntity)
+		return false;
+
+	let options = {};
+	setSnapParameterOnOptions(ruler, options);
+
+	if (ruler._state === Ruler.STATES.INACTIVE) {
+		ruler.dragRulerStart(options);
+	}
+	else {
+		ruler.dragRulerAddWaypoint(getMeasurePosition(), options);
+	}
+	return true;
+}
+
+function cancelDrag() {
+	const ruler = canvas.controls.ruler;
+	if (!ruler?.draggedEntity)
+		return false;
+	ruler.dragRulerAbortDrag();
+	return true;
+}
+
+function handleDisableSnap(event) {
+	disableSnap = !event.up;
+
+	const ruler = canvas.controls.ruler;
+	if (!ruler?.isDragRuler)
+		return false;
+	if (ruler._state !== Ruler.STATES.MEASURING)
+		return false;
+
+	ruler.measure(getMeasurePosition(), {snap: !disableSnap});
+	ruler.dragRulerSendState();
+	return false;
+}
+
+function handleMoveWithoutAnimation(event) {
+	moveWithoutAnimation = !event.up;
+
+	const ruler = canvas.controls.ruler;
+	if (!ruler?.isDragRuler)
+		return false;
+	if (ruler._state !== Ruler.STATES.MEASURING)
+		return false;
+
+	ruler.measure(getMeasurePosition(), {snap: !disableSnap});
+	ruler.dragRulerSendState();
+	return false;
+}
+
+function handleTogglePathfinding(event) {
+	togglePathfinding = !event.up;
+
+	const ruler = canvas.controls.ruler;
+	if (!ruler?.isDragRuler)
+		return false;
+	if (ruler._state !== Ruler.STATES.MEASURING)
+		return false;
+
+	ruler.measure(getMeasurePosition(), {snap: !disableSnap});
+	ruler.dragRulerSendState();
+	return false;
+}

js/libwrapper_shim.js

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+// Copyright © 2021 fvtt-lib-wrapper Rui Pinheiro
+
+
+'use strict';
+
+// A shim for the libWrapper library
+export let libWrapper = undefined;
+
+export const VERSIONS       = [1,11,0];
+export const TGT_SPLIT_RE   = new RegExp("([^.[]+|\\[('([^'\\\\]|\\\\.)+?'|\"([^\"\\\\]|\\\\.)+?\")\\])", 'g');
+export const TGT_CLEANUP_RE = new RegExp("(^\\['|'\\]$|^\\[\"|\"\\]$)", 'g');
+
+// Main shim code
+Hooks.once('init', () => {
+	// Check if the real module is already loaded - if so, use it
+	if(globalThis.libWrapper && !(globalThis.libWrapper.is_fallback ?? true)) {
+		libWrapper = globalThis.libWrapper;
+		return;
+	}
+
+	// Fallback implementation
+	libWrapper = class {
+		static get is_fallback() { return true };
+
+		static get WRAPPER()  { return 'WRAPPER'  };
+		static get MIXED()    { return 'MIXED'    };
+		static get OVERRIDE() { return 'OVERRIDE' };
+
+		static register(package_id, target, fn, type="MIXED", {chain=undefined}={}) {
+			const is_setter = target.endsWith('#set');
+			target = !is_setter ? target : target.slice(0, -4);
+			const split = target.match(TGT_SPLIT_RE).map((x)=>x.replace(/\\(.)/g, '$1').replace(TGT_CLEANUP_RE,''));
+			const root_nm = split.splice(0,1)[0];
+
+			let obj, fn_name;
+			if(split.length == 0) {
+				obj = globalThis;
+				fn_name = root_nm;
+			}
+			else {
+				const _eval = eval;
+				fn_name = split.pop();
+				obj = split.reduce((x,y)=>x[y], globalThis[root_nm] ?? _eval(root_nm));
+			}
+
+			let iObj = obj;
+			let descriptor = null;
+			while(iObj) {
+				descriptor = Object.getOwnPropertyDescriptor(iObj, fn_name);
+				if(descriptor) break;
+				iObj = Object.getPrototypeOf(iObj);
+			}
+			if(!descriptor || descriptor?.configurable === false) throw `libWrapper Shim: '${target}' does not exist, could not be found, or has a non-configurable descriptor.`;
+
+			let original = null;
+			const wrapper = (chain ?? (type.toUpperCase?.() != 'OVERRIDE' && type != 3)) ? function() { return fn.call(this, original.bind(this), ...arguments); } : function() { return fn.apply(this, arguments); };
+
+			if(!is_setter) {
+				if(descriptor.value) {
+					original = descriptor.value;
+					descriptor.value = wrapper;
+				}
+				else {
+					original = descriptor.get;
+					descriptor.get = wrapper;
+				}
+			}
+			else {
+				if(!descriptor.set) throw `libWrapper Shim: '${target}' does not have a setter`;
+				original = descriptor.set;
+				descriptor.set = wrapper;
+			}
+
+			descriptor.configurable = true;
+			Object.defineProperty(obj, fn_name, descriptor);
+		}
+	}
+});

js/main.js

@@ -0,0 +1,279 @@
+"use strict"
+
+import {getColorForDistanceAndToken, getMovedDistanceFromToken, getRangesFromSpeedProvider, initApi, registerModule, registerSystem} from "./api.js";
+import {checkDependencies, getHexSizeSupportTokenGridCenter} from "./compatibility.js";
+import {moveEntities, onMouseMove} from "./foundry_imports.js"
+import {disableSnap, registerKeybindings} from "./keybindings.js";
+import {libWrapper} from "./libwrapper_shim.js";
+import {performMigrations} from "./migration.js"
+import {removeLastHistoryEntryIfAt, resetMovementHistory} from "./movement_tracking.js";
+import {wipePathfindingCache, initializePathfinding, startBackgroundCaching, terrainRulerWrapper} from "./pathfinding.js";
+import {extendRuler} from "./ruler.js";
+import {registerSettings, RightClickAction, settingsKey} from "./settings.js"
+import {recalculate} from "./socket.js";
+import {SpeedProvider} from "./speed_provider.js"
+import {setSnapParameterOnOptions} from "./util.js";
+
+import initGridlessPathfinding, * as GridlessPathfinding from "../wasm/gridless_pathfinding.js"
+
+CONFIG.debug.dragRuler = false;
+export let debugGraphics = undefined;
+
+initGridlessPathfinding().then(() => {
+	Hooks.on("canvasInit", wipePathfindingCache);
+	Hooks.on("canvasReady", () => {
+		wipePathfindingCache();
+		initializePathfinding();
+	});
+	Hooks.on("createWall", wipePathfindingCache);
+	Hooks.on("updateWall", wipePathfindingCache);
+	Hooks.on("deleteWall", wipePathfindingCache);
+
+	// Whenever the current user selects a token, start caching
+	Hooks.on("controlToken", (token, controlled) => {
+		if (controlled) {
+			startBackgroundCaching(token);
+		}
+	});
+
+	// Whenever a token the current user controls updates, start caching
+	Hooks.on("updateToken", (document) => {
+		const token = document.object;
+		if (token._controlled) {
+			startBackgroundCaching(token);
+		}
+	});
+});
+
+Hooks.once("init", () => {
+	registerSettings()
+	registerKeybindings()
+	initApi()
+	hookDragHandlers(Token);
+	hookDragHandlers(MeasuredTemplate);
+	libWrapper.register("drag-ruler", "TokenLayer.prototype.undoHistory", tokenLayerUndoHistory, "WRAPPER");
+
+	extendRuler();
+
+	window.dragRuler = {
+		getColorForDistanceAndToken,
+		getMovedDistanceFromToken,
+		registerModule,
+		registerSystem,
+		recalculate,
+		resetMovementHistory,
+		private: {
+			terrainRulerWrapper
+		}
+	}
+})
+
+Hooks.once("ready", () => {
+	performMigrations()
+	checkDependencies();
+	Hooks.callAll("dragRuler.ready", SpeedProvider)
+	if (CONFIG.debug.dragRuler)
+		debugGraphics = canvas.controls.addChild(new PIXI.Container());
+})
+
+Hooks.on("canvasReady", () => {
+	canvas.controls.rulers.children.forEach(ruler => {
+		ruler.draggedEntity = null;
+		Object.defineProperty(ruler, "isDragRuler", {
+			get: function isDragRuler() {
+				return Boolean(this.draggedEntity) && this._state !== Ruler.STATES.INACTIVE;
+			}
+		})
+	})
+})
+
+Hooks.on("getCombatTrackerEntryContext", function (html, menu) {
+	const entry = {
+		name: "drag-ruler.resetMovementHistory",
+		icon: '<i class="fas fa-undo-alt"></i>',
+		callback: li => resetMovementHistory(ui.combat.viewed, li.data('combatant-id')),
+	};
+	menu.splice(1, 0, entry);
+});
+
+function forwardIfUnahndled(newFn) {
+	return function(oldFn, ...args) {
+		const eventHandled = newFn(...args);
+		if (!eventHandled)
+			oldFn(...args);
+	};
+}
+
+function hookDragHandlers(entityType) {
+	const entityName = entityType.name
+	libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftStart`, onEntityLeftDragStart, "WRAPPER");
+	if (entityType === Token)
+		libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftMove`, onEntityLeftDragMoveSnap, "WRAPPER");
+	else
+		libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftMove`, onEntityLeftDragMove, "WRAPPER");
+	libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftDrop`, forwardIfUnahndled(onEntityDragLeftDrop), "MIXED");
+	libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftCancel`, forwardIfUnahndled(onEntityDragLeftCancel), "MIXED");
+}
+
+async function tokenLayerUndoHistory(wrapped) {
+	const historyEntry = this.history[this.history.length - 1];
+	const returnValue = await wrapped();
+	if (historyEntry.type === "update") {
+		for (const entry of historyEntry.data) {
+			const token = canvas.tokens.get(entry._id);
+			removeLastHistoryEntryIfAt(token, entry.x, entry.y);
+		}
+	}
+	return returnValue;
+}
+
+function onEntityLeftDragStart(wrapped, event) {
+	wrapped(event);
+	const isToken = this instanceof Token;
+	const ruler = canvas.controls.ruler
+	ruler.draggedEntity = this;
+	let entityCenter;
+	if (isToken && canvas.grid.isHex && game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(this))
+		entityCenter = getHexSizeSupportTokenGridCenter(this);
+	else
+		entityCenter = this.center;
+	ruler.rulerOffset = {x: entityCenter.x - event.data.origin.x, y: entityCenter.y - event.data.origin.y};
+	if (game.settings.get(settingsKey, "autoStartMeasurement")) {
+		let options = {};
+		setSnapParameterOnOptions(ruler, options);
+		ruler.dragRulerStart(options, false);
+	}
+}
+
+function onEntityLeftDragMoveSnap(wrapped, event) {
+	applyGridlessSnapping.call(this, event);
+	onEntityLeftDragMove.call(this, wrapped, event);
+}
+
+function onEntityLeftDragMove(wrapped, event) {
+	wrapped(event);
+	const ruler = canvas.controls.ruler
+	if (ruler.isDragRuler)
+		onMouseMove.call(ruler, event)
+}
+
+function onEntityDragLeftDrop(event) {
+	const ruler = canvas.controls.ruler
+	if (!ruler.isDragRuler) {
+		ruler.draggedEntity = undefined;
+		return false
+	}
+	// When we're dragging a measured template no token will ever be selected,
+	// resulting in only the dragged template to be moved as would be expected
+	const selectedTokens = canvas.tokens.controlled
+	// This can happen if the user presses ESC during drag (maybe there are other ways too)
+	if (selectedTokens.length === 0)
+		selectedTokens.push(ruler.draggedEntity);
+	// This can happen if the ruler is being dragged so rapidly that the drag move handler hasn't been called before dropping
+	if (ruler._state === Ruler.STATES.STARTING)
+		onMouseMove.call(ruler, event);
+	ruler._state = Ruler.STATES.MOVING
+	moveEntities.call(ruler, ruler.draggedEntity, selectedTokens);
+	return true
+}
+
+function onEntityDragLeftCancel(event) {
+	// This function is invoked by right clicking
+	const ruler = canvas.controls.ruler
+	if (!ruler.draggedEntity || ruler._state === Ruler.STATES.MOVING)
+		return false
+
+	const rightClickAction = game.settings.get(settingsKey, "rightClickAction");
+	let options = {};
+	setSnapParameterOnOptions(ruler, options);
+
+	if (ruler._state === Ruler.STATES.INACTIVE) {
+		if (rightClickAction !== RightClickAction.CREATE_WAYPOINT)
+			return false;
+		ruler.dragRulerStart(options);
+		event.preventDefault();
+	}
+	else if (ruler._state === Ruler.STATES.MEASURING) {
+		switch (rightClickAction) {
+			case RightClickAction.CREATE_WAYPOINT:
+				event.preventDefault();
+				ruler.dragRulerAddWaypoint(ruler.destination, options);
+				break;
+			case RightClickAction.DELETE_WAYPOINT:
+				ruler.dragRulerDeleteWaypoint(event, options);
+				break;
+			case RightClickAction.ABORT_DRAG:
+				ruler.dragRulerAbortDrag();
+				break;
+		}
+	}
+	return true;
+}
+
+function applyGridlessSnapping(event) {
+	const ruler = canvas.controls.ruler;
+	if (!game.settings.get(settingsKey, "useGridlessRaster"))
+		return;
+	if (!ruler.isDragRuler)
+		return;
+	if (disableSnap)
+		return;
+	if (canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS)
+		return;
+
+	const rasterWidth = 35 / canvas.stage.scale.x;
+	const tokenX = event.data.destination.x;
+	const tokenY = event.data.destination.y;
+	const destination = {x: tokenX + ruler.rulerOffset.x, y: tokenY + ruler.rulerOffset.y};
+	const ranges = getRangesFromSpeedProvider(ruler.draggedEntity);
+
+	const terrainRulerAvailable = game.modules.get("terrain-ruler")?.active;
+	if (terrainRulerAvailable) {
+		const segments = Ruler.dragRulerGetRaysFromWaypoints(ruler.waypoints, destination).map(ray => {return {ray}});
+		const pinpointDistances = new Map();
+		for (const range of ranges) {
+			pinpointDistances.set(range.range, null);
+		}
+		terrainRuler.measureDistances(segments, {pinpointDistances});
+		const targetDistance = Array.from(pinpointDistances.entries())
+			.filter(([_key, val]) => val)
+			.reduce((value, current) => value[0] > current[0] ? value : current, [0, null]);
+		const rasterLocation = targetDistance[1];
+		if (rasterLocation) {
+			const deltaX = destination.x - rasterLocation.x;
+			const deltaY = destination.y - rasterLocation.y;
+			const rasterDistance = Math.hypot(deltaX, deltaY);
+			if (rasterDistance < rasterWidth) {
+				event.data.destination.x = rasterLocation.x - ruler.rulerOffset.x;
+				event.data.destination.y = rasterLocation.y - ruler.rulerOffset.y;
+			}
+		}
+	}
+	else {
+		let waypointDistance = 0;
+		let origin = event.data.origin;
+		if (ruler.waypoints.length > 1) {
+			const segments = Ruler.dragRulerGetRaysFromWaypoints(ruler.waypoints, destination).map(ray => {return {ray}});
+			origin = segments.pop().ray.A;
+			waypointDistance = canvas.grid.measureDistances(segments).reduce((a, b) => a + b);
+			origin = {x: origin.x - ruler.rulerOffset.x, y: origin.y - ruler.rulerOffset.y};
+		}
+
+		const deltaX = tokenX - origin.x;
+		const deltaY = tokenY - origin.y;
+		const distance = Math.hypot(deltaX, deltaY);
+		// targetRange will be the largest range that's still smaller than distance
+		let targetDistance = ranges
+			.map(range => range.range)
+			.map(range => range - waypointDistance)
+			.map(range => range * canvas.dimensions.size / canvas.dimensions.distance)
+			.filter(range => range < distance)
+			.reduce((a, b) => Math.max(a, b), 0);
+		if (targetDistance) {
+			if (distance < targetDistance + rasterWidth) {
+				event.data.destination.x = origin.x + deltaX * targetDistance / distance;
+				event.data.destination.y = origin.y + deltaY * targetDistance / distance;
+			}
+		}
+	}
+}

js/migration.js

@@ -0,0 +1,43 @@
+import {RightClickAction, settingsKey} from "./settings.js"
+
+const currentDataVersion = "1.10.0"
+
+export async function performMigrations() {
+	if (game.user.isGM)
+		await performWorldMigraionts()
+	await performClientMigrations()
+}
+
+async function performWorldMigraionts() {
+	let dataVersion = game.settings.get(settingsKey, "dataVersion");
+
+	if (dataVersion === currentDataVersion)
+		return;
+
+	if (dataVersion === "fresh install") {
+		game.settings.set(settingsKey, "dataVersion", currentDataVersion)
+		return
+	}
+
+	if (dataVersion === "1.3.0") {
+		dataVersion = "1.10.0"
+	}
+
+	game.settings.set(settingsKey, "dataVersion", dataVersion);
+}
+
+async function performClientMigrations() {
+	let dataVersion = game.settings.get(settingsKey, "clientDataVersion");
+
+	if (dataVersion === "fresh install") {
+		// Start of migration from unnamed version (< 1.10.0). TODO Remove in a future version
+		const swapSpacebarRightClick = game.settings.storage.get("client").getItem(`${settingsKey}.swapSpacebarRightClick`);
+		if (swapSpacebarRightClick) {
+			game.settings.set(settingsKey, "rightClickAction", RightClickAction.CREATE_WAYPOINT);
+			await game.keybindings.set(settingsKey, "createWaypoint", []);
+			await game.keybindings.set(settingsKey, "deleteWaypoint", [{key: "Space"}]);
+		}
+		// End of migration from unnamed version
+		game.settings.set(settingsKey, "clientDataVersion", currentDataVersion)
+	}
+}

js/movement_tracking.js

@@ -1,6 +1,6 @@
 import {measureDistances} from "./compatibility.js";
 import {recalculate, updateCombatantDragRulerFlags} from "./socket.js";
-import {getTokenShape, zip} from "./util.js";
+import {getTokenShape, isClose, zip} from "./util.js";
 
 function initTrackingFlag(combatant) {
 	const initialFlag = {passedWaypoints: [], trackedRound: 0};
@@ -49,14 +49,14 @@ function calculateUpdate(combat, token, rays) {
 	}
 
 	// Add the passed waypoints to the combatant
-	const terrainRulerAvailable = game.modules.get("terrain-ruler")?.active && (!game.modules.get("TerrainLayer")?.active || canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS);
+	const terrainRulerAvailable = game.modules.get("terrain-ruler")?.active;
 	const dragRulerFlags = combatant.data.flags.dragRuler;
 	const waypoints = dragRulerFlags.passedWaypoints;
 	for (const ray of rays) {
 		// Ignore rays that have the same start and end coordinates
 		if (ray.A.x !== ray.B.x || ray.A.y !== ray.B.y) {
 			if (terrainRulerAvailable) {
-				measureDistances([{ray}], token, getTokenShape(token), {terrainRulerInitialState: waypoints[waypoints.length - 1]?.dragRulerFinalState});
+				measureDistances([{ray}], token, getTokenShape(token), {terrainRulerInitialState: waypoints[waypoints.length - 1]?.dragRulerFinalState, enableTerrainRuler: terrainRulerAvailable});
 				ray.A.dragRulerVisitedSpaces = ray.terrainRulerVisitedSpaces;
 				ray.A.dragRulerFinalState = ray.terrainRulerFinalState;
 			}
@@ -81,6 +81,20 @@ export function getMovementHistory(token) {
 	return dragRulerFlags.passedWaypoints ?? [];
 }
 
+export async function removeLastHistoryEntryIfAt(token, x, y) {
+	const history = getMovementHistory(token);
+	if (history.length === 0)
+		return;
+	const entry = history[history.length - 1];
+	if (!isClose(x + token.w / 2, entry.x, 0.1) || !isClose(y + token.h / 2, entry.y, 0.1)) {
+		return;
+	}
+	history.pop();
+	const combat = game.combat;
+	const combatant = combat.getCombatantByToken(token.id);
+	await updateCombatantDragRulerFlags(combat, [{_id: combatant.id, dragRulerFlags: combatant.data.flags.dragRuler}]);
+}
+
 export async function resetMovementHistory(combat, combatantId) {
 	const combatant = combat.combatants.get(combatantId);
 	const dragRulerFlags = combatant.data.flags.dragRuler;

js/pathfinding.js

@@ -0,0 +1,514 @@
+import {getCenterFromGridPositionObj, getGridPositionFromPixelsObj, getPixelsFromGridPositionObj} from "./foundry_fixes.js";
+import {moveWithoutAnimation, togglePathfinding} from "./keybindings.js";
+import {debugGraphics} from "./main.js";
+import {settingsKey} from "./settings.js";
+import {buildSnapPointTokenData, getSnapPointForTokenDataObj, getTokenShape, getTokenShapeForTokenData, isModuleActive, iterPairs} from "./util.js";
+
+import * as GridlessPathfinding from "../wasm/gridless_pathfinding.js";
+import {PriorityQueueSet, ProcessOnceQueue} from "./data_structures.js";
+import {buildCostFunction} from "./api.js";
+
+class CacheLayer {
+	constructor(tokenData, cacheId) {
+		this.tokenData = tokenData;
+		this.cacheId = cacheId;
+		this.queue = new ProcessOnceQueue();
+
+		this.buildNodes();
+		this.registerUse();
+	}
+
+	buildNodes() {
+		this.nodes = new Array(gridHeight);
+		for (let y = 0; y < gridHeight; y++) {
+			this.nodes[y] = new Array(gridWidth);
+			for (let x = 0; x < gridWidth; x++) {
+				this.nodes[y][x] = {x, y};
+			}
+		}
+	}
+
+	registerUse() {
+		this.lastUsed = Date.now();
+	}
+}
+
+/**
+ * Class to hold all the cached node data, and functions to deal with caching.
+ *
+ * Since pathfinding can depend on several factors, e.g. the token's size, we keep
+ * several caches, keyed by all the data relevant to pathfinding. If we already have
+ * the maximum number of caches and we need to create another one, we discard the
+ * one not used for the longest.
+ *
+ * When we select a token, or a token we have selected updates, we start caching
+ * in the background so, when we do start pathfinding, it's very performant.
+ *
+ * Background caching starts by trying to run an idle process (when the browser is
+ * otherwise not busy), but if it can't do that after an amount of time (e.g. the
+ * CPU is very slow and is busy) then we instead start caching a few nodes each
+ * frame.
+ */
+class Cache {
+	static maxCacheLayers = 5;
+	static maxBackgroundCachingMillis = 10;
+	static maxAnimationCachingMillis = 5;
+	static backgroundCachingTimeoutMillis = 200;
+
+	constructor() {
+		this.layers = new Map();
+		this.background = {
+			nextJobId: null,
+			nextTimeoutId: null,
+			nextAnimationFrameId: null
+		}
+	}
+
+	clear() {
+		this.layers.clear();
+		if (this.background.nextJobId) {
+			window.cancelIdleCallback(this.background.nextJobId);
+			this.background.nextJobId = null;
+		}
+		this.cancelTimeout();
+		this.cancelAnimationFrame();
+	}
+
+	/**
+	 * Retrieve the cache layer for this token, using information that can make a difference to the pathfinding algorithm
+	 * If a layer that suits this token doesn't exist, create one
+	 */
+	getCacheLayer(token) {
+		const tokenData = buildTokenData(token);
+		// TODO Request this from the speed providers so they can set their own options
+		let terrainData = canvas.terrain.listAllTerrain({token});
+		terrainData = terrainData.map(data => {
+			return {
+				x: data.object.x,
+				y: data.object.y,
+				cost: data.cost,
+				shape: data.shape,
+			};
+		});
+		const cacheIdData = {tokenData, terrainData};
+		const cacheId = GridlessPathfinding.sha1(JSON.stringify(cacheIdData));
+		let cacheLayer = this.layers.get(cacheId);
+		// If we don't already have a cache layer for this cache ID, create one now
+		if (!cacheLayer) {
+			// Check if we already have the max number of layers. If we do,
+			// get rid of the one that hasn't been used for the longest
+			if (this.layers.size >= Cache.maxCacheLayers) {
+				const oldestCache = Array.from(this.layers.values())
+					.reduce((layer1, layer2) => (layer1?.lastUsed < layer2.lastUsed) ? layer1 : layer2, null);
+				this.layers.delete(oldestCache.cacheId);
+			}
+
+			// Create the new cache
+			cacheLayer = new CacheLayer(tokenData, cacheId);
+			this.layers.set(cacheId, cacheLayer);
+		} else {
+			// Register that we're using this cache right now
+			cacheLayer.registerUse();
+		}
+
+		return cacheLayer;
+	}
+
+	/**
+	 * Start background caching from the token's current position
+	 */
+	startBackgroundCaching(token) {
+		const cacheLayer = this.getCacheLayer(token);
+		const tokenPosition = getGridPositionFromPixelsObj(token.position)
+
+		cacheLayer.queue.push(cacheLayer.nodes[tokenPosition.y][tokenPosition.x]);
+
+		this.scheduleBackgroundCache();
+	}
+
+	/**
+	 * Find if any of the caches have more nodes to background cache. If there is, then schedule a background
+	 * caching job for that queue
+	 */
+	scheduleBackgroundCache() {
+		// If we already have a nextJobId, then don't start another one
+		if (this.background.nextJobId) return;
+
+		// Find the latest-used cache that has nodes left to cache
+		const latestCache = this.getLatestCacheWithNonEmptyQueue();
+		if (latestCache) {
+			this.background.nextJobId = window.requestIdleCallback(
+				() => this.runBackgroundCache(latestCache)
+			);
+			this.resetAnimationFrameTimeout();
+		}
+	}
+
+	/**
+	 * Start a timeout which, if we reach the timeout time, will schedule a small amount of caching
+	 * to be performed every frame. This timeout will be reset every time we perform background caching.
+	 */
+	resetAnimationFrameTimeout() {
+		this.cancelTimeout();
+		this.cancelAnimationFrame();
+
+		this.background.nextTimeoutId = window.setTimeout(
+			() => {
+				this.scheduleAnimationFrameCache();
+				this.background.nextTimeoutId = null;
+			},
+			Cache.backgroundCachingTimeoutMillis
+		);
+	}
+
+	/**
+	 * Schedule a small amount of caching to be done just before the next frame renders
+	 */
+	scheduleAnimationFrameCache() {
+		const latestCache = this.getLatestCacheWithNonEmptyQueue();
+		if (latestCache) {
+			this.background.nextAnimationFrameId = window.requestAnimationFrame(
+				() => this.runAnimationCache(latestCache)
+			);
+		}
+	}
+
+	/**
+	 * Find which cache was last used and get its cache ID
+	 */
+	getLatestCacheWithNonEmptyQueue() {
+		return Array.from(this.layers.values())
+			.filter(layer => layer.queue.hasNext())
+			.reduce((layer1, layer2) => (layer1?.lastUsed > layer2.lastUsed) ? layer1 : layer2, null);
+	}
+
+	/**
+	 * Cache nodes for a short time, and then schedule another idle job to cache more nodes
+	 */
+	runBackgroundCache(cacheLayer) {
+		const endTime = performance.now() + Cache.maxBackgroundCachingMillis;
+		while (cacheLayer.queue.hasNext() && performance.now() < endTime) {
+			this.cacheNextNode(cacheLayer);
+		}
+
+		this.background.nextJobId = null;
+		this.scheduleBackgroundCache();
+	}
+
+	/**
+	 * Cache nodes for a very short time, then schedule to cache more nodes next frame
+	 */
+	runAnimationCache(cacheLayer) {
+		const endTime = performance.now() + Cache.maxAnimationCachingMillis;
+		while (cacheLayer.queue.hasNext() && performance.now() < endTime) {
+			this.cacheNextNode(cacheLayer);
+		}
+
+		this.background.nextAnimationFrameId = null;
+		this.scheduleAnimationFrameCache();
+	}
+
+	cacheNextNode(cacheLayer) {
+		let node = cacheLayer.queue.pop();
+		getNode(node, cacheLayer);
+		for (let edge of node.edges) {
+			cacheLayer.queue.push(edge.target);
+		}
+	}
+
+	cancelTimeout() {
+		if (this.background.nextTimeoutId) {
+			window.clearTimeout(this.background.nextTimeoutId);
+			this.background.nextTimeoutId = null;
+		}
+	}
+
+	cancelAnimationFrame() {
+		if (this.background.nextAnimationFrameId) {
+			window.cancelAnimationFrame(this.background.nextAnimationFrameId);
+			this.background.nextAnimationFrameId = null;
+		}
+	}
+}
+
+const cache = new Cache();
+
+let use5105 = false;
+let gridlessPathfinders = new Map();
+let gridWidth, gridHeight;
+
+export function isPathfindingEnabled() {
+	if (this.user !== game.user)
+		return false;
+	if (!game.user.isGM && !game.settings.get(settingsKey, "allowPathfinding"))
+		return false;
+	if (moveWithoutAnimation)
+		return false;
+	return game.settings.get(settingsKey, "autoPathfinding") != togglePathfinding;
+}
+
+export function findPath(from, to, token, previousWaypoints) {
+	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
+		let tokenSize = Math.max(token.data.width, token.data.height) * canvas.dimensions.size;
+		let pathfinder = gridlessPathfinders.get(tokenSize);
+		if (!pathfinder) {
+			let radiusMultiplier = game.settings.get(settingsKey, "pathfindingRadius");
+			// TODO Pass proper options to listAllTerrain
+			// TODO Wipe caches when they become invalid
+			// TODO Multiple caches, analog to gridded pathfinding
+			pathfinder = GridlessPathfinding.initialize(canvas.walls.placeables, canvas.terrain.listAllTerrain(), tokenSize * radiusMultiplier, token.data.elevation, Boolean(game.modules.get("wall-height")?.active));
+			gridlessPathfinders.set(tokenSize, pathfinder);
+		}
+		paintGridlessPathfindingDebug(pathfinder);
+		return GridlessPathfinding.findPath(pathfinder, from, to);
+	} else {
+		const cacheLayer = cache.getCacheLayer(token);
+		const firstNode = calculatePath(from, to, cacheLayer, previousWaypoints);
+		if (!firstNode)
+			return null;
+		paintGriddedPathfindingDebug(firstNode, cacheLayer.tokenData);
+		const path = [];
+		let currentNode = firstNode;
+		while (currentNode) {
+			if (path.length >= 2 && !stepCollidesWithWall(path[path.length - 2], currentNode.node, cacheLayer.tokenData)) {
+				// Replace last waypoint if the current waypoint leads to a valid path that isn't longer than the old path
+				if (window.terrainRuler) {
+					let startNode = getCenterFromGridPositionObj(path[path.length - 2]);
+					let middleNode = getCenterFromGridPositionObj(path[path.length - 1]);
+					let endNode = getCenterFromGridPositionObj(currentNode.node);
+					let oldPath = [{ray: new Ray(startNode, middleNode)}, {ray: new Ray(middleNode, endNode)}];
+					let newPath = [{ray: new Ray(startNode, endNode)}];
+					let costFunction = buildCostFunction(token, getTokenShape(token));
+					// TODO Cache the used measurement for use in the next loop to improve performance
+					let oldDistance = terrainRuler.measureDistances(oldPath, {costFunction}).reduce((a, b) => a + b);
+					let newDistance = terrainRuler.measureDistances(newPath, {costFunction})[0];
+
+					// TODO We might need to check if the diagonal count has increased on 5-10-5
+					if (newDistance < oldDistance)  {
+						path.pop();
+					}
+					else if (newDistance === oldDistance) {
+						let oldNoDiagonals = oldPath[1].ray.terrainRulerFinalState?.noDiagonals;
+						let newNoDiagonals = newPath[0].ray.terrainRulerFinalState?.noDiagonals;
+						// This uses === && < instead of <= because the variables might be undefined (which shall lead to a true result)
+						if (oldNoDiagonals === newNoDiagonals || newNoDiagonals < oldNoDiagonals) {
+							path.pop();
+						}
+					}
+				}
+				else {
+					path.pop();
+				}
+			}
+			path.push({x: currentNode.node.x, y: currentNode.node.y});
+			currentNode = currentNode.next;
+		}
+		return path;
+	}
+}
+
+export function terrainRulerWrapper(from, to) {
+	// TODO Send list of terrain to terrain layer
+	const ray = new Ray(from, to);
+	return terrainRuler.measureDistances([{ray}])[0] / canvas.dimensions.distance * canvas.dimensions.size;
+}
+
+function buildTokenData(token) {
+	// Almost all the information we need is for calculating the snap point
+	const tokenData = buildSnapPointTokenData(token);
+
+	// If Wall Height is enabled, which walls matter depends on the token's elevation.
+	// Depending on the settings in Wall Height, the height we care about is either their
+	// foot height (elevation) or eye height (losHeight).
+	if (isModuleActive("wall-height")) {
+		const blockSightMovement = game.settings.get("wall-height", "blockSightMovement");
+		tokenData.elevation = blockSightMovement ? token.losHeight : token.data.elevation;
+	}
+
+	return tokenData;
+}
+
+function getNode(pos, cacheLayer, initialize = true) {
+	const node = cacheLayer.nodes[pos.y][pos.x];
+	if (initialize && !node.edges) {
+		node.edges = [];
+		for (const neighborPos of canvas.grid.grid.getNeighbors(pos.y, pos.x).map(([y, x]) => {return {x, y};})) {
+			if (neighborPos.x < 0 || neighborPos.y < 0 || neighborPos.x >= gridWidth || neighborPos.y >= gridHeight) {
+				continue;
+			}
+
+			// TODO Work with pixels instead of grid locations
+			if (!stepCollidesWithWall(pos, neighborPos, cacheLayer.tokenData)) {
+				const isDiagonal = node.x !== neighborPos.x && node.y !== neighborPos.y && canvas.grid.type === CONST.GRID_TYPES.SQUARE;
+				let edgeCost;
+				if (window.terrainRuler) {
+					let ray = new Ray(getCenterFromGridPositionObj(pos), getCenterFromGridPositionObj(neighborPos));
+					let measuredDistance = terrainRuler.measureDistances([{ray}], {costFunction: buildCostFunction(cacheLayer.tokenData, getTokenShapeForTokenData(cacheLayer.tokenData))})[0];
+					edgeCost = Math.round(measuredDistance / canvas.dimensions.distance);
+					if (ray.terrainRulerFinalState?.noDiagonals === 1) {
+						edgeCost = 1.5;
+					}
+					// Charge 1.0001 instead of 1 for diagonals to discourage unnecessary diagonals
+					if (isDiagonal && edgeCost == 1) {
+						edgeCost = 1.0001;
+					}
+				}
+				else {
+					// Count 5-10-5 diagonals as 1.5 (so two add up to 3) and 5-5-5 diagonals as 1.0001 (to discourage unnecessary diagonals)
+					// TODO Account for difficult terrain
+					edgeCost = isDiagonal ? (use5105 ? 1.5 : 1.0001) : 1;
+				}
+				const neighbor = getNode(neighborPos, cacheLayer, false);
+				node.edges.push({target: neighbor, cost: edgeCost});
+			}
+		}
+	}
+	return node;
+}
+
+function calculatePath(from, to, cacheLayer, previousWaypoints) {
+	use5105 = game.system.id === "pf2e" || canvas.grid.diagonalRule === "5105";
+	let startCost = 0;
+	if (use5105 && canvas.grid.type === CONST.GRID_TYPES.SQUARE) {
+		previousWaypoints = previousWaypoints.map(w => getGridPositionFromPixelsObj(w));
+		startCost = (calcNoDiagonals(previousWaypoints) % 2) * 0.5;
+	}
+
+	const nextNodes = new PriorityQueueSet((node1, node2) => node1.node === node2.node, node => node.estimated);
+	const previousNodes = new Set();
+
+	nextNodes.pushWithPriority(
+		{
+			node: getNode(from, cacheLayer),
+			cost: startCost,
+			estimated: startCost + estimateCost(from, to),
+			previous: null
+		}
+	);
+
+	while (nextNodes.hasNext()) {
+		// Get node with cheapest estimate
+		const currentNode = nextNodes.pop();
+		if (currentNode.node.x === to.x && currentNode.node.y === to.y) {
+			return buildPathNodes(currentNode);
+		}
+		previousNodes.add(currentNode.node);
+		for (const edge of currentNode.node.edges) {
+			const neighborNode = getNode(edge.target, cacheLayer);
+			if (previousNodes.has(neighborNode)) {
+				continue;
+			}
+
+			const neighbor = {
+				node: neighborNode,
+				cost: currentNode.cost + edge.cost,
+				estimated: currentNode.cost + edge.cost + estimateCost(neighborNode, to),
+				previous: currentNode
+			};
+			nextNodes.pushWithPriority(neighbor);
+		}
+	}
+}
+
+/**
+ * Now we've found the path, we know the final node, and each node links to the previous one.
+ * Reverse this list and return the first node in the path, with each node linking to the next
+ */
+function buildPathNodes(lastNode) {
+	let currentNode = lastNode;
+	let previousNode = null;
+	while (currentNode) {
+		const pathNode = {
+			node: currentNode.node,
+			cost: currentNode.cost,
+			next: previousNode
+		}
+		previousNode = pathNode;
+		currentNode = currentNode.previous;
+	}
+	return previousNode;
+}
+
+function calcNoDiagonals(waypoints) {
+	let diagonals = 0;
+	for (const [p1, p2] of iterPairs(waypoints)) {
+		diagonals += Math.min(Math.abs(p1.x - p2.x), Math.abs(p1.y - p2.y));
+	}
+	return diagonals;
+}
+
+/**
+ * Estimate the travel distance between two points, as the crow flies. Most of the time, this is 1
+ * per space, but for a square grid using 5-10-5 diagonals, count each diagonal as an extra 0.5
+ */
+function estimateCost(pos, target) {
+	const distX = Math.abs(pos.x - target.x);
+	const distY = Math.abs(pos.y - target.y);
+	return Math.max(distX, distY) + (use5105 ? Math.min(distX, distY) * 0.5 : 0);
+}
+
+function stepCollidesWithWall(from, to, tokenData) {
+	const stepStart = getSnapPointForTokenDataObj(getPixelsFromGridPositionObj(from), tokenData);
+	const stepEnd = getSnapPointForTokenDataObj(getPixelsFromGridPositionObj(to), tokenData);
+	if (isModuleActive("levels")) {
+		stepStart.z = tokenData.elevation;
+		stepEnd.z = tokenData.elevation;
+		return _levels.testCollision(stepStart, stepEnd, "collision")
+	} else {
+		return canvas.walls.checkCollision(new Ray(stepStart, stepEnd));
+	}
+}
+
+export function wipePathfindingCache() {
+	cache.clear();
+	for (const pathfinder of gridlessPathfinders.values()) {
+		GridlessPathfinding.free(pathfinder);
+	}
+	gridlessPathfinders.clear();
+	if (debugGraphics)
+		debugGraphics.removeChildren().forEach(c => c.destroy());
+}
+
+export function initializePathfinding() {
+	gridWidth = Math.ceil(canvas.dimensions.width / canvas.grid.w);
+	gridHeight = Math.ceil(canvas.dimensions.height / canvas.grid.h);
+}
+
+export function startBackgroundCaching(token) {
+	// Background caching isn't yet supported for gridless scenes
+	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS)
+		return;
+	if (game.user.isGM || game.settings.get(settingsKey, "allowPathfinding")) {
+		cache.startBackgroundCaching(token);
+	}
+}
+
+function paintGriddedPathfindingDebug(firstNode, tokenData) {
+	if (!CONFIG.debug.dragRuler)
+		return;
+
+	debugGraphics.removeChildren().forEach(c => c.destroy());
+	let currentNode = firstNode;
+	while (currentNode) {
+		let text = new PIXI.Text(currentNode.cost.toFixed(1));
+		let pixels = getSnapPointForTokenDataObj(getPixelsFromGridPositionObj(currentNode.node), tokenData);
+		text.anchor.set(0.5, 1.0);
+		text.x = pixels.x;
+		text.y = pixels.y;
+		debugGraphics.addChild(text);
+		currentNode = currentNode.next;
+	}
+}
+
+function paintGridlessPathfindingDebug(pathfinder) {
+	if (!CONFIG.debug.dragRuler)
+		return;
+
+	debugGraphics.removeChildren().forEach(c => c.destroy());
+	let graphic = new PIXI.Graphics();
+	graphic.lineStyle(2, 0x440000);
+	for (const point of GridlessPathfinding.debugGetPathfindingPoints(pathfinder)) {
+		graphic.drawCircle(point.x, point.y, 5);
+	}
+	debugGraphics.addChild(graphic);
+}

js/ruler.js

@@ -0,0 +1,215 @@
+import {currentSpeedProvider, getColorForDistanceAndToken, getRangesFromSpeedProvider} from "./api.js";
+import {getHexSizeSupportTokenGridCenter} from "./compatibility.js";
+import {cancelScheduledMeasurement, measure} from "./foundry_imports.js"
+import {getMovementHistory} from "./movement_tracking.js";
+import {settingsKey} from "./settings.js";
+import {getSnapPointForEntity} from "./util.js";
+
+export function extendRuler() {
+	class DragRulerRuler extends Ruler {
+		// Functions below are overridden versions of functions in Ruler
+		constructor(user, {color=null}={}) {
+			super(user, {color});
+			this.previousWaypoints = [];
+			this.previousLabels = this.addChild(new PIXI.Container());
+		}
+
+		clear() {
+			super.clear();
+			this.previousWaypoints = [];
+			this.previousLabels.removeChildren().forEach(c => c.destroy());
+			this.dragRulerRanges = undefined;
+			cancelScheduledMeasurement.call(this);
+		}
+
+		async moveToken(event) {
+			// Disable moveToken if Drag Ruler is active
+			if (!this.isDragRuler)
+				return await super.moveToken(event);
+		}
+
+		toJSON() {
+			const json = super.toJSON();
+			if (this.draggedEntity) {
+				const isToken = this.draggedEntity instanceof Token;
+				json.draggedEntityIsToken = isToken;
+				json.draggedEntity = this.draggedEntity.id;
+				json.waypoints = json.waypoints.map(old => {
+					let w = duplicate(old);
+					w.isPathfinding = undefined;
+					return w;
+				});
+			}
+			return json;
+		}
+
+		update(data) {
+			// Don't show a GMs drag ruler to non GM players
+			if (data.draggedEntity && this.user.isGM && !game.user.isGM && !game.settings.get(settingsKey, "showGMRulerToPlayers"))
+				return;
+
+			if (data.draggedEntity) {
+				if (data.draggedEntityIsToken)
+					this.draggedEntity = canvas.tokens.get(data.draggedEntity);
+				else
+					this.draggedEntity = canvas.templates.get(data.draggedEntity);
+			}
+			else {
+				this.draggedEntity = undefined;
+			}
+
+			super.update(data);
+		}
+
+		measure(destination, options={}) {
+			if (this.isDragRuler) {
+				// If this is the ruler of a remote user take the waypoints as they were transmitted and don't apply any additional snapping to them
+				if (this.user !== game.user)
+					options.snap = false;
+				return measure.call(this, destination, options);
+			}
+			else {
+				return super.measure(destination, options);
+			}
+		}
+
+		_endMeasurement() {
+			super._endMeasurement();
+			this.draggedEntity = null;
+		}
+
+		// The functions below aren't present in the orignal Ruler class and are added by Drag Ruler
+		dragRulerAddWaypoint(point, options={}) {
+			options.snap = options.snap ?? true;
+			if (options.snap) {
+				point = getSnapPointForEntity(point.x, point.y, this.draggedEntity);
+			}
+			this.waypoints.push(new PIXI.Point(point.x, point.y));
+			this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
+			this.waypoints.filter(waypoint => waypoint.isPathfinding).forEach(waypoint => waypoint.isPathfinding = false);
+		}
+
+		dragRulerAddWaypointHistory(waypoints) {
+			waypoints.forEach(waypoint => waypoint.isPrevious = true);
+			this.waypoints = this.waypoints.concat(waypoints);
+			for (const waypoint of waypoints) {
+				this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
+			}
+		}
+
+		dragRulerClearWaypoints() {
+			this.waypoints = [];
+			this.labels.removeChildren().forEach(c => c.destroy());
+		}
+
+		dragRulerDeleteWaypoint(event={preventDefault: () => {return}}, options={}) {
+			this.dragRulerRemovePathfindingWaypoints();
+			options.snap = options.snap ?? true;
+			if (this.waypoints.filter(w => !w.isPrevious).length > 1) {
+				event.preventDefault();
+				const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens);
+				const rulerOffset = this.rulerOffset;
+
+				// Options are not passed to _removeWaypoint in vanilla Foundry.
+				// Send them in case other modules have overriden that behavior and accept an options parameter (Toggle Snap to Grid)
+				this._removeWaypoint({x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y}, options);
+				game.user.broadcastActivity({ruler: this});
+			}
+			else {
+				this.dragRulerAbortDrag(event);
+			}
+		}
+
+		dragRulerRemovePathfindingWaypoints() {
+			this.waypoints.filter(waypoint => waypoint.isPathfinding).forEach(_ => this.labels.removeChild(this.labels.children[this.labels.children.length - 1]).destroy());
+			this.waypoints = this.waypoints.filter(waypoint => !waypoint.isPathfinding);
+		}
+
+		dragRulerAbortDrag(event={preventDefault: () => {return}}) {
+			const token = this.draggedEntity;
+			this._endMeasurement();
+
+			// Deactivate the drag workflow in mouse
+			token.mouseInteractionManager._deactivateDragEvents();
+			token.mouseInteractionManager.state = token.mouseInteractionManager.states.HOVER;
+
+			// This will cancel the current drag operation
+			// Pass in a fake event that hopefully is enough to allow other modules to function
+			token._onDragLeftCancel(event);
+		}
+
+		async dragRulerRecalculate(tokenIds) {
+			if (this._state !== Ruler.STATES.MEASURING)
+				return;
+			if (tokenIds && !tokenIds.includes(this.draggedEntity.id))
+				return;
+			const waypoints = this.waypoints.filter(waypoint => !waypoint.isPrevious);
+			this.dragRulerClearWaypoints();
+			if (game.settings.get(settingsKey, "enableMovementHistory"))
+				this.dragRulerAddWaypointHistory(getMovementHistory(this.draggedEntity));
+			for (const waypoint of waypoints) {
+				this.dragRulerAddWaypoint(waypoint, {snap: false});
+			}
+			this.measure(this.destination);
+			game.user.broadcastActivity({ruler: this});
+		}
+
+		static dragRulerGetRaysFromWaypoints(waypoints, destination) {
+			if ( destination )
+				waypoints = waypoints.concat([destination]);
+			return waypoints.slice(1).map((wp, i) => {
+				const ray =  new Ray(waypoints[i], wp);
+				ray.isPrevious = Boolean(waypoints[i].isPrevious);
+				return ray;
+			});
+		}
+
+		dragRulerGetColorForDistance(distance) {
+			if (!this.isDragRuler)
+				return this.color;
+			if (!this.draggedEntity.actor) {
+				return this.color;
+			}
+			// Don't apply colors if the current user doesn't have at least observer permissions
+			if (this.draggedEntity.actor.permission < 2) {
+				// If this is a pc and alwaysShowSpeedForPCs is enabled we show the color anyway
+				if (!(this.draggedEntity.actor.data.type === "character" && game.settings.get(settingsKey, "alwaysShowSpeedForPCs")))
+					return this.color;
+			}
+			distance = Math.round(distance * 100) / 100;
+			if (!this.dragRulerRanges)
+				this.dragRulerRanges = getRangesFromSpeedProvider(this.draggedEntity);
+			return getColorForDistanceAndToken(distance, this.draggedEntity, this.dragRulerRanges) ?? this.color;
+		}
+
+		dragRulerStart(options, measureImmediately=true) {
+			const entity = this.draggedEntity;
+			const isToken = entity instanceof Token;
+			if (isToken && !currentSpeedProvider.usesRuler(entity))
+				return;
+			const ruler = canvas.controls.ruler;
+			ruler.clear();
+			ruler._state = Ruler.STATES.STARTING;
+			let entityCenter;
+			if (isToken && canvas.grid.isHex && game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(entity))
+				entityCenter = getHexSizeSupportTokenGridCenter(entity);
+			else
+				entityCenter = entity.center;
+			if (isToken && game.settings.get(settingsKey, "enableMovementHistory"))
+				ruler.dragRulerAddWaypointHistory(getMovementHistory(entity));
+			ruler.dragRulerAddWaypoint(entityCenter, {snap: false});
+			const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens);
+			const destination = {x: mousePosition.x + ruler.rulerOffset.x, y: mousePosition.y + ruler.rulerOffset.y};
+			if (measureImmediately)
+				ruler.measure(destination, options);
+		}
+
+		dragRulerSendState() {
+			game.user.broadcastActivity({
+				ruler: this.toJSON()
+			});
+		}
+	}
+
+	Ruler = DragRulerRuler;
+}

js/settings.js

@@ -1,8 +1,20 @@
 import {availableSpeedProviders, currentSpeedProvider, getDefaultSpeedProvider, updateSpeedProvider} from "./api.js";
 import {SpeedProvider} from "./speed_provider.js"
+import {wipePathfindingCache} from "./pathfinding.js"
+import { early_isGM } from "./util.js";
 
 export const settingsKey = "drag-ruler";
 
+export const RightClickAction = Object.freeze({
+	CREATE_WAYPOINT: 0,
+	DELETE_WAYPOINT: 1,
+	ABORT_DRAG:2,
+});
+
+function delayedReload() {
+	window.setTimeout(() => location.reload(), 500);
+}
+
 export function registerSettings() {
 	game.settings.register(settingsKey, "dataVersion", {
 		scope: "world",
@@ -11,14 +23,43 @@ export function registerSettings() {
 		default: "fresh install"
 	})
 
-	game.settings.register(settingsKey, "swapSpacebarRightClick", {
+	game.settings.register(settingsKey, "clientDataVersion", {
-		name: "drag-ruler.settings.swapSpacebarRightClick.name",
+		scope: "client",
-		hint: "drag-ruler.settings.swapSpacebarRightClick.hint",
+		config: false,
+		type: String,
+		default: "fresh install"
+	});
+
+	game.settings.register(settingsKey, "rightClickAction", {
+		name: "drag-ruler.settings.rightClickAction.name",
+		hint: "drag-ruler.settings.rightClickAction.hint",
+		config: true,
+		type: Number,
+		default: RightClickAction.DELETE_WAYPOINT,
+		choices: {
+			0: "drag-ruler.settings.rightClickAction.choices.create",
+			1: "drag-ruler.settings.rightClickAction.choices.delete",
+			2: "drag-ruler.settings.rightClickAction.choices.cancel",
+		},
+	});
+
+	game.settings.register(settingsKey, "autoStartMeasurement", {
+		name: "drag-ruler.settings.autoStartMeasurement.name",
+		hint: "drag-ruler.settings.autoStartMeasurement.hint",
 		scope: "client",
 		config: true,
 		type: Boolean,
-		default: false,
+		default: true,
-	})
+	});
+
+	game.settings.register(settingsKey, "useGridlessRaster", {
+		name: "drag-ruler.settings.useGridlessRaster.name",
+		hint: "drag-ruler.settings.useGridlessRaster.hint",
+		scope: "client",
+		config: true,
+		type: Boolean,
+		default: true,
+	});
 
 	game.settings.register(settingsKey, "alwaysShowSpeedForPCs", {
 		name: "drag-ruler.settings.alwaysShowSpeedForPCs.name",
@@ -47,6 +88,33 @@ export function registerSettings() {
 		default: true,
 	});
 
+	game.settings.register(settingsKey, "allowPathfinding", {
+		name: "drag-ruler.settings.allowPathfinding.name",
+		hint: "drag-ruler.settings.allowPathfinding.hint",
+		scope: "world",
+		config: true,
+		type: Boolean,
+		default: false,
+		onChange: delayedReload,
+	});
+
+	game.settings.register(settingsKey, "autoPathfinding", {
+		name: "drag-ruler.settings.autoPathfinding.name",
+		hint: "drag-ruler.settings.autoPathfinding.hint",
+		scope: "client",
+		config: early_isGM() || game.settings.get(settingsKey, "allowPathfinding"),
+		type: Boolean,
+		default: false,
+	});
+
+	game.settings.register(settingsKey, "pathfindingRadius", {
+		scope: "world",
+		config: false,
+		type: Number,
+		default: 0.9,
+		onChange: wipePathfindingCache,
+	});
+
 	game.settings.register(settingsKey, "lastTerrainRulerHintTime", {
 		config: false,
 		type: Number,

js/socket.js

@@ -39,5 +39,7 @@ export function recalculate(tokens) {
 }
 
 function _socketRecalculate(tokenIds) {
-	return canvas.controls.ruler.dragRulerRecalculate(tokenIds);
+	const ruler = canvas.controls.ruler;
+	if (ruler.isDragRuler)
+		ruler.dragRulerRecalculate(tokenIds);
 }

js/speed_provider.js

@@ -61,13 +61,18 @@ export class SpeedProvider {
 	 * The area indicates the whole area that the token will occupy (for tokens larger than 1x1) the array will more than one entry.
 	 * The return value should be an integer indicating a multiplicator by that the cost of that step should be increased.
 	 * (1 is regular cost, 2 costs double, 3 costs triple, ...)
-	 * This function is only called if the TerrainLayer and TerrainRuler modules are enabled.
+	 *
+	 * Parameters:
+	 * - options: An object used to configure Enhanced Terrain Layer's cost calculation. Ex: If options.ignoreGrid is set to true, then Euclidean measurement can be forced on a gridded map.
+	 *
+	 * This function is only called if the Enhanced Terrain Layer and Terrain Ruler modules are enabled.
 	 *
 	 * Implementing this method is optional and only needs to be done if you want to provide a custom cost function (for example to allow tokens to ignore difficult terrain)
 	 */
-	getCostForStep(token, area) {
+	getCostForStep(token, area, options={}) {
 		// Lookup the cost for each square occupied by the token
-		const costs = area.map(space => terrainRuler.getCost(space.x, space.y, {token}));
+		options.token = token;
+		const costs = area.map(space => terrainRuler.getCost(space.x, space.y, options));
 		// Return the maximum of the costs
 		return costs.reduce((max, current) => Math.max(max, current))
 	}

js/systems.js

@@ -1,23 +1,26 @@
-
 export function getDefaultSpeedAttribute() {
 	switch (game.system.id) {
 		case "CoC7":
 			return "actor.data.data.attribs.mov.value";
 		case "dcc":
 			return "actor.data.data.attributes.speed.value";
+		case "dnd4e":
+			return "actor.data.data.movement.walk.value";
 		case "dnd5e":
-			return "actor.data.data.attributes.movement.walk"
+			return "actor.data.data.attributes.movement.walk";
 		case "lancer":
-			return "actor.data.data.mech.speed"
+			return "actor.data.data.derived.speed";
 		case "pf1":
 		case "D35E":
-			return "actor.data.data.attributes.speed.land.total"		
+			return "actor.data.data.attributes.speed.land.total";
 		case "sfrpg":
 			return "actor.data.data.attributes.speed.value";
 		case "shadowrun5e":
 			return "actor.data.data.movement.walk.value";
 		case "swade":
-			return "actor.data.data.stats.speed.value"
+			return "actor.data.data.stats.speed.adjusted";
+		case "ds4":
+			return "actor.data.data.combatValues.movement.total";
 	}
 	return ""
 }
@@ -27,15 +30,17 @@ export function getDefaultDashMultiplier() {
 		case "swade":
 			return 0
 		case "dcc":
+		case "dnd4e":
 		case "dnd5e":
 		case "lancer":
 		case "pf1":
 		case "D35E":
 		case "sfrpg":
 		case "shadowrun5e":
-			return 2
+		case "ds4":
+			return 2;
 		case "CoC7":
 			return 5;
 	}
-	return 0
+	return 0;
 }

js/util.js

@@ -0,0 +1,298 @@
+import {getPixelsFromGridPosition} from "./foundry_fixes.js"
+import {findVertexSnapPoint} from "./hex_support.js";
+import {disableSnap} from "./keybindings.js";
+
+export function* zip(it1, it2) {
+	for (let i = 0;i < Math.min(it1.length, it2.length);i++) {
+		yield [it1[i], it2[i]]
+	}
+}
+
+export function* enumeratedZip(it1, it2) {
+	let i = 0;
+	for (const [v1, v2] of zip(it1, it2)) {
+		yield [i, v1, v2];
+		i++;
+	}
+}
+
+export function* iterPairs(l) {
+	for (let i = 1;i < l.length;i++) {
+		yield [l[i - 1], l[i]];
+	}
+}
+
+export function sum(arr) {
+	return arr.reduce((a, b) => a + b, 0);
+}
+
+export function buildSnapPointTokenData(token) {
+	const tokenData = {
+		width: token.data.width,
+		height: token.data.height
+	};
+
+	if (isModuleActive("hex-size-support")) {
+		tokenData.hexSizeSupport = {};
+		tokenData.hexSizeSupport.altSnappingFlag = CONFIG.hexSizeSupport.getAltSnappingFlag(token);
+		tokenData.hexSizeSupport.altOrientationFlag = CONFIG.hexSizeSupport.getAltOrientationFlag(token);
+		tokenData.hexSizeSupport.borderSize = token.document.getFlag("hex-size-support", "borderSize");
+	}
+
+	return tokenData;
+}
+
+export function getSnapPointForToken(x, y, token) {
+	return getSnapPointForTokenData(x, y, buildSnapPointTokenData(token));
+}
+
+export function getSnapPointForTokenDataObj(pos, tokenData) {
+	return getSnapPointForTokenData(pos.x, pos.y, tokenData);
+}
+
+function getSnapPointForTokenData(x, y, tokenData) {
+	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
+		return new PIXI.Point(x, y);
+	}
+	if (canvas.grid.isHex) {
+		if (tokenData.hexSizeSupport?.altSnappingFlag) {
+			if (tokenData.hexSizeSupport.borderSize % 2 === 0) {
+				const snapPoint = findVertexSnapPoint(x, y, tokenData.hexSizeSupport.altOrientationFlag);
+				return new PIXI.Point(snapPoint.x, snapPoint.y)
+			}
+			else {
+				return new PIXI.Point(...canvas.grid.getCenter(x, y))
+			}
+		}
+		else {
+			return new PIXI.Point(...canvas.grid.getCenter(x, y));
+		}
+	}
+
+	const [topLeftX, topLeftY] = canvas.grid.getTopLeft(x, y);
+	let cellX, cellY;
+	if (tokenData.width % 2 === 0)
+		cellX = x - canvas.grid.h / 2;
+	else
+		cellX = x;
+	if (tokenData.height % 2 === 0)
+		cellY = y - canvas.grid.h / 2;
+	else
+		cellY = y;
+	const [centerX, centerY] = canvas.grid.getCenter(cellX, cellY);
+	let snapX, snapY;
+	// Tiny tokens can snap to the cells corners
+	if (tokenData.width <= 0.5) {
+		const offsetX = x - topLeftX;
+		const subGridWidth = Math.floor(canvas.grid.w / 2);
+		const subGridPosX = Math.floor(offsetX / subGridWidth);
+		snapX = topLeftX + (subGridPosX + 0.5) * subGridWidth;
+	}
+	// Tokens with odd multipliers (1x1, 3x3, ...) and tokens smaller than 1x1 but bigger than 0.5x0.5 snap to the center of the grid cell
+	else if (Math.round(tokenData.width) % 2 === 1 || tokenData.width < 1) {
+		snapX = centerX;
+	}
+	// All remaining tokens (those with even or fractional multipliers on square grids) snap to the intersection points of the grid
+	else {
+		snapX = centerX + canvas.grid.w / 2;
+	}
+	if (tokenData.height <= 0.5) {
+		const offsetY = y - topLeftY;
+		const subGridHeight = Math.floor(canvas.grid.h / 2);
+		const subGridPosY = Math.floor(offsetY / subGridHeight);
+		snapY = topLeftY + (subGridPosY + 0.5) * subGridHeight;
+	}
+	else if (Math.round(tokenData.height) % 2 === 1 || tokenData.height < 1) {
+		snapY = centerY;
+	}
+	else {
+		snapY = centerY + canvas.grid.h / 2;
+	}
+	return new PIXI.Point(snapX, snapY);
+}
+
+export function getSnapPointForTokenObj(pos, token) {
+	return getSnapPointForToken(pos.x, pos.y, token);
+}
+
+export function getSnapPointForMeasuredTemplate(x, y) {
+	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
+		return new PIXI.Point(x, y);
+	}
+	return canvas.grid.grid.getSnappedPosition(x, y, canvas.templates.gridPrecision);
+}
+
+export function getSnapPointForEntity(x, y, entity) {
+	const isToken = entity instanceof Token;
+	if (isToken)
+		return getSnapPointForToken(x, y, entity);
+	else
+		return getSnapPointForMeasuredTemplate(x, y);
+}
+
+export function highlightTokenShape(position, shape, color, alpha) {
+	const layer = canvas.grid.highlightLayers[this.name];
+    if ( !layer )
+		return false;
+	const area = getAreaFromPositionAndShape(position, shape);
+	for (const space of area) {
+		const [x, y] = getPixelsFromGridPosition(space.x, space.y);
+		canvas.grid.grid.highlightGridPosition(layer, {x, y, color, alpha: 0.25 * alpha});
+	}
+}
+
+export function getAreaFromPositionAndShape(position, shape) {
+	return shape.map(space => {
+		let x = position.x + space.x;
+		let y = position.y + space.y;
+		if (canvas.grid.isHex) {
+			let shiftedRow;
+			if (canvas.grid.grid.options.even)
+				shiftedRow = 1
+			else
+				shiftedRow = 0
+			if (canvas.grid.grid.options.columns) {
+				if (space.x % 2 !== 0 && position.x % 2 !== shiftedRow) {
+					y += 1;
+				}
+			}
+			else {
+				if (space.y % 2 !== 0 && position.y % 2 !== shiftedRow) {
+					x += 1;
+				}
+			}
+		}
+		return {x, y}
+	});
+}
+
+export function getTokenShape(token) {
+	return getTokenShapeForTokenData(buildSnapPointTokenData(token), token.scene);
+}
+
+export function getTokenShapeForTokenData(tokenData, scene=canvas.scene) {
+	if (scene.data.gridType === CONST.GRID_TYPES.GRIDLESS) {
+		return [{x: 0, y: 0}]
+	}
+	else if (scene.data.gridType === CONST.GRID_TYPES.SQUARE) {
+		const topOffset = -Math.floor(tokenData.height / 2)
+		const leftOffset = -Math.floor(tokenData.width / 2)
+		const shape = []
+		for (let y = 0;y < tokenData.height;y++) {
+			for (let x = 0;x < tokenData.width;x++) {
+				shape.push({x: x + leftOffset, y: y + topOffset})
+			}
+		}
+		return shape
+	}
+	else {
+		// Hex grids
+		if (game.modules.get("hex-size-support")?.active && tokenData.hexSizeSupport.altSnappingFlag) {
+			const borderSize = tokenData.hexSizeSupport.borderSize;
+			let shape = [{x: 0, y: 0}];
+			if (borderSize >= 2)
+				shape = shape.concat([{x: 0, y: -1}, {x: -1, y: -1}]);
+			if (borderSize >= 3)
+				shape = shape.concat([{x: 0, y: 1}, {x: -1, y: 1}, {x: -1, y: 0}, {x: 1, y: 0}]);
+			if (borderSize >= 4)
+				shape = shape.concat([{x: -2, y: -1}, {x: 1, y: -1}, {x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}])
+
+			if (Boolean(tokenData.hexSizeSupport.altOrientationFlag) !== canvas.grid.grid.options.columns)
+				shape.forEach(space => space.y *= -1);
+			if (canvas.grid.grid.options.columns)
+				shape = shape.map(space => {return {x: space.y, y: space.x}});
+			return shape;
+		}
+		else {
+			return [{x: 0, y: 0}];
+		}
+	}
+}
+
+export function getTokenSize(token) {
+	let w, h;
+	const hexSizeSupportBorderSize = token.data.flags["hex-size-support"]?.borderSize;
+	if (hexSizeSupportBorderSize > 0) {
+		w = h = hexSizeSupportBorderSize
+	}
+	else {
+		w = token.data.width
+		h = token.data.height
+	}
+	return {w, h};
+}
+
+// Tokens that have a size divisible by two (2x2, 4x4, 2x1) have their ruler at the edge of a cell.
+// This function applies an offset to to the waypoints that will move the ruler from the edge to the center of the cell
+export function applyTokenSizeOffset(waypoints, token) {
+	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
+		return waypoints
+	}
+
+	const tokenSize = getTokenSize(token);
+	const waypointOffset = {x: 0, y: 0};
+	if (canvas.grid.isHex) {
+		if (game.modules.get("hex-size-support")?.active) {
+			const isAltOrientation = CONFIG.hexSizeSupport.getAltOrientationFlag(token);
+			if (canvas.grid.grid.options.columns) {
+				if (tokenSize.w % 2 === 0) {
+					waypointOffset.x = canvas.grid.w / 2;
+					if (!isAltOrientation)
+						waypointOffset.x *= -1;
+				}
+			}
+			else {
+				if (tokenSize.h % 2 === 0) {
+					waypointOffset.y = canvas.grid.h / 2;
+					if (isAltOrientation)
+						waypointOffset.y *= -1;
+				}
+			}
+		}
+		// If hex size support isn't active leave the waypoints like they are
+	}
+	else {
+		if (tokenSize.w % 2 === 0) {
+			waypointOffset.x = canvas.grid.w / 2;
+		}
+		if (tokenSize.h % 2 === 0) {
+			waypointOffset.y = canvas.grid.h / 2;
+		}
+	}
+
+	return waypoints.map(w => new PIXI.Point(w.x + waypointOffset.x, w.y + waypointOffset.y))
+}
+
+export function setSnapParameterOnOptions(sourceObject, options) {
+	// Allow outside modules to override snapping
+	if (sourceObject.snapOverride?.active) {
+		options.snapOverrideActive = true;
+		options.snap = sourceObject.snapOverride.snap;
+		sourceObject.snapOverride = undefined; // remove it to prevent any lingering data issues
+	}
+	else {
+		options.snap = !disableSnap;
+	}
+}
+
+export function isClose(a, b, delta) {
+	return Math.abs(a - b) <= delta;
+}
+
+export function getMeasurePosition() {
+	const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens);
+	const rulerOffset = canvas.controls.ruler.rulerOffset;
+	const measurePosition = {x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y};
+	return measurePosition;
+}
+
+// isGM function for use during loading when game.user isn't available yet
+export function early_isGM() {
+	const level = game.data.users.find(u => u._id == game.data.userId).role;
+	const gmLevel = CONST.USER_ROLES.ASSISTANT;
+	return level >= gmLevel;
+}
+
+export function isModuleActive(moduleName) {
+	return game.modules.get(moduleName)?.active
+}

lang/de.json

@@ -29,15 +29,49 @@
 				"dash": "sprinten"
 			}
 		},
+		"keybindings": {
+			"cancelDrag": "Ziehen beenden",
+			"createWaypoint": "Wegpunkt erstellen",
+			"deleteWaypoint": "Wegpunkt löschen",
+			"disableSnap": {
+				"name": "Raster deaktivieren",
+				"hint": "Während diese Taste gedrückt ist wird das Raster temporär deaktiviert"
+			},
+			"moveWithoutAnimation": {
+				"name": "Token animation deaktivieren",
+				"hint": "Wenn diese Taste gedrückt wird, während ein Token fallen gelassen wird, bewegt es sich ohne Animation zum Zielort."
+			},
+			"togglePathfinding": {
+				"name": "Wegfindung umschalten",
+				"hint": "Wenn diese Taste gedrückt gehalten wird, während ein Token gezogen wird, wird die Wegfindung vorübergehend aktiviert/deaktiviert"
+			}
+		},
 		"settings": {
+			"allowPathfinding": {
+				"name": "Wegfindung für Spieler erlauben",
+				"hint": "Erlaubt es Spielern die Wegfindungs zu benutzen. Bitte beachte, dass die Wegfindung Wege durch unerkundeten Nebel des Kriegs und Ätherische Wände berechnen kann. Dies kann deinen Spielern Geheimnisse lüften, von denen sie noch nicht erfahren sollten."
+			},
 			"alwaysShowSpeedForPCs": {
 				"name": "Geschwindigkeit von Spielercharakteren für jeden anzeigen",
 				"hint": "Wenn diese Einstellung aktiviert ist wird die Färbung der hervorgehobenen Felder bei Spielercharakteren allen Spielern angezeigt, selbst wenn diese keinen Zugriff auf den Charakterbogen haben."
 			},
+			"autoStartMeasurement": {
+				"name": "Automatisch mit Messen beginnen",
+				"hint": "Wenn diese Option aktiviert ist beginnt Drag Ruler mit dem Messen sobald das Token bewegt wird. Wenn die Option deaktiviert ist bleibt Drag Ruler deaktiviert bis der Knopf zum platzieren eines Wegpunkts betätigt wird."
+			},
 			"enableMovementHistory": {
 				"name": "Bewegungsverlauf während des Kampfes aktivieren",
 				"hint": "Wenn diesen Option aktiviert ist merkt sich Drag Ruler die Bewegungen, die während einer Runde eines Kampfes gemacht wurden und zeigt diese an, wenn das Token weiterbewegt wird."
 			},
+			"rightClickAction": {
+				"name": "Aktion bei Rechtsklick",
+				"hint": "Was soll getan werden, wenn die rechte Maustaste während des Ziehens gedrückt wird?",
+				"choices": {
+					"create": "Wegpunkt erstellen",
+					"delete": "Wegpunkt löschen",
+					"cancel": "Ziehen beenden"
+				}
+			},
 			"showGMRulerToPlayers": {
 				"name": "Lineal des Spielleiters bei Spielern anzeigen",
 				"hint": "Wenn diese Option deaktiviert ist wird das Lineal des Spielleiters bei den anderen Spielern nicht angezeigt."
@@ -74,9 +108,9 @@
 					}
 				}
 			},
-			"swapSpacebarRightClick": {
+			"useGridlessraster": {
-				"name": "Leertaste und Rechtsklick tauschen",
+				"name": "Geschwindigkeitsraster aktivieren",
-				"hint": "Die Funktionen der Leertaste und des Rechtsklicks sind, während eine Spielfigur bewegt wird, vertauscht. Wenn diese Option aktiviert wird können mit Rechtsklick Wegpunkte gesetzt werden und mit der Leertaste werden sie wieder gelöscht."
+				"hint": "Lässt Spielfiguren auf gitterlosen Szenen an deren Geschwindigkeitsgrenzen einrasten."
 			}
 		}
 	}

lang/en.json

@@ -29,15 +29,53 @@
 				"dash": "dash"
 			}
 		},
+		"keybindings": {
+			"cancelDrag": "Cancel dragging",
+			"createWaypoint": "Create waypoint",
+			"deleteWaypoint": "Delete waypoint",
+			"disableSnap": {
+				"name": "Disable snapping",
+				"hint": "Snapping will be temporarily disabled while this key is being held down"
+			},
+			"moveWithoutAnimation": {
+				"name": "Disable token animation",
+				"hint": "When being held while dropping a token, the token will move to the target location without animating"
+			},
+			"togglePathfinding": {
+				"name": "Toggle pathfinding",
+				"hint": "When being held while dragging a token, the pathfinding functionality will be temporarily enabled/disabled"
+			}
+		},
 		"settings": {
+			"allowPathfinding": {
+				"name": "Allow pathfinding for players",
+				"hint": "Allows players to use Drag Ruler's pathfinding functionality in this world. Be aware that pathfinding can route through unexplored fog of war and Ethereal Walls, which might reveal secrets to your players ahead of time."
+			},
 			"alwaysShowSpeedForPCs": {
 				"name": "Show PC speed to everyone",
 				"hint": "If enabled the coloring based on actor speed for player characters will shown to everyone, even if they don't have observer permission for the character sheet."
 			},
+			"autoStartMeasurement": {
+				"name": "Automatically start measuring",
+				"hint": "If enabled, Drag Ruler will start measuring as soon as the token is being dragged. If disabled, Drag Ruler will remain inactive and will only start measuring once the button to add a waypoint is being pressed."
+			},
+			"autoPathfinding": {
+				"name": "Pathfinding by default",
+				"hint": "If enabled, dragging a token will automatically use a pathfinding ruler"
+			},
 			"enableMovementHistory": {
 				"name": "Enable movement history during combat",
 				"hint": "If enabled, Drag Ruler will remember the path a token took during it's turn in combat and will display it when you pick the token back up."
 			},
+			"rightClickAction": {
+				"name": "Right click action",
+				"hint": "What action shall be performed when right clicking while dragging a token?",
+				"choices": {
+					"create": "Create waypoint",
+					"delete": "Delete waypoint",
+					"cancel": "Cancel drag"
+				}
+			},
 			"showGMRulerToPlayers": {
 				"name": "Show GM ruler to players",
 				"hint": "If disabled the ruler of GMs will not be shown for non-GM players"
@@ -74,9 +112,9 @@
 					}
 				}
 			},
-			"swapSpacebarRightClick": {
+			"useGridlessRaster": {
-				"name": "Swap spacebar and right click",
+				"name": "Use speed based snapping",
-				"hint": "Swaps the functions of spacebar and right click during dragging. If enabled right click will place waypoints and spacebar will delete them"
+				"hint": "On Gridless scenes, this makes tokens snap to the token's speed ranges."
 			}
 		}
 	}

lang/es.json

@@ -1,87 +1,125 @@
-{
+{
-	"drag-ruler": {
+	"drag-ruler": {
-		"I18N": {
+		"I18N": {
-			"LANGUAGE": "Español",
+			"LANGUAGE": "Español",
-			"MAINTAINERS": "@Viriato139ac#0342"
+			"MAINTAINERS": "@Viriato139ac#0342"
-		},
+		},
-		"dependencies": {
+		"dependencies": {
-			"ok": "OK",
+			"ok": "OK",
-			"terrain-ruler": {
+			"terrain-ruler": {
-				"title": "Cómo medir a través de terreno difícil con Drag Ruler",
+				"title": "Cómo medir a través de terreno difícil con Drag Ruler",
-				"text": "You have the {moduleName} module enabled. Drag Ruler is able to measure difficult terrain that was placed down using that module. To make this possible Drag Ruler utilizes the Terrain Ruler module. If Terrain Ruler is installed and activated Drag Ruler will automatically start to respect difficult terrain in it's measurements.",
+				"text": "You have the {moduleName} module enabled. Drag Ruler is able to measure difficult terrain that was placed down using that module. To make this possible Drag Ruler utilizes the Terrain Ruler module. If Terrain Ruler is installed and activated Drag Ruler will automatically start to respect difficult terrain in it's measurements.",
-				"neverShowAgain": "No volver a mostrar"
+				"neverShowAgain": "No volver a mostrar"
-			},
+			},
-			"socketlib": {
+			"socketlib": {
-				"title": "El módulo Socketlib no está instalado",
+				"title": "El módulo Socketlib no está instalado",
-				"text": "Drag Ruler necesita para su funcionamiento correcto que instale socketlib. Por favor, active socketlib en este mundo"
+				"text": "Drag Ruler necesita para su funcionamiento correcto que instale socketlib. Por favor, active socketlib en este mundo"
-			}
+			}
-		},
+		},
-		"resetMovementHistory": "Reiniciar historial de movimiento",
+		"resetMovementHistory": "Reiniciar historial de movimiento",
-		"genericSpeedProvider": {
+		"genericSpeedProvider": {
-			"settings": {
+			"settings": {
-				"dashMultiplier": {
+				"dashMultiplier": {
-					"name": "Multiplicador por correr",
+					"name": "Multiplicador por correr",
-					"hint": "Se puede usar para aplicar a los iconos una velocidad secundaria que use un color distinto en la medición de la ruta a seguir. Establece el valor a 0 para deshabilitar esta velocidad secundaria"
+					"hint": "Se puede usar para aplicar a los iconos una velocidad secundaria que use un color distinto en la medición de la ruta a seguir. Establece el valor a 0 para deshabilitar esta velocidad secundaria"
-				},
+				},
-				"speedAttribute": {
+				"speedAttribute": {
-					"name": "Attributo de velocidad",
+					"name": "Attributo de velocidad",
-					"hint": "El atributo que define la velocidad de movimiento andando del icono. Se usa para los códigos de colores al medir la ruta a seguir"
+					"hint": "El atributo que define la velocidad de movimiento andando del icono. Se usa para los códigos de colores al medir la ruta a seguir"
-				}
+				}
-			},
+			},
-			"speeds": {
+			"speeds": {
-				"walk": "caminar",
+				"walk": "caminar",
-				"dash": "correr"
+				"dash": "correr"
-			}
+			}
-		},
+		},
-		"settings": {
+		"keybindings": {
-			"alwaysShowSpeedForPCs": {
+			"cancelDrag": "Cancelar arrastre",
-				"name": "Mostrar velocidad de los PJs a todo el mundo",
+			"createWaypoint": "Crear punto de ruta",
-				"hint": "Si se habilita, se mostrará a todo el mundo los códigos de colores de las rutas de los PJs, incluso si no tienen permisos de observador para ese personaje"
+			"deleteWaypoint": "Borrar punto de ruta",
-			},
+			"disableSnap": {
-			"enableMovementHistory": {
+				"name": "Deshabilitar ajuste",
-				"name": "Habilitar historial de movimiento durante el combate",
+				"hint": "El ajuste a la rejilla se deshabilitará temporalmente mientras se presione esta tecla"
-				"hint": "Si se habilita, Drag Ruler recordará la ruta que ha seguido un icono en su turno y la mostrará al seleccionarlo de nuevo"
+			},
-			},
+			"moveWithoutAnimation": {
-			"showGMRulerToPlayers": {
+				"name": "Deshabilitar animación de icono",
-				"name": "Mostrar regla del GM a los jugadores",
+				"hint": "Si al soltar un icono se presiona esta tecla, se deshabilitará la animación del icono al moverse al destino"
-				"hint": "Si se deshabilita, no se mostrará la regla de medición de los GMs al resto de usuarios"
+			},
-			},
+			"togglePathfinding": {
-			"speedProviderSettings": {
+				"name": "Conmutar búsqueda de camino",
-				"name": "Proveedor de configuración de velocidad",
+				"hint": "Cuando se presione al arrastrar un icono, la funcionalidad de búsqueda de camino será temporalmente habilitada/deshabilitada"
-				"hint": "El proveedor de ajustes de velocidad contiene todos los ajustes específicos de cada sistema",
+			}
-				"button": "Proveedor de configuración de velocidad",
+		},
-				"windowTitle": "Proveedor de configuración de velocidad",
+		"settings": {
-				"headers": {
+			"allowPathfinding": {
-					"speedProvider": "Proveedor de velocidad",
+				"name": "Permitir búsqueda de camino a los jugadores",
-					"speedProviderSettings": "Configuraciones específicas del proveedor de velocidad"
+				"hint": "Permite a los jugadores usar en este mundo la funcionalidad de búsqueda de camino. Tenga cuidado porque la ruta puede transcurrir por lugares con niebla de guerra o muros invisibles, lo que podrá revelar algunos secretos a los jugadores antes de tiempo"
-				},
+			},
-				"activeProvider": {
+			"alwaysShowSpeedForPCs": {
-					"name": "Proveedor de velocidad actualmente activo",
+				"name": "Mostrar velocidad de los PJs a todo el mundo",
-					"hint": "La configuración que se muestra más abajo depende del proveedor de velocidad activo. Si el GM selecciona un proveedor distinto, los ajustes disponibles puede que cambien"
+				"hint": "Si se habilita, se mostrará a todo el mundo los códigos de colores de las rutas de los PJs, incluso si no tienen permisos de observador para ese personaje"
-				},
+			},
-				"noSettings": "Este proveedor de velocidad no dispone de ninguna opción de configuración",
+			"autoStartMeasurement": {
-				"color": {
+				"name": "Comenzar a medir automáticamente",
-					"name": "Color para {colorName}",
+				"hint": "Si se habilita, Drag Ruler comenzará a medir en cuanto se comience a arrastrar un icono. Si se deshabilita, Drag Ruler permanecerá inactivo y comenzará a medir únicamente cuando se presione el botón configurado para añadir un nuevo punto de ruta"
-					"hint": "Color que se usará para establecer el tono de las cuadrículas que se encuentran dentro del rango {colorName}",
+			},
-					"unreachable": {
+			"autoPathfinding": {
-						"name": "inalcanzable",
+				"name": "Búsqueda de camino por defecto",
-						"hint": "Color que se usará para las cuadrículas más allá de la distancia máxima de movimiento del icono"
+				"hint": "Si se habilita, al arrastrar un icono se usará automáticamente la regla de búsqueda de camino"
-					}
+			},
-				},
+			"enableMovementHistory": {
-				"speedProvider": {
+				"name": "Habilitar historial de movimiento durante el combate",
-					"name": "Proveedor de configuración de velocidad",
+				"hint": "Si se habilita, Drag Ruler recordará la ruta que ha seguido un icono en su turno y la mostrará al seleccionarlo de nuevo"
-					"hint": "Seleccione quien suministra la información de la velocidad de los iconos a la hora de colorear la ruta a seguir. Drag Ruler incluye un proveedor genérico que ofrece una funcionalidad básica y que probablemente funcione para casi todos los sistemas si se usa de forma correcta. Se pueden añadir otros proveedores de velocidad al instalar sistemas o módulos. Seleccionar un proveedor distinto al genérico asegurará una mejor integración con las reglas del sistema que está usando. Las opciones siguientes dependerán del proveedor que seleccione",
+			},
-					"choices": {
+			"rightClickAction": {
-						"module": "Módulo {name}",
+				"name": "Acción del botón derecho",
-						"native": "Genérico",
+				"hint": "Qué acción se llevará a cabo cuando se haga clic derecho mientras se arrastra un icono",
-						"system": "Sistema {name}"
+				"choices": {
-					}
+					"create": "Crear punto de ruta",
-				}
+					"delete": "Borrar punto de ruta",
-			},
+					"cancel": "Cancelar arrastre"
-			"swapSpacebarRightClick": {
+				}
-				"name": "Intercambiar barra espaciadora y clic-derecho",
+			},
-				"hint": "Cambia el funcionamiento de la barra espaciadora y el clic-derecho del ratón mientras se arrastra un icono. Si está habilitado, clic-derecho establecerá puntos en la ruta y la barra espaciadora los borrará"
+			"showGMRulerToPlayers": {
-			}
+				"name": "Mostrar regla del GM a los jugadores",
-		}
+				"hint": "Si se deshabilita, no se mostrará la regla de medición de los GMs al resto de usuarios"
-	}
+			},
-}
+			"speedProviderSettings": {
+				"name": "Proveedor de configuración de velocidad",
+				"hint": "El proveedor de ajustes de velocidad contiene todos los ajustes específicos de cada sistema",
+				"button": "Proveedor de configuración de velocidad",
+				"windowTitle": "Proveedor de configuración de velocidad",
+				"headers": {
+					"speedProvider": "Proveedor de velocidad",
+					"speedProviderSettings": "Configuraciones específicas del proveedor de velocidad"
+				},
+				"activeProvider": {
+					"name": "Proveedor de velocidad actualmente activo",
+					"hint": "La configuración que se muestra más abajo depende del proveedor de velocidad activo. Si el GM selecciona un proveedor distinto, los ajustes disponibles puede que cambien"
+				},
+				"noSettings": "Este proveedor de velocidad no dispone de ninguna opción de configuración",
+				"color": {
+					"name": "Color para {colorName}",
+					"hint": "Color que se usará para establecer el tono de las cuadrículas que se encuentran dentro del rango {colorName}",
+					"unreachable": {
+						"name": "inalcanzable",
+						"hint": "Color que se usará para las cuadrículas más allá de la distancia máxima de movimiento del icono"
+					}
+				},
+				"speedProvider": {
+					"name": "Proveedor de configuración de velocidad",
+					"hint": "Seleccione quien suministra la información de la velocidad de los iconos a la hora de colorear la ruta a seguir. Drag Ruler incluye un proveedor genérico que ofrece una funcionalidad básica y que probablemente funcione para casi todos los sistemas si se usa de forma correcta. Se pueden añadir otros proveedores de velocidad al instalar sistemas o módulos. Seleccionar un proveedor distinto al genérico asegurará una mejor integración con las reglas del sistema que está usando. Las opciones siguientes dependerán del proveedor que seleccione",
+					"choices": {
+						"module": "Módulo {name}",
+						"native": "Genérico",
+						"system": "Sistema {name}"
+					}
+				}
+			},
+			"useGridlessRaster": {
+				"name": "Usar ajuste a la velocidad",
+				"hint": "Cuando no se use rejilla en la escena, este ajuste hace que los iconos se ajusten a sus rangos de velocidad. Se puede deshabilitar temporalmente pulsando la tecla Mayús mientras se arrastra"
+			}
+		}
+	}
+}

lang/fr.json

@@ -0,0 +1,86 @@
+{
+	"drag-ruler": {
+		"dependencies": {
+			"ok": "OK",
+			"terrain-ruler": {
+				"title": "Comment mesurer un terrain difficile avec Drag Ruler",
+				"text": "Vous avez le module {moduleName} activé. Drag Ruler est capable de mesurer un terrain difficile qui a été placé à l'aide de ce module. Pour rendre cela possible, Drag Ruler utilise le module Terrain Ruler. Si Terrain Ruler est installé et activé Drag Ruler commencera automatiquement à respecter le terrain difficile dans ses mesures.",
+				"neverShowAgain": "Ne plus jamais afficher cela"
+			},
+			"socketlib": {
+				"title": "Module Socketlib manquant",
+                                "text": "Drag Ruler nécessite que le module socketlib fonctionne correctement. Veuillez activer le module socketlib dans ce monde."
+			}
+		},
+		"resetMovementHistory": "Réinitialiser l'historique des mouvements",
+		"genericSpeedProvider": {
+			"settings": {
+				"dashMultiplier": {
+					"name": "Multiplicateur de courses",
+					"hint": "Cela peut être utilisé pour donner aux jetons une vitesse secondaire pendant la coloration du chemin mesuré. Réglez-le sur 0 pour désactiver la vitesse secondaire."
+				},
+				"speedAttribute": {
+                                        "name": "Attribut de vitesse",
+                                        "hint": "L'attribut qui définit la vitesse de marche d'un jeton. Il est utilisé lors de la coloration du chemin mesuré." 				}
+			},
+			"speeds": {
+				"walk": "marche",
+				"dash": "course"
+			}
+		},
+		"settings": {
+			"alwaysShowSpeedForPCs": {
+				"name": "Afficher la vitesse du PJ à tout le monde",
+				"hint": "Si activé, la coloration basée sur la vitesse de l'acteur pour les personnages joueurs sera montrée à tout le monde, même s'ils n'ont pas la permission d'observateur pour la feuille de personnage."
+			},
+			"autoStartMeasurement": {
+				"name": "Démarrer automatiquement la mesure",
+				"hint": "Si activé, Drag Ruler commencera à mesurer dès que le jeton est glissé. S'il est désactivé, Drag Ruler restera inactif et ne commencera à mesurer qu'une fois que le bouton pour ajouter un waypoint est enfoncé."
+			},
+			"enableMovementHistory": {
+				"name": "Activer l'historique des mouvements pendant le combat",
+				"hint": "Si activé, Drag Ruler se souviendra du chemin emprunté par un jeton pendant son tour de combat et l'affichera lorsque vous récupérerez le jeton."
+			},
+			"showGMRulerToPlayers": {
+				"name": "Afficher la règle MJ aux joueurs",
+				"hint": "Si désactivé, la règle des MJ ne sera pas affichée pour les joueurs non-MJ"
+			},
+			"speedProviderSettings": {
+				"name": "Paramètres du système de vitesse",
+				"hint": "Les paramètres du système de vitesse contiennent tous les paramètres spécifiques au système de jeu.",
+				"button": "Paramètres du système de vitesse",
+				"windowTitle": "Paramètres du système de vitesse",
+				"headers": {
+					"speedProvider": "système de vitesse",
+					"speedProviderSettings": "Paramètres spécifiques au système de vitesse"
+				},
+				"activeProvider": {
+					"name": "système de vitesse actuellement actif",
+					"hint": "Les paramètres indiqués ci-dessous dépendent du système de vitesse actif. Si le MJ sélectionne un système de vitesse différent, les paramètres disponibles peuvent changer."
+				},
+				"noSettings": "Ce système de vitesse n'offre aucune option de configuration.",
+				"color": {
+					"name": "Couleur pour {colorName}",
+					"hint": "La couleur qui sera utilisée pour colorier les carrés qui sont dans la plage {colorName}",
+					"unreachable": {
+						"name": "injoignable",
+						"hint": "La couleur des espaces qui ne sont pas accessibles par le jeton déplacé"
+					}
+				},
+				"speedProvider": {
+					"name": "système de paramètres de vitesse",
+					"indice": "Sélectionnez qui fournit les informations de vitesse pour les jetons lors de la coloration. Drag Ruler offre un système de vitesse générique qui fournit des fonctionnalités de base et devrait fonctionner pour tous les systèmes de jeu s'il est correctement configuré. Plus de systèmes de vitesse peuvent être mis à disposition via les systèmes de jeu et les modules installés . La sélection d'un autre système de vitesse que le système de vitesse générique peut offrir une meilleure intégration dans les règles du système de jeu que vous utilisez. Les options ci-dessous dépendent du système de vitesse sélectionné ici.",
+					"choices": {
+						"module": "Module {name}",
+						"native": "Générique",
+						"system": "Systéme {name}"
+					}
+				}
+			},
+			"useGridlessRaster": {
+				"name": "Use speed based snapping",
+				"hint": "On Gridless scenes, this makes tokens snap to the token's speed ranges. This can be temporarily disabled by pressing Shift during drag."
+			}
+		}
+	}
+}

lang/ja.json

@@ -1,5 +1,19 @@
 {
+	"Localization Provided By": "touge",
 	"drag-ruler": {
+		"dependencies": {
+			"ok": "OK",
+			"terrain-ruler": {
+				"title": "Drag Rulerで移動困難地形を測定する",
+				"text": "「{moduleName}」モジュールが有効化されました。Drag Rulerは、同モジュールによって設定された移動困難地形を測定できます。これには「Terrain Ruler」モジュールが必要です。有効化すると、自動的に移動困難地形を考慮した測定を行います",
+				"neverShowAgain": "再表示しない"
+			},
+			"socketlib": {
+				"title": "「Socketlib」が見つかりません",
+				"text": "Drag Rulerの正常動作には「Socketlib」モジュールが必要です。このワールドで「Socketlib」を有効にしてください。"
+			}
+		},
+		"resetMovementHistory": "移動履歴のリセット",
 		"genericSpeedProvider": {
 			"settings": {
 				"dashMultiplier": {
@@ -21,6 +35,14 @@
 				"name": "プレイヤーキャラクターの移動速度を全員に公開する",
 				"hint": "有効にすると、アクターの観察者（Observer）権限を持たない人にも，移動範囲の色分けが表示されるようになります。"
 			},
+			"autoStartMeasurement": {
+				"name": "自動計測",
+				"hint": "有効化時、Drag Rulerはトークンがドラッグされた時点で計測を初めます。無効化の場合、ドラッグしてもDrag Rulerは起動せず、中間地点をおいたときにのみ起動します。"
+			},
+			"enableMovementHistory": {
+				"name": "戦闘中の移動履歴を有効にする",
+				"hint": "有効にすると、Drag Rulerは戦闘ターン中にコマが辿った経路を記憶するようになります。これはコマの再選択時に再表示されます。"
+			},
 			"showGMRulerToPlayers": {
 				"name": "GMのルーラーをプレイヤーに見せる",
 				"hint": "無効の場合、GMのルーラーはプレイヤーに表示されません。"
@@ -57,9 +79,9 @@
 					}
 				}
 			},
-			"swapSpacebarRightClick": {
+			"useGridlessRaster": {
-				"name": "スペースキーと右クリックを入れ替える",
+				"name": "移動速度制限",
-				"hint": "ドラッグ中のスペースキーと右クリックの機能を入れ替えます。有効にすると右クリックがウェイポイントの配置、スペースキーが削除になります。"
+				"hint": "グリッドの無いシーンでは、コマがドラッグできる範囲を移動速度ぶんまで制限します。Shiftキーを押すことで一時的にこの制限を無視できます。"
 			}
 		}
 	}

lang/ko.json

@@ -73,10 +73,6 @@
 						"system": "시스템 {name}"
 					}
 				}
-			},
-			"swapSpacebarRightClick": {
-				"name": "스페이스바와 우클릭 스왑",
-				"hint": "드래그 도중 스페이스바의 기능을 우클릭 기능과 바꾼다. 활성화된 경우 드래그시 우클릭을 사용하면 경유지가 배치되고, 스페이스바가 해당 경유지를 삭제한다."
 			}
 		}
 	}

lang/zh-tw.json

@@ -56,10 +56,6 @@
                         "system": "系統 {name}"
                     }
                 }
-            },
-            "swapSpacebarRightClick": {
-                "name": "交換空格鍵並鼠標右鍵",
-                "hint": "交換空格鍵和右鍵點擊在拖動過程中的功能。如果啟用,右鍵單擊將放置航點,空格鍵將刪除它們。"
             }
         }
     }

module.json

@@ -2,9 +2,9 @@
 	"name": "drag-ruler",
 	"title": "Drag Ruler",
 	"description": "When dragging a token displays a ruler showing how far you've moved that token.",
-	"version": "1.7.6",
+	"version": "1.12.8",
-	"minimumCoreVersion" : "0.8.5",
+	"minimumCoreVersion" : "9.245",
-	"compatibleCoreVersion" : "0.8.8",
+	"compatibleCoreVersion" : "9",
 	"authors": [
 		{
 			"name": "Manuel Vögele",
@@ -13,8 +13,9 @@
 		}
 	],
 	"esmodules": [
-		"src/main.js",
+		"js/libwrapper_shim.js",
-		"src/socket.js"
+		"js/main.js",
+		"js/socket.js"
 	],
 	"templates": [
 		"speed_provider_settings.html"
@@ -30,6 +31,16 @@
 			"name": "English",
 			"path": "lang/en.json"
 		},
+		{
+			"lang": "es",
+			"name": "Español",
+			"path": "lang/es.json"
+		},
+		{
+			"lang": "fr",
+			"name": "Français",
+			"path": "lang/fr.json"
+		},
 		{
 			"lang": "ja",
 			"name": "日本語",
@@ -44,11 +55,6 @@
 			"lang": "zh-tw",
 			"name": "正體中文",
 			"path": "lang/zh-tw.json"
-		},
-		{
-			"lang": "es",
-			"name": "Español",
-			"path": "lang/es.json"
 		}
 	],
 	"dependencies": [
@@ -59,7 +65,7 @@
 	],
 	"socket": true,
 	"url": "https://github.com/manuelVo/foundryvtt-drag-ruler",
-	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/archive/v1.7.6.zip",
+	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/releases/download/v1.12.8/drag-ruler-1.12.8.zip",
 	"manifest": "https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/master/module.json",
 	"readme": "https://github.com/manuelVo/foundryvtt-drag-ruler/blob/master/README.md",
 	"changelog": "https://github.com/manuelVo/foundryvtt-drag-ruler/blob/master/CHANGELOG.md",

rust/.gitignore

@@ -0,0 +1 @@
+target/

rust/Cargo.lock

@@ -0,0 +1,232 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "block-buffer"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a45a46ab1f2412e53d3a0ade76ffad2025804294569aae387231a0cd6e0899"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59a6001667ab124aebae2a495118e11d30984c3a653e99d86d58971708cf5e4b"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "gridless-pathfinding"
+version = "1.12.8"
+dependencies = [
+ "console_error_panic_hook",
+ "js-sys",
+ "rustc-hash",
+ "sha1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a38fc24e30fd564ce974c02bf1d337caddff65be6cc4735a1f7eab22a7440f04"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.125"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5916d2ae698f6de9bfb891ad7a8d65c09d232dc58cc4ac433c7da3b2fd84bc2b"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "sha1"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c77f4e7f65455545c2153c1253d25056825e77ee2533f0e41deb65a93a34852f"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "typenum"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25f1af7423d8588a3d840681122e72e6a24ddbcb3f0ec385cac0d12d24256c06"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b21c0df030f5a177f3cba22e9bc4322695ec43e7257d865302900290bcdedca"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4203d69e40a52ee523b2529a773d5ffc1dc0071801c87b3d270b471b80ed01"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa8a30d46208db204854cadbb5d4baf5fcf8071ba5bf48190c3e59937962ebc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d958d035c4438e28c70e4321a2911302f10135ce78a9c7834c0cab4123d06a2"

rust/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "gridless-pathfinding"
+version = "1.12.8"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["cdylib"]
+
+[profile.release]
+lto = true
+#debug = true
+
+[dependencies]
+console_error_panic_hook = "0.1.7"
+js-sys = "0.3.56"
+rustc-hash = "1.1.0"
+sha1 = "0.10.1"
+wasm-bindgen = "0.2.79"

rust/rustfmt.toml

@@ -0,0 +1 @@
+hard_tabs = true

rust/src/geometry.rs

@@ -0,0 +1,253 @@
+use std::hash::{Hash, Hasher};
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+	pub type JsPoint;
+
+	#[wasm_bindgen(method, getter)]
+	fn x(this: &JsPoint) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn y(this: &JsPoint) -> f64;
+}
+
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone)]
+pub struct Point {
+	pub x: f64,
+	pub y: f64,
+}
+
+impl Point {
+	pub fn new(x: f64, y: f64) -> Self {
+		Self { x, y }
+	}
+
+	pub fn from_line_x(line: &Line, x: f64) -> Self {
+		let y = line.calc_y(x);
+		Self { x, y }
+	}
+
+	pub fn distance_to(&self, to: Point) -> f64 {
+		(self.y - to.y).hypot(self.x - to.x)
+	}
+
+	pub fn is_same_as(&self, other: &Self) -> bool {
+		let e = 0.000001;
+		(self.x - other.x).abs() < e && (self.y - other.y).abs() < e
+	}
+
+	pub fn is_in_rectangle(&self, rect: &Rectangle) -> bool {
+		between(self.x, rect.left.p1.x, rect.right.p1.x)
+			&& between(self.y, rect.top.p1.y, rect.bottom.p1.y)
+	}
+}
+
+impl Eq for Point {}
+
+impl PartialEq for Point {
+	fn eq(&self, other: &Self) -> bool {
+		self.x == other.x && self.y == other.y
+	}
+}
+
+impl Hash for Point {
+	fn hash<H: Hasher>(&self, hasher: &mut H) {
+		self.x.to_bits().hash(hasher);
+		self.y.to_bits().hash(hasher);
+	}
+}
+
+impl From<&JsPoint> for Point {
+	fn from(point: &JsPoint) -> Self {
+		Self::new(point.x(), point.y())
+	}
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct Line {
+	pub m: f64,
+	pub b: f64,
+	pub p1: Point,
+}
+
+impl Line {
+	pub fn new(m: f64, b: f64, p1: Point) -> Self {
+		Self { m, b, p1 }
+	}
+
+	pub fn from_points(p1: Point, p2: Point) -> Self {
+		let m = (p1.y - p2.y) / (p1.x - p2.x);
+		let b = p1.y - m * p1.x;
+		Self { m, b, p1 }
+	}
+
+	pub fn from_point_and_angle(p1: Point, angle: f64) -> Self {
+		let p2 = Point {
+			x: p1.x - angle.cos(),
+			y: p1.y - angle.sin(),
+		};
+		Line::from_points(p1, p2)
+	}
+
+	pub fn is_vertical(&self) -> bool {
+		self.m.is_infinite()
+	}
+
+	pub fn is_horizontal(&self) -> bool {
+		self.m == 0.0
+	}
+
+	pub fn calc_x(&self, y: f64) -> f64 {
+		(y - self.b) / self.m
+	}
+
+	pub fn calc_y(&self, x: f64) -> f64 {
+		self.m * x + self.b
+	}
+
+	pub fn intersection(&self, other: &Line) -> Option<Point> {
+		// Are both lines vertical?
+		if self.is_vertical() && other.is_vertical() {
+			return None;
+		}
+
+		// Are the lines paralell?
+		if (self.m - other.m).abs() < 0.00000005 {
+			return None;
+		}
+
+		// Is one of the lines vertical?
+		if self.is_vertical() || other.is_vertical() {
+			let vertical;
+			let regular;
+			if self.is_vertical() {
+				vertical = self;
+				regular = other;
+			} else {
+				vertical = other;
+				regular = self;
+			}
+			return Some(Point::from_line_x(regular, vertical.p1.x));
+		}
+
+		// Calculate x coordinate of intersection point between both lines
+		// Find intersection point: x * m1 + b1 = x * m2 + b2
+		// Solve for x: x = (b1 - b2) / (m2 - m1)
+		let x = (self.b - other.b) / (other.m - self.m);
+		if self.m.abs() < other.m.abs() {
+			Some(Point::from_line_x(self, x))
+		} else {
+			Some(Point::from_line_x(other, x))
+		}
+	}
+
+	pub fn get_perpendicular_through_point(&self, p: Point) -> Self {
+		let m = -1.0 / self.m;
+		let b = p.y - m * p.x;
+		Self { m, b, p1: p }
+	}
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct LineSegment {
+	pub p1: Point,
+	pub p2: Point,
+	pub line: Line,
+}
+
+impl LineSegment {
+	pub fn new(p1: Point, p2: Point) -> Self {
+		Self {
+			p1,
+			p2,
+			line: Line::from_points(p1, p2),
+		}
+	}
+
+	pub fn intersection(&self, other: &LineSegment) -> Option<Point> {
+		let intersection = self.line.intersection(&other.line);
+		intersection.filter(|intersection| {
+			self.is_intersection_on_segment(*intersection)
+				&& other.is_intersection_on_segment(*intersection)
+		})
+	}
+
+	fn is_intersection_on_segment(&self, intersection: Point) -> bool {
+		if intersection.is_same_as(&self.p1) || intersection.is_same_as(&self.p2) {
+			return true;
+		}
+		if self.line.is_vertical() || self.line.m.abs() > 1.0 {
+			return between(intersection.y, self.p1.y, self.p2.y);
+		}
+		between(intersection.x, self.p1.x, self.p2.x)
+	}
+
+	pub fn intersects_rect(&self, rect: &Rectangle) -> bool {
+		if self.p1.is_in_rectangle(rect) {
+			return true;
+		}
+		[rect.left, rect.top, rect.right, rect.bottom]
+			.iter()
+			.any(|edge| self.intersection(edge).is_some())
+	}
+}
+
+pub fn between<T: Copy + PartialOrd>(num: T, a: T, b: T) -> bool {
+	let (min, max) = if a < b { (a, b) } else { (b, a) };
+	num >= min && num <= max
+}
+
+#[wasm_bindgen]
+extern "C" {
+	pub type JsRectangle;
+
+	#[wasm_bindgen(method, getter)]
+	fn left(this: &JsRectangle) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn top(this: &JsRectangle) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn right(this: &JsRectangle) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn bottom(this: &JsRectangle) -> f64;
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Rectangle {
+	pub left: LineSegment,
+	pub top: LineSegment,
+	pub right: LineSegment,
+	pub bottom: LineSegment,
+}
+
+impl Rectangle {
+	pub fn new(left: f64, top: f64, right: f64, bottom: f64) -> Self {
+		Self {
+			left: LineSegment::new(Point::new(left, top), Point::new(left, bottom)),
+			top: LineSegment::new(Point::new(left, top), Point::new(right, top)),
+			right: LineSegment::new(Point::new(right, top), Point::new(right, bottom)),
+			bottom: LineSegment::new(Point::new(left, bottom), Point::new(right, bottom)),
+		}
+	}
+}
+
+impl From<&JsRectangle> for Rectangle {
+	fn from(rect: &JsRectangle) -> Self {
+		let left = rect.left();
+		let top = rect.top();
+		let right = rect.right();
+		let bottom = rect.bottom();
+		Self::new(left, top, right, bottom)
+	}
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct Circle {
+	pub center: Point,
+	pub radius: f64,
+}

rust/src/js_api.rs

@@ -0,0 +1,418 @@
+use js_sys::Array;
+use sha1::{Digest, Sha1};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+	geometry::{Circle, LineSegment, Point, Rectangle},
+	pathfinder::{DiscoveredNodePtr, Pathfinder},
+	util::Windows,
+};
+
+#[allow(unused)]
+macro_rules! log {
+	( $( $t:tt )* ) => {
+		log(&format!( $( $t )* ));
+	};
+}
+
+#[wasm_bindgen]
+extern "C" {
+	#[wasm_bindgen(js_namespace = console, js_name=warn)]
+	pub fn log(s: &str);
+
+	#[wasm_bindgen(js_namespace = ["dragRuler", "private"], js_name=terrainRulerWrapper)]
+	pub fn distance_with_terrain(a: Point, b: Point) -> f64;
+}
+
+#[wasm_bindgen]
+extern "C" {
+	pub type JsWall;
+	pub type JsWallData;
+	pub type JsWallFlags;
+	pub type JsWallHeight;
+
+	#[wasm_bindgen(method, getter)]
+	fn data(this: &JsWall) -> JsWallData;
+
+	#[wasm_bindgen(method, getter)]
+	fn c(this: &JsWallData) -> Vec<f64>;
+
+	#[wasm_bindgen(method, getter, js_name = "door")]
+	fn door_type(this: &JsWallData) -> DoorType;
+
+	#[wasm_bindgen(method, getter, js_name = "ds")]
+	fn door_state(this: &JsWallData) -> DoorState;
+
+	#[wasm_bindgen(method, getter, js_name = "move")]
+	fn move_type(this: &JsWallData) -> WallSenseType;
+
+	#[wasm_bindgen(method, getter)]
+	fn flags(this: &JsWallData) -> JsWallFlags;
+
+	#[wasm_bindgen(method, getter, js_name = "wallHeight")]
+	fn wall_height(this: &JsWallFlags) -> Option<JsWallHeight>;
+
+	#[wasm_bindgen(method, getter, js_name = "wallHeightTop")]
+	fn top(this: &JsWallHeight) -> Option<f64>;
+
+	#[wasm_bindgen(method, getter, js_name = "wallHeightBottom")]
+	fn bottom(this: &JsWallHeight) -> Option<f64>;
+}
+
+#[wasm_bindgen]
+extern "C" {
+	pub type JsPoint;
+
+	#[wasm_bindgen(method, getter)]
+	fn x(this: &JsPoint) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn y(this: &JsPoint) -> f64;
+}
+
+impl From<JsPoint> for Point {
+	fn from(point: JsPoint) -> Self {
+		Point {
+			x: point.x(),
+			y: point.y(),
+		}
+	}
+}
+
+#[wasm_bindgen]
+extern "C" {
+	pub type JsTerrainInfo;
+	pub type JsTerrainObject;
+	pub type JsTerrainShape;
+
+	#[wasm_bindgen(method, getter)]
+	fn object(this: &JsTerrainInfo) -> JsTerrainObject;
+
+	#[wasm_bindgen(method, getter)]
+	fn shape(this: &JsTerrainInfo) -> JsTerrainShape;
+
+	#[wasm_bindgen(method, getter)]
+	fn x(this: &JsTerrainObject) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn y(this: &JsTerrainObject) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn width(this: &JsTerrainObject) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn height(this: &JsTerrainObject) -> f64;
+
+	#[wasm_bindgen(method, getter, js_name = "type")]
+	fn shape_type(this: &JsTerrainShape) -> u32;
+
+	#[wasm_bindgen(method, getter)]
+	fn x(this: &JsTerrainShape) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn y(this: &JsTerrainShape) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn radius(this: &JsTerrainShape) -> f64;
+
+	#[wasm_bindgen(method, getter)]
+	fn points(this: &JsTerrainShape) -> Vec<f64>;
+}
+
+impl JsTerrainObject {
+	fn to_bounding_rect(&self) -> Rectangle {
+		let left = self.x();
+		let top = self.y();
+		let right = left + self.width();
+		let bottom = top + self.height();
+		Rectangle::new(left, top, right, bottom)
+	}
+}
+
+impl JsTerrainShape {
+	fn to_segments(&self, x: f64, y: f64) -> Vec<LineSegment> {
+		let points = self.points();
+		assert!(points.len() % 2 == 0);
+		points
+			.chunks(2)
+			.map(|coordinates| Point::new(coordinates[0] + x, coordinates[1] + y))
+			.windows()
+			.map(|(p1, p2)| LineSegment::new(p1, p2))
+			.collect()
+	}
+
+	fn to_circle(&self, x: f64, y: f64) -> Circle {
+		let center = Point::new(self.x() + x, self.y() + y);
+		let radius = self.radius();
+		Circle { center, radius }
+	}
+}
+
+impl From<&JsTerrainInfo> for TerrainShape {
+	fn from(terrain: &JsTerrainInfo) -> Self {
+		let shape = terrain.shape();
+		let object = terrain.object();
+		let x = object.x();
+		let y = object.y();
+		match shape.shape_type() {
+			0 => TerrainShape::Polygon(shape.to_segments(x, y)),
+			2 => TerrainShape::Circle(shape.to_circle(x, y)),
+			_ => unimplemented!(),
+		}
+	}
+}
+
+#[derive(Debug, Clone)]
+pub enum TerrainShape {
+	Polygon(Vec<LineSegment>),
+	Circle(Circle),
+}
+
+#[derive(Debug, Clone)]
+pub struct Terrain {
+	pub shape: TerrainShape,
+	pub bounding_box: Rectangle,
+}
+
+impl From<&JsTerrainInfo> for Terrain {
+	fn from(terrain: &JsTerrainInfo) -> Self {
+		let bounding_box = terrain.object().to_bounding_rect();
+		let shape = terrain.into();
+		Self {
+			bounding_box,
+			shape,
+		}
+	}
+}
+
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum DoorState {
+	CLOSED = 0,
+	OPEN = 1,
+	LOCKED = 2,
+}
+
+impl TryFrom<usize> for DoorState {
+	type Error = ();
+	fn try_from(value: usize) -> Result<Self, Self::Error> {
+		match value {
+			x if x == Self::CLOSED as usize => Ok(Self::CLOSED),
+			x if x == Self::OPEN as usize => Ok(Self::OPEN),
+			x if x == Self::LOCKED as usize => Ok(Self::LOCKED),
+			_ => Err(()),
+		}
+	}
+}
+
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum DoorType {
+	NONE = 0,
+	DOOR = 1,
+	SECRET = 2,
+}
+
+impl TryFrom<usize> for DoorType {
+	type Error = ();
+	fn try_from(value: usize) -> Result<Self, Self::Error> {
+		match value {
+			x if x == Self::NONE as usize => Ok(Self::NONE),
+			x if x == Self::DOOR as usize => Ok(Self::DOOR),
+			x if x == Self::SECRET as usize => Ok(Self::SECRET),
+			_ => Err(()),
+		}
+	}
+}
+
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum WallSenseType {
+	NONE = 0,
+	LIMITED = 10,
+	NORMAL = 20,
+}
+
+impl TryFrom<usize> for WallSenseType {
+	type Error = ();
+	fn try_from(value: usize) -> Result<Self, Self::Error> {
+		match value {
+			x if x == Self::NONE as usize => Ok(Self::NONE),
+			x if x == Self::LIMITED as usize => Ok(Self::LIMITED),
+			x if x == Self::NORMAL as usize => Ok(Self::NORMAL),
+			_ => Err(()),
+		}
+	}
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct WallHeight {
+	pub top: f64,
+	pub bottom: f64,
+}
+
+impl Default for WallHeight {
+	fn default() -> Self {
+		Self {
+			top: f64::INFINITY,
+			bottom: f64::NEG_INFINITY,
+		}
+	}
+}
+
+impl From<Option<JsWallHeight>> for WallHeight {
+	fn from(height: Option<JsWallHeight>) -> Self {
+		let height = height
+			.map(|height| (height.top(), height.bottom()))
+			.unwrap_or((None, None));
+		let top = height.0.unwrap_or(WallHeight::default().top);
+		let bottom = height.1.unwrap_or(WallHeight::default().bottom);
+		Self { top, bottom }
+	}
+}
+
+impl WallHeight {
+	pub fn contains(&self, height: f64) -> bool {
+		self.top >= height && self.bottom <= height
+	}
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Wall {
+	pub p1: Point,
+	pub p2: Point,
+	pub door_type: DoorType,
+	pub door_state: DoorState,
+	pub move_type: WallSenseType,
+	pub height: WallHeight,
+}
+
+impl Wall {
+	pub fn new(
+		p1: Point,
+		p2: Point,
+		door_type: DoorType,
+		door_state: DoorState,
+		move_type: WallSenseType,
+		height: WallHeight,
+	) -> Self {
+		Self {
+			p1,
+			p2,
+			door_type,
+			door_state,
+			move_type,
+			height,
+		}
+	}
+
+	pub fn is_door(&self) -> bool {
+		self.door_type != DoorType::NONE
+	}
+
+	pub fn is_open(&self) -> bool {
+		self.door_state == DoorState::OPEN
+	}
+}
+
+impl Wall {
+	fn from_js(wall: &JsWall, enable_height: bool) -> Self {
+		let data = wall.data();
+		let mut c = data.c();
+		c.iter_mut().for_each(|val| *val = val.round());
+		let height = if enable_height {
+			data.flags().wall_height().into()
+		} else {
+			WallHeight::default()
+		};
+		Self::new(
+			Point::new(c[0], c[1]),
+			Point::new(c[2], c[3]),
+			data.door_type(),
+			data.door_state(),
+			data.move_type(),
+			height,
+		)
+	}
+}
+
+#[allow(dead_code)]
+#[wasm_bindgen]
+pub fn initialize(
+	js_walls: Vec<JsValue>,
+	js_terrain: Vec<JsTerrainInfo>,
+	token_size: f64,
+	token_elevation: f64,
+	enable_height: bool,
+) -> Pathfinder {
+	let mut walls = Vec::with_capacity(js_walls.len());
+	for wall in js_walls {
+		let wall = JsWall::from(wall);
+		walls.push(Wall::from_js(&wall, enable_height));
+	}
+	let terrain = js_terrain.iter().map(|terrain| terrain.into()).collect();
+	Pathfinder::initialize(walls, terrain, token_size, token_elevation)
+}
+
+#[allow(dead_code)]
+#[wasm_bindgen]
+pub fn free(pathfinder: Pathfinder) {
+	drop(pathfinder);
+}
+
+#[allow(dead_code)]
+#[wasm_bindgen(js_name=findPath)]
+pub fn find_path(pathfinder: &mut Pathfinder, from: JsPoint, to: JsPoint) -> Option<Array> {
+	pathfinder
+		.find_path(from.into(), to.into())
+		.map(|first_node| first_node.iter_path().map(JsValue::from).collect())
+}
+
+#[allow(dead_code)]
+#[wasm_bindgen(js_name=debugGetPathfindingPoints)]
+pub fn debug_get_pathfinding_points(pathfinder: &Pathfinder) -> Array {
+	pathfinder
+		.nodes
+		.iter()
+		.map(|node| node.borrow().point)
+		.map(JsValue::from)
+		.collect()
+}
+
+#[allow(dead_code)]
+#[wasm_bindgen]
+pub fn sha1(input: &str) -> String {
+	let mut hasher = Sha1::new();
+	hasher.update(input);
+	format!("{:x}", hasher.finalize())
+}
+
+trait IteratePath {
+	fn iter_path(&self) -> PathIterator;
+}
+
+impl IteratePath for DiscoveredNodePtr {
+	fn iter_path(&self) -> PathIterator {
+		PathIterator {
+			current_node: Some(self.clone()),
+		}
+	}
+}
+
+struct PathIterator {
+	current_node: Option<DiscoveredNodePtr>,
+}
+
+impl Iterator for PathIterator {
+	type Item = Point;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		if let Some(node) = self.current_node.clone() {
+			let point = node.borrow().node.borrow().point;
+			self.current_node = node.borrow().previous.clone();
+			Some(point)
+		} else {
+			None
+		}
+	}
+}

rust/src/lib.rs

@@ -0,0 +1,13 @@
+mod geometry;
+#[macro_use]
+mod js_api;
+mod pathfinder;
+mod ptr_indexed_hash_set;
+mod util;
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(start)]
+pub fn main() {
+	std::panic::set_hook(Box::new(console_error_panic_hook::hook));
+}

rust/src/pathfinder.rs

@@ -0,0 +1,381 @@
+use std::{cell::RefCell, f64::consts::PI, rc::Rc};
+
+use wasm_bindgen::prelude::*;
+
+use rustc_hash::FxHashMap;
+
+use crate::{
+	geometry::{LineSegment, Point, Rectangle},
+	js_api::{distance_with_terrain, Terrain, TerrainShape, Wall, WallSenseType, log},
+	ptr_indexed_hash_set::PtrIndexedHashSet,
+};
+
+pub struct Edge {
+	target: NodePtr,
+	cost: f64,
+}
+
+pub struct Node {
+	pub point: Point,
+	edges: Option<Vec<Edge>>,
+	final_edge: Option<Option<Edge>>,
+}
+
+impl Node {
+	pub fn new(point: Point) -> Self {
+		Self {
+			point,
+			edges: None,
+			final_edge: None,
+		}
+	}
+
+	fn iter_edges(
+		&self,
+	) -> std::iter::Chain<std::slice::Iter<'_, Edge>, std::option::Iter<'_, Edge>> {
+		self.edges
+			.as_ref()
+			.unwrap()
+			.iter()
+			.chain(self.final_edge.as_ref().unwrap().iter())
+	}
+}
+
+type NodePtr = Rc<RefCell<Node>>;
+
+impl From<Node> for NodePtr {
+	fn from(node: Node) -> Self {
+		Rc::new(RefCell::new(node))
+	}
+}
+
+pub struct DiscoveredNode {
+	pub node: NodePtr,
+	cost: f64,
+	estimated: f64,
+	pub previous: Option<DiscoveredNodePtr>,
+}
+
+pub type DiscoveredNodePtr = Rc<RefCell<DiscoveredNode>>;
+
+impl From<DiscoveredNode> for DiscoveredNodePtr {
+	fn from(node: DiscoveredNode) -> Self {
+		Rc::new(RefCell::new(node))
+	}
+}
+
+#[derive(Default, Clone)]
+pub struct NodeStorage {
+	regular_nodes: Vec<NodePtr>,
+	final_node: Option<NodePtr>,
+}
+
+pub type NodeStorageIterator<'a> = std::iter::Chain<
+	std::slice::Iter<'a, Rc<RefCell<Node>>>,
+	std::option::Iter<'a, Rc<RefCell<Node>>>,
+>;
+
+impl NodeStorage {
+	fn new() -> Self {
+		Self::default()
+	}
+
+	fn push(&mut self, node: NodePtr) {
+		self.regular_nodes.push(node);
+	}
+
+	fn initialize_edges(&mut self, node: &NodePtr, walls: &[LineSegment], terrain: &[Rectangle]) {
+		if node.borrow().final_edge.is_none() {
+			let final_edge = self
+				.final_node
+				.as_ref()
+				.filter(|neighbor| {
+					!self.collides_with_wall(
+						&LineSegment::new(node.borrow().point, neighbor.borrow().point),
+						walls,
+					)
+				})
+				.map(|neighbor| Edge {
+					target: neighbor.clone(),
+					cost: Self::measure_distance(
+						node.borrow().point,
+						neighbor.borrow().point,
+						terrain,
+					),
+				});
+			node.borrow_mut().final_edge = Some(final_edge);
+		}
+
+		if node.borrow().edges.is_some() {
+			return;
+		}
+
+		let point = node.borrow().point;
+		let mut edges = Vec::new();
+		for neighbor in &self.regular_nodes {
+			if Rc::ptr_eq(neighbor, node) {
+				continue;
+			}
+			let neighbor_point = neighbor.borrow().point;
+			if !self.collides_with_wall(&LineSegment::new(point, neighbor_point), walls) {
+				let cost =
+					Self::measure_distance(node.borrow().point, neighbor.borrow().point, terrain);
+				edges.push(Edge {
+					target: neighbor.clone(),
+					cost,
+				});
+			}
+		}
+		node.borrow_mut().edges = Some(edges);
+	}
+
+	fn collides_with_wall(&self, line: &LineSegment, walls: &[LineSegment]) -> bool {
+		walls.iter().any(|wall| line.intersection(wall).is_some())
+	}
+
+	fn measure_distance(a: Point, b: Point, terrain: &[Rectangle]) -> f64 {
+		let segment = LineSegment::new(a, b);
+		if terrain.iter().any(|rect| segment.intersects_rect(rect)) {
+			distance_with_terrain(a, b)
+		} else {
+			a.distance_to(b)
+		}
+	}
+
+	pub fn cleanup_final_edges(&mut self) {
+		for node in &self.regular_nodes {
+			node.borrow_mut().final_edge = None;
+		}
+	}
+
+	pub fn iter(&self) -> NodeStorageIterator {
+		self.regular_nodes.iter().chain(self.final_node.iter())
+	}
+}
+
+#[wasm_bindgen]
+pub struct Pathfinder {
+	#[wasm_bindgen(skip)]
+	pub nodes: NodeStorage,
+	#[wasm_bindgen(skip)]
+	pub walls: Vec<LineSegment>,
+	#[wasm_bindgen(skip)]
+	pub terrain: Vec<Rectangle>,
+}
+
+impl Pathfinder {
+	pub fn initialize(
+		walls: Vec<Wall>,
+		terrain: Vec<Terrain>,
+		token_size: f64,
+		token_elevation: f64,
+	) -> Self {
+		log!("{:#?}", terrain);
+		let distance_from_walls = token_size / 2.0;
+
+		// TODO Place pathfinding nodes around terrain edges
+		let mut polygon_terrain = Vec::new();
+		let mut circle_terrain = Vec::new();
+
+		for terrain in &terrain {
+			match &terrain.shape {
+				TerrainShape::Polygon(polygon) => polygon_terrain.append(&mut polygon.clone()),
+				TerrainShape::Circle(circle) => circle_terrain.push(circle),
+			}
+		}
+
+		let mut walls = walls
+			.into_iter()
+			.filter(|wall| wall.move_type != WallSenseType::NONE)
+			.filter(|wall| !(wall.is_door() && wall.is_open()))
+			.filter(|wall| wall.height.contains(token_elevation))
+			.map(|wall| LineSegment::new(wall.p1, wall.p2))
+			.collect::<Vec<_>>();
+
+		// TODO Generate points around difficult terrain
+		let mut endpoints = FxHashMap::<Point, Vec<f64>>::default();
+
+		for segments in walls.iter().chain(polygon_terrain.iter()) {
+			let x_diff = segments.p2.x - segments.p1.x;
+			let y_diff = segments.p2.y - segments.p1.y;
+			let p1_angle = y_diff.atan2(x_diff).rem_euclid(2.0 * PI);
+			let p2_angle = (p1_angle + PI).rem_euclid(2.0 * PI);
+			for (point, angle) in [(segments.p1, p1_angle), (segments.p2, p2_angle)] {
+				let angles = endpoints.entry(point).or_insert_with(Vec::new);
+				angles.push(angle);
+			}
+		}
+		endpoints
+			.values_mut()
+			.for_each(|angles| angles.sort_by(|a, b| a.partial_cmp(b).unwrap()));
+		let mut nodes = NodeStorage::new();
+		for (point, angles) in endpoints {
+			assert!(!angles.is_empty());
+			for i in 1..angles.len() {
+				let angle1 = angles[i - 1];
+				let angle2 = angles[i];
+				if angle1 == angle2 {
+					continue;
+				}
+				let angle_diff = angle2 - angle1;
+				if angle_diff <= PI {
+					continue;
+				}
+				let angle_between = angle_diff / 2.0 + angle1;
+				nodes.push(calc_pathfinding_node(
+					point,
+					angle_between,
+					distance_from_walls,
+					&mut walls,
+				));
+				nodes.push(calc_pathfinding_node(
+					point,
+					angle1 + 0.5 * PI,
+					distance_from_walls,
+					&mut walls,
+				));
+				nodes.push(calc_pathfinding_node(
+					point,
+					angle2 - 0.5 * PI,
+					distance_from_walls,
+					&mut walls,
+				));
+			}
+			let angle1 = angles.last().unwrap();
+			let angle2 = angles.first().unwrap() + 2.0 * PI;
+			let angle_diff = angle2 - angle1;
+			if angle_diff <= PI {
+				continue;
+			}
+			let angle_between = angle_diff / 2.0 + angle1;
+			nodes.push(calc_pathfinding_node(
+				point,
+				angle_between,
+				distance_from_walls,
+				&mut walls,
+			));
+			nodes.push(calc_pathfinding_node(
+				point,
+				angle1 + 0.5 * PI,
+				distance_from_walls,
+				&mut walls,
+			));
+			nodes.push(calc_pathfinding_node(
+				point,
+				angle2 - 0.5 * PI,
+				distance_from_walls,
+				&mut walls,
+			));
+		}
+
+		// TODO Check bounding box of circle terrain
+		for circle in circle_terrain {
+			let angle_step = f64::asin(token_size / 2.0 / circle.radius);
+			let mut angle = 0.0;
+			while angle < 2.0 * PI {
+				let point = Point {
+					x: circle.center.x + angle.cos() * circle.radius,
+					y: circle.center.y + angle.sin() * circle.radius,
+				};
+				nodes.push(calc_pathfinding_node(
+					point,
+					angle,
+					distance_from_walls,
+					&mut walls,
+				));
+				angle += angle_step;
+			}
+		}
+
+		// TODO Eliminating nodes close to each other may improve performance
+		Self {
+			nodes,
+			walls,
+			terrain: terrain.iter().map(|terrain| terrain.bounding_box).collect(),
+		}
+	}
+
+	pub fn find_path(&mut self, from: Point, to: Point) -> Option<DiscoveredNodePtr> {
+		self.nodes.cleanup_final_edges();
+		let mut nodes = self.nodes.clone();
+		nodes.final_node = Some(NodePtr::from(Node::new(from)));
+		let to_node = NodePtr::from(Node::new(to));
+		nodes.initialize_edges(&to_node, &self.walls, &self.terrain);
+		let to = DiscoveredNode {
+			node: to_node,
+			cost: 0.0,
+			estimated: to.distance_to(from),
+			previous: None,
+		};
+		// TODO Use a sorted set for next_nodes for better performance
+		let mut next_nodes = vec![DiscoveredNodePtr::from(to)];
+		let mut previous_nodes = PtrIndexedHashSet::new();
+		while !next_nodes.is_empty() {
+			// Sort by estimated cost, high to low
+			// TODO Maybe tere's a faster way to do this than re-sorting every iteration?
+			next_nodes.sort_by(|a, b| {
+				b.borrow()
+					.estimated
+					.partial_cmp(&a.borrow().estimated)
+					.unwrap()
+			});
+
+			// Get node with cheapest estimate
+			let current_node = next_nodes.pop().unwrap();
+			if current_node.borrow().node.borrow().point.x == from.x
+				&& current_node.borrow().node.borrow().point.y == from.y
+			{
+				return Some(current_node);
+			}
+			previous_nodes.insert(current_node.borrow().node.clone());
+			for edge in current_node.borrow().node.borrow().iter_edges() {
+				let neighbor = &edge.target;
+				if previous_nodes.contains(neighbor) {
+					continue;
+				}
+				nodes.initialize_edges(neighbor, &self.walls, &self.terrain);
+				// Add a flat 0.00001 cost per node to discurage creation of unnecessary waypoints
+				let cost = current_node.borrow().cost + edge.cost + 0.00001;
+				let discovered_neighbor = DiscoveredNode {
+					node: neighbor.clone(),
+					cost,
+					estimated: cost + neighbor.borrow().point.distance_to(from),
+					previous: Some(current_node.clone()),
+				};
+				let neighbor_entry = next_nodes
+					.iter()
+					.find(|node| Rc::ptr_eq(&node.borrow().node, neighbor));
+				if let Some(entry) = neighbor_entry {
+					// If the neighbor is cheaper to reach via the current route than through previously discovered routes, replace it
+					if entry.borrow().cost > cost {
+						*entry.borrow_mut() = discovered_neighbor;
+					}
+				} else {
+					next_nodes.push(discovered_neighbor.into());
+				}
+			}
+		}
+		None
+	}
+}
+
+fn calc_pathfinding_node(
+	p: Point,
+	angle: f64,
+	distance_from_walls: f64,
+	walls: &mut Vec<LineSegment>,
+) -> NodePtr {
+	let offset_x = angle.cos() * distance_from_walls;
+	let offset_y = angle.sin() * distance_from_walls;
+	walls.push(LineSegment::new(
+		p,
+		Point {
+			x: p.x + offset_x * 0.99,
+			y: p.y + offset_y * 0.99,
+		},
+	));
+	NodePtr::from(Node::new(Point {
+		x: p.x + offset_x,
+		y: p.y + offset_y,
+	}))
+}

rust/src/ptr_indexed_hash_set.rs

@@ -0,0 +1,68 @@
+use rustc_hash::FxHashSet;
+use std::collections::hash_set;
+use std::hash::{Hash, Hasher};
+use std::rc::Rc;
+
+#[derive(Default)]
+pub struct PtrIndexedHashSet<T>(FxHashSet<PtrIndexedRc<T>>);
+
+impl<T> PtrIndexedHashSet<T> {
+	pub fn new() -> Self {
+		PtrIndexedHashSet(FxHashSet::default())
+	}
+
+	pub fn insert(&mut self, value: Rc<T>) -> bool {
+		self.0.insert(PtrIndexedRc(value))
+	}
+
+	pub fn remove(&mut self, value: &Rc<T>) -> bool {
+		self.0.remove(&PtrIndexedRc(Rc::clone(value)))
+	}
+
+	pub fn contains(&mut self, value: &Rc<T>) -> bool {
+		self.0.contains(&PtrIndexedRc(Rc::clone(value)))
+	}
+}
+
+impl<T: std::fmt::Debug> std::fmt::Debug for PtrIndexedHashSet<T> {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		f.debug_set().entries(self.0.iter().map(|e| &e.0)).finish()
+	}
+}
+
+struct PtrIndexedRc<T>(Rc<T>);
+
+impl<T> Hash for PtrIndexedRc<T> {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		Rc::as_ptr(&self.0).hash(state)
+	}
+}
+
+impl<T> PartialEq for PtrIndexedRc<T> {
+	fn eq(&self, other: &Self) -> bool {
+		Rc::ptr_eq(&self.0, &other.0)
+	}
+}
+
+impl<T> Eq for PtrIndexedRc<T> {}
+
+pub struct PtrIndexedHashSetIterator<'a, T>(hash_set::Iter<'a, PtrIndexedRc<T>>);
+
+impl<'a, T> Iterator for PtrIndexedHashSetIterator<'a, T> {
+	type Item = &'a Rc<T>;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		match self.0.next() {
+			Some(item) => Some(&item.0),
+			None => None,
+		}
+	}
+}
+
+impl<'a, T> IntoIterator for &'a PtrIndexedHashSet<T> {
+	type Item = &'a Rc<T>;
+	type IntoIter = PtrIndexedHashSetIterator<'a, T>;
+	fn into_iter(self) -> Self::IntoIter {
+		PtrIndexedHashSetIterator::<T>((&self.0).iter())
+	}
+}

rust/src/util.rs

@@ -0,0 +1,44 @@
+pub struct WindowIterator<I: Iterator> {
+	iterator: I,
+	previous: Option<I::Item>,
+}
+
+impl<I: Iterator> Iterator for WindowIterator<I>
+where
+	I::Item: Copy,
+{
+	type Item = (I::Item, I::Item);
+
+	fn next(&mut self) -> Option<Self::Item> {
+		if self.previous.is_none() {
+			self.previous = self.iterator.next();
+		}
+		let current = self.iterator.next();
+		if current.is_none() {
+			return None;
+		}
+		let current = current.unwrap();
+		let previous = self.previous.unwrap();
+		let result = (current, previous);
+		self.previous = Some(current);
+		Some(result)
+	}
+}
+
+pub trait Windows<T> {
+	fn windows(self) -> WindowIterator<Self>
+	where
+		Self: Sized + Iterator;
+}
+
+impl<I: Iterator> Windows<I> for I {
+	fn windows(self) -> WindowIterator<Self>
+	where
+		Self: Sized + Iterator,
+	{
+		WindowIterator {
+			iterator: self,
+			previous: None,
+		}
+	}
+}

src/main.js

@@ -1,210 +0,0 @@
-"use strict"
-
-import {currentSpeedProvider, getMovedDistanceFromToken, getRangesFromSpeedProvider, getUnreachableColorFromSpeedProvider, initApi, registerModule, registerSystem} from "./api.js"
-import {checkDependencies, getHexSizeSupportTokenGridCenter} from "./compatibility.js";
-import {moveEntities, onMouseMove} from "./foundry_imports.js"
-import {performMigrations} from "./migration.js"
-import {DragRulerRuler} from "./ruler.js";
-import {getMovementHistory, resetMovementHistory} from "./movement_tracking.js";
-import {registerSettings, settingsKey} from "./settings.js"
-import {recalculate} from "./socket.js";
-import {SpeedProvider} from "./speed_provider.js"
-
-Hooks.once("init", () => {
-	registerSettings()
-	initApi()
-	hookDragHandlers(Token);
-	hookDragHandlers(MeasuredTemplate);
-	hookKeyboardManagerFunctions()
-
-	Ruler = DragRulerRuler;
-
-	window.dragRuler = {
-		getColorForDistance,
-		getMovedDistanceFromToken,
-		registerModule,
-		registerSystem,
-		recalculate,
-		resetMovementHistory,
-	}
-})
-
-Hooks.once("ready", () => {
-	performMigrations()
-	checkDependencies();
-	Hooks.callAll("dragRuler.ready", SpeedProvider)
-})
-
-Hooks.on("canvasReady", () => {
-	canvas.controls.rulers.children.forEach(ruler => {
-		ruler.draggedEntity = null;
-		Object.defineProperty(ruler, "isDragRuler", {
-			get: function isDragRuler() {
-				return Boolean(this.draggedEntity); // If draggedEntity is set this is a drag ruler
-			}
-		})
-	})
-})
-
-Hooks.on("getCombatTrackerEntryContext", function (html, menu) {
-	const entry = {
-		name: "drag-ruler.resetMovementHistory",
-		icon: '<i class="fas fa-undo-alt"></i>',
-		callback: li => resetMovementHistory(ui.combat.viewed, li.data('combatant-id')),
-	};
-	menu.splice(1, 0, entry);
-});
-
-function hookDragHandlers(entityType) {
-	const originalDragLeftStartHandler = entityType.prototype._onDragLeftStart
-	entityType.prototype._onDragLeftStart = function(event) {
-		originalDragLeftStartHandler.call(this, event)
-		onEntityLeftDragStart.call(this, event)
-	}
-
-	const originalDragLeftMoveHandler = entityType.prototype._onDragLeftMove
-	entityType.prototype._onDragLeftMove = function (event) {
-		originalDragLeftMoveHandler.call(this, event)
-		onEntityLeftDragMove.call(this, event)
-	}
-
-	const originalDragLeftDropHandler = entityType.prototype._onDragLeftDrop
-	entityType.prototype._onDragLeftDrop = function (event) {
-		const eventHandled = onEntityDragLeftDrop.call(this, event)
-		if (!eventHandled)
-			originalDragLeftDropHandler.call(this, event)
-	}
-
-	const originalDragLeftCancelHandler = entityType.prototype._onDragLeftCancel
-	entityType.prototype._onDragLeftCancel = function (event) {
-		const eventHandled = onEntityDragLeftCancel.call(this, event)
-		if (!eventHandled)
-			originalDragLeftCancelHandler.call(this, event)
-	}
-}
-
-function hookKeyboardManagerFunctions() {
-	const originalHandleKeys = KeyboardManager.prototype._handleKeys
-	KeyboardManager.prototype._handleKeys = function (event, key, up) {
-		const eventHandled = handleKeys.call(this, event, key, up)
-		if (!eventHandled)
-			originalHandleKeys.call(this, event, key, up)
-	}
-}
-
-function handleKeys(event, key, up) {
-	if (event.repeat || this.hasFocus)
-		return false
-
-	if (key.toLowerCase() === "x") return onKeyX(up)
-	if (key.toLowerCase() === "shift") return onKeyShift(up)
-	return false
-}
-
-function onKeyX(up) {
-	if (up)
-		return false
-	const ruler = canvas.controls.ruler;
-	if (!ruler.isDragRuler)
-		return false
-
-	ruler.dragRulerDeleteWaypoint();
-	return true
-}
-
-function onKeyShift(up) {
-	const ruler = canvas.controls.ruler
-	if (!ruler.isDragRuler)
-		return false
-	if (ruler._state !== Ruler.STATES.MEASURING)
-		return false;
-
-	const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens)
-	const rulerOffset = ruler.rulerOffset
-	const measurePosition = {x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y}
-	ruler.measure(measurePosition, {snap: up})
-}
-
-function onEntityLeftDragStart(event) {
-	const isToken = this instanceof Token;
-	if (isToken && !currentSpeedProvider.usesRuler(this))
-		return
-	const ruler = canvas.controls.ruler
-	ruler.draggedEntity = this;
-	let entityCenter;
-	if (isToken && canvas.grid.isHex && game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(this))
-		entityCenter = getHexSizeSupportTokenGridCenter(this);
-	else
-		entityCenter = this.center;
-	ruler.clear();
-	ruler._state = Ruler.STATES.STARTING;
-	ruler.rulerOffset = {x: entityCenter.x - event.data.origin.x, y: entityCenter.y - event.data.origin.y};
-	if (isToken && game.settings.get(settingsKey, "enableMovementHistory"))
-		ruler.dragRulerAddWaypointHistory(getMovementHistory(this));
-	ruler.dragRulerAddWaypoint(entityCenter, false);
-}
-
-function onEntityLeftDragMove(event) {
-	const ruler = canvas.controls.ruler
-	if (ruler.isDragRuler)
-		onMouseMove.call(ruler, event)
-}
-
-function onEntityDragLeftDrop(event) {
-	const ruler = canvas.controls.ruler
-	if (!ruler.isDragRuler)
-		return false
-	// When we're dragging a measured template no token will ever be selected,
-	// resulting in only the dragged template to be moved as would be expected
-	const selectedTokens = canvas.tokens.controlled
-	// This can happen if the user presses ESC during drag (maybe there are other ways too)
-	if (selectedTokens.length === 0)
-		selectedTokens.push(ruler.draggedEntity);
-	ruler._state = Ruler.STATES.MOVING
-	moveEntities.call(ruler, ruler.draggedEntity, selectedTokens);
-	return true
-}
-
-function onEntityDragLeftCancel(event) {
-	// This function is invoked by right clicking
-	const ruler = canvas.controls.ruler
-	if (!ruler.isDragRuler || ruler._state === Ruler.STATES.MOVING)
-		return false
-	if (ruler._state === Ruler.STATES.MEASURING) {
-		if (!game.settings.get(settingsKey, "swapSpacebarRightClick")) {
-			ruler.dragRulerDeleteWaypoint(event);
-		}
-		else {
-			event.preventDefault()
-			const snap = !event.shiftKey
-			ruler.dragRulerAddWaypoint(ruler.destination, snap);
-		}
-	}
-	return true
-}
-
-export function getColorForDistance(startDistance, subDistance=0) {
-	if (!this.isDragRuler)
-		return this.color
-	if (!this.draggedEntity.actor) {
-		return this.color;
-	}
-	// Don't apply colors if the current user doesn't have at least observer permissions
-	if (this.draggedEntity.actor.permission < 2) {
-		// If this is a pc and alwaysShowSpeedForPCs is enabled we show the color anyway
-		if (!(this.draggedEntity.actor.data.type === "character" && game.settings.get(settingsKey, "alwaysShowSpeedForPCs")))
-			return this.color
-	}
-	const distance = startDistance + subDistance
-	if (!this.dragRulerRanges)
-		this.dragRulerRanges = getRangesFromSpeedProvider(this.draggedEntity);
-	const ranges = this.dragRulerRanges;
-	if (ranges.length === 0)
-		return this.color
-	const currentRange = ranges.reduce((minRange, currentRange) => {
-		if (distance <= currentRange.range && currentRange.range < minRange.range)
-			return currentRange
-		return minRange
-	}, {range: Infinity, color: getUnreachableColorFromSpeedProvider()})
-	return currentRange.color
-}

src/migration.js

@@ -1,27 +0,0 @@
-import {settingsKey} from "./settings.js"
-
-const currentDataVersion = "1.3.0"
-
-export function performMigrations() {
-	if (!game.user.isGM)
-		return
-
-	let dataVersion = game.settings.get(settingsKey, "dataVersion")
-	if (dataVersion === "fresh install") {
-		// Migration from unnamed version. TODO Remove this in a future version
-		let speedAttribute = game.settings.storage.get("world").get(`${settingsKey}.speedAttribute`)
-		if (speedAttribute)
-			speedAttribute = speedAttribute.slice(1, speedAttribute.length - 1)
-		const speedAttributeDefault = game.settings.get(settingsKey, "speedProviders.native.setting.speedAttribute")
-		if (speedAttribute !== speedAttributeDefault)
-			game.settings.set(settingsKey, "speedProviders.native.setting.speedAttribute", speedAttribute)
-
-		let dashMultiplier = game.settings.storage.get("world").get(`${settingsKey}.dashMultiplier`)
-		const dashMultiplierDefault = game.settings.get(settingsKey, "speedProviders.native.setting.dashMultiplier")
-		if (dashMultiplier !== dashMultiplierDefault)
-			game.settings.set(settingsKey, "speedProviders.native.setting.dashMultiplier", dashMultiplier)
-		// End of unnamed version migration code
-		game.settings.set(settingsKey, "dataVersion", currentDataVersion)
-		return
-	}
-}

src/ruler.js

@@ -1,141 +0,0 @@
-import {measure} from "./foundry_imports.js"
-import {getMovementHistory} from "./movement_tracking.js";
-import {settingsKey} from "./settings.js";
-import {getSnapPointForEntity} from "./util.js";
-
-export class DragRulerRuler extends Ruler {
-	// Functions below are overridden versions of functions in Ruler
-	constructor(user, {color=null}={}) {
-		super(user, {color});
-		this.previousWaypoints = [];
-		this.previousLabels = this.addChild(new PIXI.Container());
-	}
-
-	clear() {
-		super.clear();
-		this.previousWaypoints = [];
-		this.previousLabels.removeChildren().forEach(c => c.destroy());
-		this.dragRulerRanges = undefined;
-	}
-
-	async moveToken(event) {
-		// This function is invoked by left clicking
-		if (!this.isDragRuler)
-			return await super.moveToken(event);
-		if (!game.settings.get(settingsKey, "swapSpacebarRightClick")) {
-			const snap = !event.shiftKey;
-			this.dragRulerAddWaypoint(this.destination, snap);
-		}
-		else {
-			this.dragRulerDeleteWaypoint();
-		}
-	}
-
-	toJSON() {
-		const json = super.toJSON();
-		if (this.draggedEntity) {
-			const isToken = this.draggedEntity instanceof Token;
-			json["draggedEntityIsToken"] = isToken;
-			json["draggedEntity"] = this.draggedEntity.id;
-		}
-		return json;
-	}
-
-	update(data) {
-		// Don't show a GMs drag ruler to non GM players
-		if (data.draggedEntity && this.user.isGM && !game.user.isGM && !game.settings.get(settingsKey, "showGMRulerToPlayers"))
-			return;
-
-		if (data.draggedEntity) {
-			if (data.draggedEntityIsToken)
-				this.draggedEntity = canvas.tokens.get(data.draggedEntity);
-			else
-				this.draggedEntity = canvas.templates.get(data.draggedEntity);
-		}
-		super.update(data);
-	}
-
-	measure(destination, options={}) {
-		if (this.isDragRuler) {
-			return measure.call(this, destination, options);
-		}
-		else {
-			return super.measure(destination, options);
-		}
-	}
-
-	_endMeasurement() {
-		super._endMeasurement();
-		this.draggedEntity = null;
-	}
-
-	// The functions below aren't present in the orignal Ruler class and are added by Drag Ruler
-	dragRulerAddWaypoint(point, snap=true) {
-		if (snap) {
-			point = getSnapPointForEntity(point.x, point.y, this.draggedEntity);
-		}
-		this.waypoints.push(new PIXI.Point(point.x, point.y));
-		this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
-	}
-
-	dragRulerAddWaypointHistory(waypoints) {
-		waypoints.forEach(waypoint => waypoint.isPrevious = true);
-		this.waypoints = this.waypoints.concat(waypoints);
-		for (const waypoint of waypoints) {
-			this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
-		}
-	}
-
-	dragRulerClearWaypoints() {
-		this.waypoints = [];
-		this.labels.removeChildren().forEach(c => c.destroy());
-	}
-
-	dragRulerDeleteWaypoint(event={preventDefault: () => {return}}) {
-		if (this.waypoints.filter(w => !w.isPrevious).length > 1) {
-			event.preventDefault();
-			const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens);
-			const rulerOffset = this.rulerOffset;
-			this._removeWaypoint({x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y});
-			game.user.broadcastActivity({ruler: this});
-		}
-		else {
-			const token = this.draggedEntity;
-			this._endMeasurement();
-
-			// Deactivate the drag workflow in mouse
-			token.mouseInteractionManager._deactivateDragEvents();
-			token.mouseInteractionManager.state = token.mouseInteractionManager.states.HOVER;
-
-			// This will cancel the current drag operation
-			// Pass in a fake event that hopefully is enough to allow other modules to function
-			token._onDragLeftCancel(event);
-		}
-	}
-
-	async dragRulerRecalculate(tokenIds) {
-		if (this._state !== Ruler.STATES.MEASURING)
-			return;
-		if (tokenIds && !tokenIds.includes(this.draggedEntity.id))
-			return;
-		const waypoints = this.waypoints.filter(waypoint => !waypoint.isPrevious);
-		this.dragRulerClearWaypoints();
-		if (game.settings.get(settingsKey, "enableMovementHistory"))
-			this.dragRulerAddWaypointHistory(getMovementHistory(this.draggedEntity));
-		for (const waypoint of waypoints) {
-			this.dragRulerAddWaypoint(waypoint, false);
-		}
-		this.measure(this.destination);
-		game.user.broadcastActivity({ruler: this});
-	}
-
-	static dragRulerGetRaysFromWaypoints(waypoints, destination) {
-		if ( destination )
-			waypoints = waypoints.concat([destination]);
-		return waypoints.slice(1).map((wp, i) => {
-			const ray =  new Ray(waypoints[i], wp);
-			ray.isPrevious = Boolean(waypoints[i].isPrevious);
-			return ray;
-		});
-	}
-}

src/util.js

@@ -1,200 +0,0 @@
-import {getPixelsFromGridPosition} from "./foundry_fixes.js"
-
-export function* zip(it1, it2) {
-	for (let i = 0;i < Math.min(it1.length, it2.length);i++) {
-		yield [it1[i], it2[i]]
-	}
-}
-
-export function getSnapPointForToken(x, y, token) {
-	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
-		return new PIXI.Point(x, y);
-	}
-	if (canvas.grid.isHex && game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(token)) {
-		if (token.getFlag("hex-size-support", "borderSize") % 2 === 0) {
-			const snapPoint = CONFIG.hexSizeSupport.findVertexSnapPoint(x, y, token, canvas.grid.grid)
-			return new PIXI.Point(snapPoint.x, snapPoint.y)
-		}
-		else {
-			return new PIXI.Point(...canvas.grid.getCenter(x, y))
-		}
-	}
-	// Tiny tokens can snap to the cells corners
-	if (!canvas.grid.isHex && token.data.width <= 0.5) {
-		const [topLeftX, topLeftY] = canvas.grid.getTopLeft(x, y);
-		const offsetX = x - topLeftX;
-		const offsetY = y - topLeftY;
-		const subGridWidth = Math.floor(canvas.grid.w / 2);
-		const subGridHeight = Math.floor(canvas.grid.h / 2);
-		const subGridPosX = Math.floor(offsetX / subGridWidth);
-		const subGridPosY = Math.floor(offsetY / subGridHeight);
-		return new PIXI.Point(topLeftX + (subGridPosX + 0.5) * subGridWidth, topLeftY + (subGridPosY + 0.5) * subGridHeight);
-	}
-	// Hex tokens, tokens with odd multipliers (1x1, 3x3, ...) and tokens smaller than 1x1 but bigger than 0.5x0.5 snap to the center of the grid cell
-	if (canvas.grid.isHex || Math.round(token.data.width) % 2 === 1 || token.data.width < 1) {
-		return new PIXI.Point(...canvas.grid.getCenter(x, y))
-	}
-	// All remaining tokens (those with even or fractional multipliers on square grids) snap to the intersection points of the grid
-	const [snappedX, snappedY] = canvas.grid.getCenter(x - canvas.grid.w / 2, y - canvas.grid.h / 2)
-	return new PIXI.Point(snappedX + canvas.grid.w / 2, snappedY + canvas.grid.h / 2)
-}
-
-export function getSnapPointForMeasuredTemplate(x, y) {
-	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
-		return new PIXI.Point(x, y);
-	}
-	let subgridWidth, subgridHeight;
-	if (canvas.grid.type === CONST.GRID_TYPES.SQUARE) {
-		subgridWidth = subgridHeight = canvas.dimensions.size / 2;
-	}
-	else {
-		if (canvas.grid.grid.columns) {
-			subgridWidth = canvas.grid.w / 4;
-			subgridHeight = canvas.grid.h / 2;
-		}
-		else {
-			subgridWidth = canvas.grid.w / 2;
-			subgridHeight = canvas.grid.h / 4;
-		}
-	}
-	const snappedX = Math.round(x / subgridWidth) * subgridWidth;
-	const snappedY = Math.round(y / subgridHeight) * subgridHeight;
-	return new PIXI.Point(snappedX, snappedY);
-}
-
-export function getSnapPointForEntity(x, y, entity) {
-	const isToken = entity instanceof Token;
-	if (isToken)
-		return getSnapPointForToken(x, y, entity);
-	else
-		return getSnapPointForMeasuredTemplate(x, y);
-}
-
-export function highlightTokenShape(position, shape, color, alpha) {
-	const layer = canvas.grid.highlightLayers[this.name];
-    if ( !layer )
-		return false;
-	const area = getAreaFromPositionAndShape(position, shape);
-	for (const space of area) {
-		const [x, y] = getPixelsFromGridPosition(space.x, space.y);
-		canvas.grid.grid.highlightGridPosition(layer, {x, y, color, alpha: 0.25 * alpha});
-	}
-}
-
-export function getAreaFromPositionAndShape(position, shape) {
-	return shape.map(space => {
-		let x = position.x + space.x;
-		let y = position.y + space.y;
-		if (canvas.grid.isHex) {
-			let shiftedRow;
-			if (canvas.grid.grid.options.even)
-				shiftedRow = 1
-			else
-				shiftedRow = 0
-			if (canvas.grid.grid.options.columns) {
-				if (space.x % 2 !== 0 && position.x % 2 !== shiftedRow) {
-					y += 1;
-				}
-			}
-			else {
-				if (space.y % 2 !== 0 && position.y % 2 !== shiftedRow) {
-					x += 1;
-				}
-			}
-		}
-		return {x, y}
-	});
-}
-
-export function getTokenShape(token) {
-	if (token.scene.data.gridType === CONST.GRID_TYPES.GRIDLESS) {
-		return [{x: 0, y: 0}]
-	}
-	else if (token.scene.data.gridType === CONST.GRID_TYPES.SQUARE) {
-		const topOffset = -Math.floor(token.data.height / 2)
-		const leftOffset = -Math.floor(token.data.width / 2)
-		const shape = []
-		for (let y = 0;y < token.data.height;y++) {
-			for (let x = 0;x < token.data.width;x++) {
-				shape.push({x: x + leftOffset, y: y + topOffset})
-			}
-		}
-		return shape
-	}
-	else {
-		// Hex grids
-		if (game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(token)) {
-			const borderSize = token.data.flags["hex-size-support"].borderSize;
-			let shape = [{x: 0, y: 0}];
-			if (borderSize >= 2)
-				shape = shape.concat([{x: 0, y: -1}, {x: -1, y: -1}]);
-			if (borderSize >= 3)
-				shape = shape.concat([{x: 0, y: 1}, {x: -1, y: 1}, {x: -1, y: 0}, {x: 1, y: 0}]);
-			if (borderSize >= 4)
-				shape = shape.concat([{x: -2, y: -1}, {x: 1, y: -1}, {x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}])
-
-			if (Boolean(CONFIG.hexSizeSupport.getAltOrientationFlag(token)) !== canvas.grid.grid.options.columns)
-				shape.forEach(space => space.y *= -1);
-			if (canvas.grid.grid.options.columns)
-				shape = shape.map(space => {return {x: space.y, y: space.x}});
-			return shape;
-		}
-		else {
-			return [{x: 0, y: 0}];
-		}
-	}
-}
-
-export function getTokenSize(token) {
-	let w, h;
-	const hexSizeSupportBorderSize = token.data.flags["hex-size-support"]?.borderSize;
-	if (hexSizeSupportBorderSize > 0) {
-		w = h = hexSizeSupportBorderSize
-	}
-	else {
-		w = token.data.width
-		h = token.data.height
-	}
-	return {w, h};
-}
-
-// Tokens that have a size divisible by two (2x2, 4x4, 2x1) have their ruler at the edge of a cell.
-// This function applies an offset to to the waypoints that will move the ruler from the edge to the center of the cell
-export function applyTokenSizeOffset(waypoints, token) {
-	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
-		return waypoints
-	}
-
-	const tokenSize = getTokenSize(token);
-	const waypointOffset = {x: 0, y: 0};
-	if (canvas.grid.isHex) {
-		if (game.modules.get("hex-size-support")?.active) {
-			const isAltOrientation = CONFIG.hexSizeSupport.getAltOrientationFlag(token);
-			if (canvas.grid.grid.options.columns) {
-				if (tokenSize.w % 2 === 0) {
-					waypointOffset.x = canvas.grid.w / 2;
-					if (!isAltOrientation)
-						waypointOffset.x *= -1;
-				}
-			}
-			else {
-				if (tokenSize.h % 2 === 0) {
-					waypointOffset.y = canvas.grid.h / 2;
-					if (isAltOrientation)
-						waypointOffset.y *= -1;
-				}
-			}
-		}
-		// If hex size support isn't active leave the waypoints like they are
-	}
-	else {
-		if (tokenSize.w % 2 === 0) {
-			waypointOffset.x = canvas.grid.w / 2;
-		}
-		if (tokenSize.h % 2 === 0) {
-			waypointOffset.y = canvas.grid.h / 2;
-		}
-	}
-
-	return waypoints.map(w => new PIXI.Point(w.x + waypointOffset.x, w.y + waypointOffset.y))
-}