Merge branch 'develop' into pathfinding

This partially reverts commit db7dd1c1c9.

.gitignore

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

CHANGELOG.md

@@ -1,58 +1,3 @@
-## 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)

build_release.py

@@ -11,7 +11,7 @@ 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"]
+copy_everything_directories = ["js", "lang", "templates", "wasm/snippets"]
 wasm_dir = Path("wasm")
 root_dir = Path(".")
 rust_dir = Path("rust")

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 {getAreaFromPositionAndShape, getTokenShape} from "./util.js";
+import {getTokenShape} from "./util.js";
 
 export const availableSpeedProviders = {}
 export let currentSpeedProvider = undefined
@@ -140,10 +140,6 @@ export function getMovedDistanceFromToken(token) {
 	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,6 +1,6 @@
-import {buildCostFunction} from "./api.js";
+import {getCostFromSpeedProvider} from "./api.js";
 import {settingsKey} from "./settings.js";
-import {highlightTokenShape} from "./util.js";
+import {getAreaFromPositionAndShape, highlightTokenShape} from "./util.js";
 
 export function getHexSizeSupportTokenGridCenter(token) {
 	const tokenCenterOffset = CONFIG.hexSizeSupport.getCenterOffset(token)
@@ -27,7 +27,7 @@ export function measureDistances(segments, entity, shape, options={}) {
 		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 = buildCostFunction(entity, shape);
+		opts.costFunction = (x, y, costOptions={}) => {	return getCostFromSpeedProvider(entity, getAreaFromPositionAndShape({x, y}, shape), costOptions); }
 		if (previousSegments.length > 0)
 			opts.terrainRulerInitialState = previousSegments[previousSegments.length - 1].ray.dragRulerFinalState;
 		return distances.concat(terrainRuler.measureDistances(newSegments, opts));

js/data_structures.js

@@ -1,138 +0,0 @@
-/**
- * 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_imports.js

@@ -28,9 +28,6 @@ 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) {
@@ -175,9 +172,7 @@ export function measure(destination, options={}) {
 		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) {
+		if (path) {
 			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
@@ -346,8 +341,7 @@ export function highlightMeasurementNative(ray, previousSegments, tokenShape=[{x
 		if ( x0 === x1 && y0 === y1 ) continue;
 
 		// Highlight the grid position
-		let [xgtl, ygtl] = canvas.grid.grid.getPixelsFromGridPosition(x1, y1);
-		let [xg, yg] = canvas.grid.grid.getCenter(xgtl, ygtl);
+		let [xg, yg] = canvas.grid.grid.getPixelsFromGridPosition(x1, y1);
 		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);
@@ -361,8 +355,7 @@ export function highlightMeasurementNative(ray, previousSegments, tokenShape=[{x
 			let th = tMax[i - 1] - (0.5 / nMax);
 			let {x, y} = ray.project(th);
 			let [x1h, y1h] = canvas.grid.grid.getGridPositionFromPixels(x, y);
-			let [xghtl, yghtl] = canvas.grid.grid.getPixelsFromGridPosition(x1h, y1h);
-			let [xgh, ygh] = canvas.grid.grid.getCenter(xghtl, yghtl);
+			let [xgh, ygh] = canvas.grid.grid.getPixelsFromGridPosition(x1h, y1h);
 			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);

js/hex_support.js

@@ -1,93 +0,0 @@
-/**
- * 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

@@ -113,16 +113,6 @@ function handleDisableSnap(event) {
 
 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) {

js/main.js

@@ -7,7 +7,7 @@ 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} from "./pathfinding.js";
+import {wipePathfindingCache} from "./pathfinding.js";
 import {extendRuler} from "./ruler.js";
 import {registerSettings, RightClickAction, settingsKey} from "./settings.js"
 import {recalculate} from "./socket.js";
@@ -21,28 +21,10 @@ export let debugGraphics = undefined;
 
 initGridlessPathfinding().then(() => {
 	Hooks.on("canvasInit", wipePathfindingCache);
-	Hooks.on("canvasReady", () => {
-		wipePathfindingCache();
-		initializePathfinding();
-	});
+	Hooks.on("canvasReady", wipePathfindingCache);
 	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", () => {

js/pathfinding.js

@@ -1,249 +1,20 @@
-import {getCenterFromGridPositionObj, getGridPositionFromPixelsObj, getPixelsFromGridPositionObj} from "./foundry_fixes.js";
-import {moveWithoutAnimation, togglePathfinding} from "./keybindings.js";
+import {getGridPositionFromPixelsObj, getPixelsFromGridPositionObj} from "./foundry_fixes.js";
+import {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 {getSnapPointForTokenObj, 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();
+import * as GridlessPathfinding from "../wasm/gridless_pathfinding.js"
 
+let cachedNodes = undefined;
 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;
 }
 
@@ -252,104 +23,74 @@ export function findPath(from, to, token, previousWaypoints) {
 		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");
-			pathfinder = GridlessPathfinding.initialize(canvas.walls.placeables, tokenSize * radiusMultiplier, token.data.elevation, Boolean(game.modules.get("wall-height")?.active));
+			pathfinder = GridlessPathfinding.initialize(canvas.walls.placeables, tokenSize);
 			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();
-				}
-			}
+		const lastNode = calculatePath(from, to, token, previousWaypoints);
+		if (!lastNode)
+			return null;
+		paintGriddedPathfindingDebug(lastNode, token);
+		const path = [];
+		let currentNode = lastNode;
+		while (currentNode) {
+			// TODO Check if the distance doesn't change
+			if (path.length >= 2 && !stepCollidesWithWall(currentNode.node, path[path.length - 2], token))
+				// Replace last waypoint if the current waypoint leads to a valid path
+				path[path.length - 1] = {x: currentNode.node.x, y: currentNode.node.y};
+			else
 				path.push({x: currentNode.node.x, y: currentNode.node.y});
-			currentNode = currentNode.next;
+			currentNode = currentNode.previous;
 		}
 		return path;
 	}
 }
 
-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;
+export function wipePathfindingCache() {
+	cachedNodes = undefined;
+	for (const pathfinder of gridlessPathfinders.values()) {
+		GridlessPathfinding.free(pathfinder);
+	}
+	gridlessPathfinders.clear();
+	if (debugGraphics)
+		debugGraphics.removeChildren().forEach(c => c.destroy());
 }
 
-	return tokenData;
+function getNode(pos, token, initialize=true) {
+	pos = {layer: 0, ...pos}; // Copy pos and set pos.layer to the default value if it's unset
+	if (!cachedNodes)
+		cachedNodes = new Array(2);
+	if (!cachedNodes[pos.layer])
+		cachedNodes[pos.layer] = new Array(Math.ceil(canvas.dimensions.height / canvas.grid.h));
+	if (!cachedNodes[pos.layer][pos.y])
+		cachedNodes[pos.layer][pos.y] = new Array(Math.ceil(canvas.dimensions.width / canvas.grid.w));
+	if (!cachedNodes[pos.layer][pos.y][pos.x]) {
+		cachedNodes[pos.layer][pos.y][pos.x] = pos;
 	}
 
-function getNode(pos, cacheLayer, initialize = true) {
-	const node = cacheLayer.nodes[pos.y][pos.x];
+	const node = cachedNodes[pos.layer][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) {
+			if (neighborPos.x < 0 || neighborPos.y < 0)
 				continue;
-			}
-
 			// TODO Work with pixels instead of grid locations
-			if (!stepCollidesWithWall(pos, neighborPos, cacheLayer.tokenData)) {
+			if (!stepCollidesWithWall(pos, neighborPos, token)) {
 				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;
+				let targetLayer = pos.layer;
+				if (use5105 && isDiagonal)
+					targetLayer = 1 - targetLayer;
+				const neighbor = getNode({...neighborPos, layer: targetLayer}, token, false);
+
+				// TODO We currently assume a cost of one or two for all transitions. Change this for difficult terrain support
+				let edgeCost = 1;
+				if (isDiagonal) {
+					// We charge 0.0001 more for edges to avoid unnecessary diagonal steps
+					edgeCost = pos.layer === 1 && targetLayer === 0 ? 2 : 1.0001;
 				}
-					// 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});
 			}
 		}
@@ -357,67 +98,44 @@ function getNode(pos, cacheLayer, initialize = true) {
 	return node;
 }
 
-function calculatePath(from, to, cacheLayer, previousWaypoints) {
-	use5105 = game.system.id === "pf2e" || canvas.grid.diagonalRule === "5105";
-	let startCost = 0;
+function calculatePath(from, to, token, previousWaypoints) {
+	if (game.system.id === "pf2e")
+		use5105 = true;
+	if (canvas.grid.diagonalRule === "5105")
+		use5105 = true;
+	let startLayer = 0;
 	if (use5105 && canvas.grid.type === CONST.GRID_TYPES.SQUARE) {
 		previousWaypoints = previousWaypoints.map(w => getGridPositionFromPixelsObj(w));
-		startCost = (calcNoDiagonals(previousWaypoints) % 2) * 0.5;
+		startLayer = calcNoDiagonals(previousWaypoints) % 2;
 	}
-
-	const nextNodes = new PriorityQueueSet((node1, node2) => node1.node === node2.node, node => node.estimated);
+	const nextNodes = [{node: getNode({...to, layer: startLayer}, token), cost: 0, estimated: estimateCost(to, from), previous: null}];
 	const previousNodes = new Set();
-
-	nextNodes.pushWithPriority(
-		{
-			node: getNode(from, cacheLayer),
-			cost: startCost,
-			estimated: startCost + estimateCost(from, to),
-			previous: null
-		}
-	);
-
-	while (nextNodes.hasNext()) {
+	while (nextNodes.length > 0) {
+		// Sort by estimated cost, high to low
+		// TODO Re-sorting every iteration is expensive. Think of something better
+		nextNodes.sort((a, b) => b.estimated - a.estimated);
 		// Get node with cheapest estimate
 		const currentNode = nextNodes.pop();
-		if (currentNode.node.x === to.x && currentNode.node.y === to.y) {
-			return buildPathNodes(currentNode);
-		}
+		if (currentNode.node.x === from.x && currentNode.node.y === from.y)
+			return currentNode;
 		previousNodes.add(currentNode.node);
 		for (const edge of currentNode.node.edges) {
-			const neighborNode = getNode(edge.target, cacheLayer);
-			if (previousNodes.has(neighborNode)) {
+			const neighborNode = getNode(edge.target, token);
+			if (previousNodes.has(neighborNode))
 				continue;
+			const neighbor = {node: neighborNode, cost: currentNode.cost + edge.cost, estimated: currentNode.cost + edge.cost + estimateCost(neighborNode, from), previous: currentNode};
+			const neighborIndex = nextNodes.findIndex(node => node.node === neighbor.node);
+			if (neighborIndex >= 0) {
+				// If the neighbor is cheaper to reach via the current route than through previously discovered routes, replace it
+				if (nextNodes[neighborIndex].cost > neighbor.cost) {
+					nextNodes[neighborIndex] = neighbor;
 				}
-
-			const neighbor = {
-				node: neighborNode,
-				cost: currentNode.cost + edge.cost,
-				estimated: currentNode.cost + edge.cost + estimateCost(neighborNode, to),
-				previous: currentNode
-			};
-			nextNodes.pushWithPriority(neighbor);
+			}
+			else {
+				nextNodes.push(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) {
@@ -428,66 +146,30 @@ function calcNoDiagonals(waypoints) {
 	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);
+	return Math.max(Math.abs(pos.x - target.x), Math.abs(pos.y - target.y));
 }
 
-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 {
+function stepCollidesWithWall(from, to, token) {
+	const stepStart = getSnapPointForTokenObj(getPixelsFromGridPositionObj(from), token);
+	const stepEnd = getSnapPointForTokenObj(getPixelsFromGridPositionObj(to), token);
 	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) {
+function paintGriddedPathfindingDebug(lastNode, token) {
 	if (!CONFIG.debug.dragRuler)
 		return;
 
 	debugGraphics.removeChildren().forEach(c => c.destroy());
-	let currentNode = firstNode;
+	let currentNode = lastNode;
 	while (currentNode) {
-		let text = new PIXI.Text(currentNode.cost.toFixed(1));
-		let pixels = getSnapPointForTokenDataObj(getPixelsFromGridPositionObj(currentNode.node), tokenData);
+		let text = new PIXI.Text(currentNode.cost.toFixed(0));
+		let pixels = getSnapPointForTokenObj(getPixelsFromGridPositionObj(currentNode.node), token);
 		text.anchor.set(0.5, 1.0);
 		text.x = pixels.x;
 		text.y = pixels.y;
 		debugGraphics.addChild(text);
-		currentNode = currentNode.next;
+		currentNode = currentNode.previous;
 	}
 }
 

js/ruler.js

@@ -54,9 +54,6 @@ export function extendRuler() {
 				else
 					this.draggedEntity = canvas.templates.get(data.draggedEntity);
 			}
-			else {
-				this.draggedEntity = undefined;
-			}
 
 			super.update(data);
 		}

js/settings.js

@@ -1,6 +1,5 @@
 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";
@@ -11,10 +10,6 @@ export const RightClickAction = Object.freeze({
 	ABORT_DRAG:2,
 });
 
-function delayedReload() {
-	window.setTimeout(() => location.reload(), 500);
-}
-
 export function registerSettings() {
 	game.settings.register(settingsKey, "dataVersion", {
 		scope: "world",
@@ -95,24 +90,16 @@ export function registerSettings() {
 		config: true,
 		type: Boolean,
 		default: false,
-		onChange: delayedReload,
+		onChange: () => location.reload(),
 	});
 
 	game.settings.register(settingsKey, "autoPathfinding", {
 		name: "drag-ruler.settings.autoPathfinding.name",
 		hint: "drag-ruler.settings.autoPathfinding.hint",
-		scope: "client",
+		scpoe: "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,
+		defualt: false,
 	});
 
 	game.settings.register(settingsKey, "lastTerrainRulerHintTime", {

js/socket.js

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

js/systems.js

@@ -4,15 +4,13 @@ export function getDefaultSpeedAttribute() {
 			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.derived.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":
@@ -30,7 +28,6 @@ export function getDefaultDashMultiplier() {
 		case "swade":
 			return 0
 		case "dcc":
-		case "dnd4e":
 		case "dnd5e":
 		case "lancer":
 		case "pf1":
@@ -38,9 +35,9 @@ export function getDefaultDashMultiplier() {
 		case "sfrpg":
 		case "shadowrun5e":
 		case "ds4":
-			return 2;
+			return 2
 		case "CoC7":
 			return 5;
 	}
-	return 0;
+	return 0
 }

js/util.js

@@ -1,5 +1,4 @@
 import {getPixelsFromGridPosition} from "./foundry_fixes.js"
-import {findVertexSnapPoint} from "./hex_support.js";
 import { disableSnap } from "./keybindings.js";
 
 export function* zip(it1, it2) {
@@ -26,38 +25,14 @@ 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);
+		if (game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(token)) {
+			if (token.document.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 {
@@ -71,38 +46,38 @@ function getSnapPointForTokenData(x, y, tokenData) {
 
 	const [topLeftX, topLeftY] = canvas.grid.getTopLeft(x, y);
 	let cellX, cellY;
-	if (tokenData.width % 2 === 0)
+	if (token.data.width % 2 === 0)
 		cellX = x - canvas.grid.h / 2;
 	else
 		cellX = x;
-	if (tokenData.height % 2 === 0)
+	if (token.data.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) {
+	if (token.data.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) {
+	else if (Math.round(token.data.width) % 2 === 1 || token.data.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) {
+	if (token.data.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) {
+	else if (Math.round(token.data.height) % 2 === 1 || token.data.height < 1) {
 		snapY = centerY;
 	}
 	else {
@@ -119,7 +94,23 @@ 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);
+	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) {
@@ -167,19 +158,15 @@ export function getAreaFromPositionAndShape(position, shape) {
 }
 
 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) {
+	if (token.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)
+	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 < tokenData.height;y++) {
-			for (let x = 0;x < tokenData.width;x++) {
+		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})
 			}
 		}
@@ -187,8 +174,8 @@ export function getTokenShapeForTokenData(tokenData, scene=canvas.scene) {
 	}
 	else {
 		// Hex grids
-		if (game.modules.get("hex-size-support")?.active && tokenData.hexSizeSupport.altSnappingFlag) {
-			const borderSize = tokenData.hexSizeSupport.borderSize;
+		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}]);
@@ -197,7 +184,7 @@ export function getTokenShapeForTokenData(tokenData, scene=canvas.scene) {
 			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)
+			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}});
@@ -292,7 +279,3 @@ export function early_isGM() {
 	const gmLevel = CONST.USER_ROLES.ASSISTANT;
 	return level >= gmLevel;
 }
-
-export function isModuleActive(moduleName) {
-	return game.modules.get(moduleName)?.active
-}

module.json

@@ -2,7 +2,7 @@
 	"name": "drag-ruler",
 	"title": "Drag Ruler",
 	"description": "When dragging a token displays a ruler showing how far you've moved that token.",
-	"version": "1.12.8",
+	"version": "1.11.5",
 	"minimumCoreVersion" : "9.245",
 	"compatibleCoreVersion" : "9",
 	"authors": [
@@ -65,7 +65,7 @@
 	],
 	"socket": true,
 	"url": "https://github.com/manuelVo/foundryvtt-drag-ruler",
-	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/releases/download/v1.12.8/drag-ruler-1.12.8.zip",
+	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/archive/v1.11.5.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/Cargo.lock

@@ -2,15 +2,6 @@
 # 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"
@@ -33,53 +24,13 @@ dependencies = [
  "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"
+version = "0.1.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
  "rustc-hash",
- "sha1",
  "wasm-bindgen",
 ]
 
@@ -98,12 +49,6 @@ 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"
@@ -137,17 +82,6 @@ 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"
@@ -159,24 +93,12 @@ dependencies = [
  "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"

rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gridless-pathfinding"
-version = "1.12.8"
+version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -16,5 +16,4 @@ lto = true
 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/src/js_api.rs

@@ -1,5 +1,4 @@
 use js_sys::Array;
-use sha1::{Sha1, Digest};
 use wasm_bindgen::prelude::*;
 
 use crate::{
@@ -24,8 +23,6 @@ extern "C" {
 extern "C" {
 	pub type JsWall;
 	pub type JsWallData;
-	pub type JsWallFlags;
-	pub type JsWallHeight;
 
 	#[wasm_bindgen(method, getter)]
 	fn data(this: &JsWall) -> JsWallData;
@@ -41,18 +38,6 @@ extern "C" {
 
 	#[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]
@@ -135,38 +120,6 @@ impl TryFrom<usize> for WallSenseType {
 	}
 }
 
-#[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,
@@ -174,7 +127,6 @@ pub struct Wall {
 	pub door_type: DoorType,
 	pub door_state: DoorState,
 	pub move_type: WallSenseType,
-	pub height: WallHeight,
 }
 
 impl Wall {
@@ -184,7 +136,6 @@ impl Wall {
 		door_type: DoorType,
 		door_state: DoorState,
 		move_type: WallSenseType,
-		height: WallHeight,
 	) -> Self {
 		Self {
 			p1,
@@ -192,7 +143,6 @@ impl Wall {
 			door_type,
 			door_state,
 			move_type,
-			height,
 		}
 	}
 
@@ -206,36 +156,29 @@ impl Wall {
 }
 
 impl Wall {
-	fn from_js(wall: &JsWall, enable_height: bool) -> Self {
+	fn from_js(wall: &JsWall) -> 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>, token_size: f64, token_elevation: f64, enable_height: bool) -> Pathfinder {
+pub fn initialize(js_walls: Vec<JsValue>, token_size: f64) -> 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));
+		walls.push(Wall::from_js(&wall));
 	}
-	Pathfinder::initialize(walls, token_size, token_elevation)
+	Pathfinder::initialize(walls, token_size)
 }
 
 #[allow(dead_code)]
@@ -263,14 +206,6 @@ pub fn debug_get_pathfinding_points(pathfinder: &Pathfinder) -> Array {
 		.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;
 }

rust/src/pathfinder.rs

@@ -148,7 +148,7 @@ pub struct Pathfinder {
 }
 
 impl Pathfinder {
-	pub fn initialize<I>(walls: I, token_size: f64, token_elevation: f64) -> Self
+	pub fn initialize<I>(walls: I, token_size: f64) -> Self
 	where
 		I: IntoIterator<Item = Wall>,
 	{
@@ -162,9 +162,6 @@ impl Pathfinder {
 			if wall.is_door() && wall.is_open() {
 				continue;
 			}
-			if !wall.height.contains(token_elevation) {
-				continue;
-			}
 			let x_diff = wall.p2.x - wall.p1.x;
 			let y_diff = wall.p2.y - wall.p1.y;
 			let p1_angle = y_diff.atan2(x_diff).rem_euclid(2.0 * PI);
@@ -191,13 +188,18 @@ impl Pathfinder {
 				if angle_diff <= PI {
 					continue;
 				}
+				{
 					let angle_between = angle_diff / 2.0 + angle1;
-				nodes.push(calc_pathfinding_node(
+					let pathfinding_node = calc_pathfinding_node(
 						point,
 						angle_between,
 						distance_from_walls,
 						&mut line_segments,
-				));
+					);
+					if angle_diff > 1.5 * PI {
+						nodes.push(pathfinding_node);
+					}
+				}
 				nodes.push(calc_pathfinding_node(
 					point,
 					angle1 + 0.5 * PI,
@@ -217,6 +219,7 @@ impl Pathfinder {
 			if angle_diff <= PI {
 				continue;
 			}
+			if angle_diff > 1.5 * PI {
 				let angle_between = angle_diff / 2.0 + angle1;
 				nodes.push(calc_pathfinding_node(
 					point,
@@ -224,6 +227,7 @@ impl Pathfinder {
 					distance_from_walls,
 					&mut line_segments,
 				));
+			}
 			nodes.push(calc_pathfinding_node(
 				point,
 				angle1 + 0.5 * PI,