Release v1.9.0

The goal of this is to reduce color flickering noise due to floating number errors

CHANGELOG.md

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

lang/de.json

@@ -81,6 +81,10 @@
 			"swapSpacebarRightClick": {
 				"name": "Leertaste und Rechtsklick tauschen",
 				"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."
+			},
+			"useGridlessraster": {
+				"name": "Geschwindigkeitsraster aktivieren",
+				"hint": "Lässt Spielfiguren auf gitterlosen Szenen an deren Geschwindigkeitsgrenzen einrasten. Dies kann vorübergehend deaktiviert werden, indem während des ziehens die Umschalttaste gedrückt wird."
 			}
 		}
 	}

lang/en.json

@@ -81,6 +81,10 @@
 			"swapSpacebarRightClick": {
 				"name": "Swap spacebar and right click",
 				"hint": "Swaps the functions of spacebar and right click during dragging. If enabled right click will place waypoints and spacebar will delete them"
+			},
+			"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."
 			}
 		}
 	}

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.8.2",
+	"version": "1.9.0",
 	"minimumCoreVersion" : "0.8.5",
 	"compatibleCoreVersion" : "0.8.9",
 	"authors": [
@@ -59,7 +59,7 @@
 	],
 	"socket": true,
 	"url": "https://github.com/manuelVo/foundryvtt-drag-ruler",
-	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/archive/v1.8.2.zip",
+	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/archive/v1.9.0.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",

src/api.js

@@ -131,10 +131,11 @@ export function getColorForDistanceAndToken(distance, token, ranges=null) {
 }
 
 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);
 }

src/compatibility.js

@@ -62,9 +62,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"),

src/foundry_imports.js

@@ -168,7 +168,7 @@ export function measure(destination, options={}) {
 		options.ignoreGrid = false;
 	}
 
-	options.enableTerrainRuler = isToken && game.modules.get("terrain-ruler")?.active && (!game.modules.get("TerrainLayer")?.active || canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS);
+	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

src/main.js

@@ -1,7 +1,7 @@
 "use strict"
 
-import {currentSpeedProvider, getColorForDistanceAndToken, getMovedDistanceFromToken, initApi, registerModule, registerSystem} from "./api.js";
-import {checkDependencies, getHexSizeSupportTokenGridCenter} from "./compatibility.js";
+import {currentSpeedProvider, getColorForDistanceAndToken, getMovedDistanceFromToken, getRangesFromSpeedProvider, initApi, registerModule, registerSystem} from "./api.js";
+import {checkDependencies, getHexSizeSupportTokenGridCenter, highlightMeasurementTerrainRuler} from "./compatibility.js";
 import {moveEntities, onMouseMove} from "./foundry_imports.js"
 import {performMigrations} from "./migration.js"
 import {DragRulerRuler} from "./ruler.js";
@@ -66,6 +66,8 @@ function hookDragHandlers(entityType) {
 
 	const originalDragLeftMoveHandler = entityType.prototype._onDragLeftMove
 	entityType.prototype._onDragLeftMove = function (event) {
+		if (entityType === Token)
+			applyGridlessSnapping.call(this, event);
 		originalDragLeftMoveHandler.call(this, event)
 		onEntityLeftDragMove.call(this, event)
 	}
@@ -149,7 +151,8 @@ function onKeyShift(up) {
 
 function onKeySpace(up) {
 	const ruler = canvas.controls.ruler;
-	if (!ruler.draggedEntity)
+	// Ruler can end up being undefined here if no canvas is active
+	if (!ruler?.draggedEntity)
 		return false;
 
 	if (ruler._state !== Ruler.STATES.INACTIVE)
@@ -265,3 +268,71 @@ function onEntityDragLeftCancel(event) {
 	}
 	return true
 }
+
+function applyGridlessSnapping(event) {
+	const ruler = canvas.controls.ruler;
+	if (!game.settings.get(settingsKey, "useGridlessRaster"))
+		return;
+	if (!ruler.isDragRuler)
+		return;
+	if (game.keyboard.isDown("Shift"))
+		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;
+			}
+		}
+	}
+}

src/movement_tracking.js

@@ -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;
 			}

src/ruler.js

@@ -166,6 +166,7 @@ export class DragRulerRuler extends Ruler {
 			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);

src/settings.js

@@ -29,6 +29,15 @@ export function registerSettings() {
 		default: false,
 	})
 
+	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",
 		hint: "drag-ruler.settings.alwaysShowSpeedForPCs.hint",

src/speed_provider.js

@@ -63,9 +63,9 @@ export class SpeedProvider {
 	 * (1 is regular cost, 2 costs double, 3 costs triple, ...)
 	 *
 	 * Parameters:
-	 * - options: An object used to configure TerrainLayer's cost calculation. Ex: If options.ignoreGrid is set to true, then Euclidean measurement can be forced on a gridded map.
+	 * - 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 TerrainLayer and TerrainRuler modules are enabled.
+	 * 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)
 	 */

src/util.js

@@ -10,7 +10,8 @@ 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 (canvas.grid.isHex) {
+		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)
@@ -19,24 +20,51 @@ export function getSnapPointForToken(x, y, token) {
 				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);
+		else {
+			return new PIXI.Point(...canvas.grid.getCenter(x, y));
 		}
-	// 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))
+	}
+
+	const [topLeftX, topLeftY] = canvas.grid.getTopLeft(x, y);
+	let cellX, cellY;
+	if (token.data.width % 2 === 0)
+		cellX = x - canvas.grid.h / 2;
+	else
+		cellX = x;
+	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 (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(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
-	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)
+	else {
+		snapX = centerX + canvas.grid.w / 2;
+	}
+	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(token.data.height) % 2 === 1 || token.data.height < 1) {
+		snapY = centerY;
+	}
+	else {
+		snapY = centerY + canvas.grid.h / 2;
+	}
+	return new PIXI.Point(snapX, snapY);
 }
 
 export function getSnapPointForMeasuredTemplate(x, y) {