Release v1.7.5

https://gitlab.com/foundrynet/foundryvtt/-/issues/5094

CHANGELOG.md

@@ -1,3 +1,139 @@
+## 1.7.5
+### Bugfixes
+- Decimal speeds (as often used in metric game systems) are no longer being rounded down (thanks to DarKDinDoN for diagnosing this bug)
+
+
+## 1.7.4
+### Bugfixes
+- Fixed a bug where the ruler would wrongly snap to the grid center for other players when dragging a measurement template
+
+### Compatibility
+- Drag Ruler is now compatiblie with the "Monk's Active Tile Triggers" module
+- Drag Ruler's Generic Speed Provider is now aware of good default values for the D&D 3.5 game system
+- Drag Ruler is now compatible with Foundry 0.8.7
+
+## 1.7.3
+### Compatibility
+- Drag Ruler is now compatible with Foundry 0.8.5
+
+
+## 1.7.2
+### Bugfixes
+- Fixed a bug that prevented waypoints for measurement templates from snapping to any other point than a grid cell corner (or grid cell center on hex)
+- Fixed a bug that could cause the ruler to not end up at the token's center (especially if the token is being moved very quickly and then stopped abruptly)
+
+
+## 1.7.1
+### Bugfixes
+- Fixed a bug that prevented players from moving their tokens ([#74](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/74))
+
+
+## 1.7.0
+**BREAKING** This update is incompatible with previous Terrain Ruler versions. If you're using Terrain Ruler, make sure you update Terrain Ruler to at least version 1.3.0.
+
+### New features
+- A ruler will now be shown when dragging measurement templates over the map ([#13](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/13))
+- Drag Ruler can now measure difficult terrain on gridless maps (if the Terrain Ruler module is installed and enabled)
+- Improved the positioning of the labels around the ruler. The labels should now never overlap with the waypoint.
+
+### Bugfixes
+- Fixed a bug that sometimes measured diagonals incorrectly with the 5/10/5 grid rule
+- Fixed a bug that would cause the ruler to re-measure when the shift key is being pressed or released while a token is moving
+
+### Compatibility
+- Drag Ruler's Generic Speed Provider is now aware of good default values for the Starfinder game system
+
+### Translation
+- Corrected typos in the german translation (thanks to CarnVanBeck!)
+
+### API
+- The old API that Drag Ruler offered prior to version 1.3.0 is now deprecated. Speed Providers that still use this API will continue to work for now, but will generate a warning in the console about the deprecation. All modules and game systems offered on the FoundryVTT website have already updated to the new API. If you see the deprecation warning, please consider updating to the current version of the respective system/module you're using.
+
+
+## 1.6.5
+### Bugfixes
+- Drag Ruler no longer gets stuck if the user presses ESC during drag ([#70](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/70))
+
+
+## 1.6.4
+### Bugfixes
+- Fixed a bug where a bug in a Speed Provider could lead to the ruler getting stuck, leaving the token immovable
+
+
+## 1.6.3
+### Bugfixes
+- If the movement history for a token is being updated (for example by a history reset by the gm) while a player is currently measuring a distance for that token the history change is now being reflected in the active measurement.
+
+### Compatibility
+- Drag Ruler's Generic SpeedProvider is now aware of good default values for the Savage Worlds Adventure Edition game system
+
+
+## 1.6.2
+### Bugfixes
+- The reset movement history button now resets the movement history for all players, not just for the GM
+
+
+## 1.6.1
+### API
+- Added `onMovementHistoryUpdate` callback to Speed Providers, that allows them to perform game systems specific improvements to the movement history
+- Added `dragRuler.resetMovementHistory` that clears the stored movement history for a token.
+
+
+## 1.6.0
+### Performance
+- Greatly increased the performance when playing on huge maps and when moving many tokens at once.
+- Huge performance improvements for speed providers. (Technical details: `getRanges` is now being called way less frequently)
+
+### New features
+- GMs now have an option to reset the movement history for individual tokens in the right click menu of the combat tracker
+- When releasing a dragged token while pressing Alt the token will be moved to the target location without an animation ([#3](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/3))
+
+### Bugfixes
+- When starting to drag a new token while the previous one is still moving the ruler won't dissappear anymore when the previous token arrives at it's destination.
+
+
+## 1.5.4
+### Bugfixes
+- Fixed a bug that prevented tokens from being moved when their movement history collides with a wall. ([#61](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/61))
+
+
+## 1.5.3
+### Compatiblilty
+- Drag Ruler's Generic Speed Provider is now able to work with game systems that put non-number characters behind the tokens movement speed (like `30ft.`). One example for such a game system is Dungeon Crawl Classics. ([#60](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/60))
+- The Generic Speed Provider now has good default settings for the Dungeon Crawl Classics (dcc) game system.
+
+
+## 1.5.2
+### Bugfixes
+- Drag Ruler no longer prevents tokens that don't have an actor from being moved. ([#58](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/58))
+- Grid highlighting now also works for tokens that don't have an actor.
+
+
+## 1.5.1
+### Bugfixes
+- The hint that tells users how to enable difficult terrain measurement in Drag Ruler is no longer shown if no terrain layer module is installed.
+
+
+## 1.5.0
+### New features
+- In combat Drag Ruler will now remember the path that was taken by a token during the turn. Picking the token up during the same turn will continue the previous measurement, taking steps that are already taken into account.
+
+### Module compatibility
+- Drag Ruler is now fully compatible with the `Enhanced Terrain Layer` module. ([#50](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/50))
+
+
+## 1.4.6
+### Bugfixes
+- Fixed a bug where a token would move to the incorrect location if it is was dragged and released very quickly ([#51](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/51)) - thanks to Silver Raven for helping me track down this bug!
+
+
+## 1.4.5
+### Bugfixes
+- Tiny tokens (0.5x0.5 or smaller) now snap to the coners of a square like they do in vanilla foundry ([#49](https://github.com/manuelVo/foundryvtt-drag-ruler/issues/49))
+- Fixed a bug that could cause a meausred distance to be wrong when disabling token snapping using the shift key
+- Fixed a bug where the highlighted path could have gaps when disabling token snapping using the shift key
+
+
 ## 1.4.4
 ### Bugfixes
 - Fix snapping for tokens that are smaller than 1x1

README.md

@@ -1,32 +1,35 @@
 [![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 to infrom you how far you've dragged the token 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. 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 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.
+
+![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)
+![Drag Ruler while dragging a measurement template](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/709774b25f7dd818a90591165f74b3e6dbc788cc/media/measurement_template.webp)
 
 
-## Path color
-![Drag Ruler demonstration](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/5177746fbb4edb28b6ba09137247d142af575c47/media/drag_ruler.webp)
+## Supports Tokens of all sizes
+Terrain ruler has excellent support for tokens of all sizes. The Ruler will always originate from the token's center and will always highlight all the squares that tokens move over. If the [Hex Token Size Support](https://foundryvtt.com/packages/hex-size-support) is installed this is also true for large tokens on hex scenes.
 
-The token has a speed of 30ft. All squares on the path within that range are colored in the players color. If the token is running it can cover double that range (this can be changed in the settings). All Squares on the path that can only be reached while running are colored in yellow. Squares on the path that the token cannot possibly reached at regular speeds are colored red. This coloring behavior can be tweaked in the settings and can be overridden by modules and game systems to provide more granular, game system specific control. For more information on how to do this see the [API](#api) section of this document.
+![Drag Ruler being used with a large token on a square grid](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/709774b25f7dd818a90591165f74b3e6dbc788cc/media/large_token_square.webp)
+![Drag Ruler being used with a large token on a hex grid](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/709774b25f7dd818a90591165f74b3e6dbc788cc/media/large_token_hex.webp)
 
 
-## Waypoints
-You can add waypoints to the path by pressing spacebar while you drag the token. To remove a placed waypoint press the right mouse button.
+## Difficult Terrain support
+**To use support for difficult terrain you must install the [Terrain Ruler](https://foundryvtt.com/packages/terrain-ruler) module**
 
-![Demonstration of Waypoints](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/5177746fbb4edb28b6ba09137247d142af575c47/media/waypoints.webp)
+With the Terrain Ruler module installed, Drag Ruler is able to take difficult terrain that was placed down using the [Enhanced Terrain Layer](https://foundryvtt.com/packages/enhanced-terrain-layer) or [TerrainLayer](https://foundryvtt.com/packages/TerrainLayer) module into account.
 
-## Difficult Terrain
-**To use support for difficult terrain you must install the [Terrain Ruler module](https://foundryvtt.com/packages/terrain-ruler)**
-
-With the Terrain Ruler module installed, Drag Ruler is able to take difficult terrain that was placed with the [TerrainLayer module](https://foundryvtt.com/packages/TerrainLayer/) into account when measuring distances.
-
-![Demonstration of Difficult Terrain support](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/bb8ac5d1acb9d6374d06f7e9c8e2c2dd61192d56/media/terrain_layer.webp)
+![Drag Ruler being used to measure distances over difficult terrain on square grid](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/709774b25f7dd818a90591165f74b3e6dbc788cc/media/difficult_terrain_square.webp)
+![Drag Ruler being used to measure distances over difficult terrain on gridless scenes](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/709774b25f7dd818a90591165f74b3e6dbc788cc/media/difficult_terrain_gridless.webp)
 
 
-## Why would I want to use this instead of ShowDragDistance?
-ShowDragDistance isn't maintained anymore. This means that it is at risk to stop working with every foundry update. In fact this process has already begun. As of Foundry Version 0.7.9 ShowDragDistance doesn't work anymore on gridless maps. Drag Ruler on the other hand is fully compatible with the current Foundry release and I'll continue updating it for future foundry releases for the forseeable future.
+## Movement history (optional)
+*This feature can be disabled in the settings if you don't like it*
 
-In addition Drag Ruler provides more flexibility for game systems and modules via it's api to provide an experience that fits the rules of the game system that you are playing best.
+During combat, Drag Ruler will remember the path a token has taken during it's turn. When the token is being picked up again, Drag Ruler will continue measuring where it has left off. The path of the previous movement will be dipslayed in a faded color.
+
+![Demonstration of the Movement History](https://raw.githubusercontent.com/manuelVo/foundryvtt-drag-ruler/709774b25f7dd818a90591165f74b3e6dbc788cc/media/movement_history.webp)
 
 
 ## Game systems with Drag Ruler integration
@@ -34,9 +37,14 @@ Drag Ruler will work with all Foundry VTT game systems. However some game system
 
 The game systems that offer Drag Ruler integration are:
 - Cypher System (starting with version 1.13.0)
+- Ironclaw Second Edition (starting with version 0.2.2)
 - Pathfinder 1 (starting with version 0.77.3)
 - Pathfinder 2e (via the module [PF2E Drag Ruler Integration](https://foundryvtt.com/packages/pf2e-dragruler/))
+- Tagmar RPG (starting with version 1.1.4)
 - 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)
+- WWII:OWB (starting with version 1.0.4)
 
 
 ## Translations

lang/de.json

@@ -1,5 +1,18 @@
 {
 	"drag-ruler": {
+		"dependencies": {
+			"ok": "OK",
+			"terrain-ruler": {
+				"title": "Wie man schwieriges Gelände mit Drag Ruler misst",
+				"text": "Du hast das {moduleName} Modul installiert. Drag Ruler kann schwieriges Gelände, das mit diesem Modul platziert wurde in seinen Messungen berücksichtigen. Hierzu greift Drag Ruler auf die Funktionalität von Terrain Ruler zurück. Wenn Terrain Ruler installiert und aktiviert ist wird Drag Ruler automatisch anfangen schwieriges Gelände in den Messungen zu berücksichtigen.",
+				"neverShowAgain": "Zeige dies nie wieder an"
+			},
+			"socketlib": {
+				"title": "Socketlib Modul fehlt",
+				"text": "Drag Ruler benötigt das socketlib-Modul, um korrekt zu funktionieren. Bitte aktiviere das socketlib-Modul in dieser Welt."
+			}
+		},
+		"resetMovementHistory": "Bewegungsverlauf zurücksetzen",
 		"genericSpeedProvider": {
 			"settings": {
 				"dashMultiplier": {
@@ -21,8 +34,12 @@
 				"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."
 			},
+			"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."
+			},
 			"showGMRulerToPlayers": {
-				"name": "Lineal des Sipelleiters bei Spielern anzeigen",
+				"name": "Lineal des Spielleiters bei Spielern anzeigen",
 				"hint": "Wenn diese Option deaktiviert ist wird das Lineal des Spielleiters bei den anderen Spielern nicht angezeigt."
 			},
 			"speedProviderSettings": {
@@ -36,7 +53,7 @@
 				},
 				"activeProvider": {
 					"name": "Verwendete Spielsystemintegration",
-					"hint": "Die unten angezeigten Einstellungen hängen von der verwendeten Spielsystemintegration ab. Wenn der Spielleiter eine andere Spielsystemintegration auswählt können sich die zur Verfügung stehnden Einstellungen ändern."
+					"hint": "Die unten angezeigten Einstellungen hängen von der verwendeten Spielsystemintegration ab. Wenn der Spielleiter eine andere Spielsystemintegration auswählt können sich die zur Verfügung stehenden Einstellungen ändern."
 				},
 				"noSettings": "Diese Spielsystemintegration hat keine Einstellmöglichkeiten",
 				"color": {
@@ -49,7 +66,7 @@
 				},
 				"speedProvider": {
 					"name": "Verwendete Spielsystemintegration",
-					"hint": "Wähle aus, welche Spielsystemintegration für die farbliche Hervorhebung der Felder zuständig sein soll. Drag Ruler stellt eine generische Spielsystemintegration zur Verfügung, die grundlegende Funktionalität bietet und bei korrekter konfiguration mit allen Spielsystemen funktionieren sollte. Weitere Spielsystemintegrationen können durch Module und Spielsysteme angeboten werden. Eine andere Spielsystemintegration als die generische auszuwählen kann eine bessere Inegration in das verwendete Spielsystem bieten. Die Optionen unterhalb sind davon abhäng, welche Spielsystemintegration hier ausgewählt wurde.",
+					"hint": "Wähle aus, welche Spielsystemintegration für die farbliche Hervorhebung der Felder zuständig sein soll. Drag Ruler stellt eine generische Spielsystemintegration zur Verfügung, die grundlegende Funktionalität bietet und bei korrekter konfiguration mit allen Spielsystemen funktionieren sollte. Weitere Spielsystemintegrationen können durch Module und Spielsysteme angeboten werden. Eine andere Spielsystemintegration als die generische auszuwählen kann eine bessere Inegration in das verwendete Spielsystem bieten. Die Optionen unterhalb sind davon abhängig, welche Spielsystemintegration hier ausgewählt wurde.",
 					"choices": {
 						"module": "Modul {name}",
 						"native": "Generisch",
@@ -59,7 +76,7 @@
 			},
 			"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 wrid können mit Rechtsklick Wegpunkte gesetzt werden und mit der Leertaste werden sie wieder gelöscht."
+				"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."
 			}
 		}
 	}

lang/en.json

@@ -1,5 +1,18 @@
 {
 	"drag-ruler": {
+		"dependencies": {
+			"ok": "OK",
+			"terrain-ruler": {
+				"title": "How to measure difficult terrain with 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.",
+				"neverShowAgain": "Never show this again"
+			},
+			"socketlib": {
+				"title": "Socketlib Module Missing",
+				"text": "Drag Ruler requires the socketlib module to work properly. Please activate the socketlib module in this world."
+			}
+		},
+		"resetMovementHistory": "Reset Movement History",
 		"genericSpeedProvider": {
 			"settings": {
 				"dashMultiplier": {
@@ -21,6 +34,10 @@
 				"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."
 			},
+			"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."
+			},
 			"showGMRulerToPlayers": {
 				"name": "Show GM ruler to players",
 				"hint": "If disabled the ruler of GMs will not be shown for non-GM players"

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.4.4",
-	"minimumCoreVersion" : "0.7.9",
-	"compatibleCoreVersion" : "0.7.9",
+	"version": "1.7.5",
+	"minimumCoreVersion" : "0.8.5",
+	"compatibleCoreVersion" : "0.8.7",
 	"authors": [
 		{
 			"name": "Manuel Vögele",
@@ -13,7 +13,8 @@
 		}
 	],
 	"esmodules": [
-		"src/main.js"
+		"src/main.js",
+		"src/socket.js"
 	],
 	"templates": [
 		"speed_provider_settings.html"
@@ -40,8 +41,15 @@
 			"path": "lang/zh-tw.json"
 		}
 	],
+	"dependencies": [
+		{
+			"name": "socketlib",
+			"manifest": "https://raw.githubusercontent.com/manuelVo/foundryvtt-socketlib/master/module.json"
+		}
+	],
+	"socket": true,
 	"url": "https://github.com/manuelVo/foundryvtt-drag-ruler",
-	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/archive/v1.4.4.zip",
+	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/archive/v1.7.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",

src/api.js

@@ -1,5 +1,8 @@
+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";
 
 export const availableSpeedProviders = {}
 export let currentSpeedProvider = undefined
@@ -11,6 +14,9 @@ function register(module, type, speedProvider) {
 		providerInstance = new speedProvider(id)
 	}
 	else {
+		console.warn(`Drag Ruler | The ${type} '${module.id}' uses the old, deprecated version of the Drag Ruler API. ` +
+		             "That old API will be removed in a future Drag Ruler version. " +
+		             `Please update the ${type} ${module.id} to stay compatible with future Drag Ruler versions.`);
 		speedProvider.id = id
 		speedProvider.usesRuler = () => true
 		providerInstance = speedProvider
@@ -98,10 +104,25 @@ export function getUnreachableColorFromSpeedProvider() {
 }
 
 export function getCostFromSpeedProvider(token, area) {
+	try {
 		if (currentSpeedProvider instanceof Function) {
 			return SpeedProvider.prototype.getCostForStep.call(undefined, token, area);
 		}
 		return currentSpeedProvider.getCostForStep(token, area);
+	}
+	catch (e) {
+		console.error(e);
+		return 1;
+	}
+}
+
+export function getMovedDistanceFromToken(token) {
+	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);
+	// Sum up the distances
+	return distances.reduce((acc, val) => acc + val, 0);
 }
 
 export function registerModule(moduleId, speedProvider) {

src/compatibility.js

@@ -1,14 +1,88 @@
+import {getCostFromSpeedProvider} from "./api.js";
 import {getColorForDistance} from "./main.js"
-import {highlightTokenShape} from "./util.js"
+import {settingsKey} from "./settings.js";
+import {getAreaFromPositionAndShape, highlightTokenShape} from "./util.js";
 
 export function getHexSizeSupportTokenGridCenter(token) {
 	const tokenCenterOffset = CONFIG.hexSizeSupport.getCenterOffset(token)
 	return {x: token.x + tokenCenterOffset.x, y: token.y + tokenCenterOffset.y}
 }
 
-export function highlightMeasurementTerrainRuler(ray, startDistance, tokenShape=[{x: 0, y: 0}]) {
+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)
-		highlightTokenShape.call(this, space, tokenShape, color)
+		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)
+		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});
+		if (previousSegments.length > 0)
+			opts.terrainRulerInitialState = previousSegments[previousSegments.length - 1].ray.dragRulerFinalState;
+		return distances.concat(terrainRuler.measureDistances(newSegments, opts));
+	}
+	else {
+		return canvas.grid.measureDistances(segments, opts);
+	}
+}
+
+export function checkDependencies() {
+	if (!game.modules.get("socketlib")?.active) {
+		console.error("Drag Ruler | The `socketlib` module isn't enabled, but it's required for Drag Ruler to operate properly.");
+		if (game.user.isGM) {
+			new Dialog({
+				title: game.i18n.localize("drag-ruler.dependencies.socketlib.title"),
+				content: `<h2>${game.i18n.localize("drag-ruler.dependencies.socketlib.title")}</h2><p>${game.i18n.localize("drag-ruler.dependencies.socketlib.text")}</p>`,
+				buttons: {
+					ok: {
+						icon: '<i class="fas fa-check"></i>',
+						label: game.i18n.localize("drag-ruler.dependencies.ok")
+					}
+				},
+			}).render(true);
+		}
+	}
+	else if (!game.modules.get("terrain-ruler")?.active && game.user.isGM && !game.settings.get(settingsKey, "neverShowTerrainRulerHint")) {
+		const lastHint = game.settings.get(settingsKey, "lastTerrainRulerHintTime");
+		if (Date.now() - lastHint > 604800000) { // One week
+			let enabledTerrainModule;
+			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"),
+					content: `<h2>${game.i18n.localize("drag-ruler.dependencies.terrain-ruler.title")}</h2><p>${game.i18n.format("drag-ruler.dependencies.terrain-ruler.text", {moduleName: enabledTerrainModule})}</p>`,
+					buttons: {
+						ok: {
+							icon: '<i class="fas fa-check"></i>',
+							label: game.i18n.localize("drag-ruler.dependencies.ok"),
+							callback: () => game.settings.set(settingsKey, "lastTerrainRulerHintTime", Date.now()),
+						},
+						neverShowAgain: {
+							icon: '<i class="fas fa-times"></i>',
+							label: game.i18n.localize("drag-ruler.dependencies.terrain-ruler.neverShowAgain"),
+							callback: () => game.settings.set(settingsKey, "neverShowTerrainRulerHint", true),
+						}
+					},
+					close: () => game.settings.set(settingsKey, "lastTerrainRulerHintTime", Date.now())
+				}).render(true);
+			}
+		}
 	}
 }

src/foundry_fixes.js

@@ -2,13 +2,10 @@
 
 // https://gitlab.com/foundrynet/foundryvtt/-/issues/4705
 export function getPixelsFromGridPosition(xGrid, yGrid) {
-	if (canvas.grid.isHex) {
+	if (canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS) {
 		return canvas.grid.grid.getPixelsFromGridPosition(yGrid, xGrid)
 	}
-	const [x, y] = canvas.grid.grid.getPixelsFromGridPosition(xGrid, yGrid)
-	if (canvas.grid.type === CONST.GRID_TYPES.SQUARE)
-		return [y, x]
-	return [x, y]
+	return canvas.grid.grid.getPixelsFromGridPosition(xGrid, yGrid)
 }
 
 // Wrapper to fix a FoundryVTT bug that causes the return values of canvas.grid.grid.getPixelsFromGridPosition to be ordered inconsistently

src/foundry_imports.js

@@ -1,26 +1,31 @@
-import { getCostFromSpeedProvider } from "./api.js";
-import {highlightMeasurementTerrainRuler} from "./compatibility.js";
+import {highlightMeasurementTerrainRuler, measureDistances} from "./compatibility.js";
 import {getGridPositionFromPixels} from "./foundry_fixes.js";
+import {Line} from "./geometry.js";
 import {getColorForDistance} from "./main.js"
-import {applyTokenSizeOffset, getAreaFromPositionAndShape, getSnapPointForToken, getTokenShape, highlightTokenShape, zip} from "./util.js";
+import {trackRays} from "./movement_tracking.js"
+import {recalculate} from "./socket.js";
+import {applyTokenSizeOffset, getSnapPointForEntity, getSnapPointForToken, getTokenShape, highlightTokenShape, zip} from "./util.js";
 
 // This is a modified version of Ruler.moveToken from foundry 0.7.9
-export async function moveTokens(draggedToken, selectedTokens) {
+export async function moveEntities(draggedEntity, selectedEntities) {
 	let wasPaused = game.paused;
 	if (wasPaused && !game.user.isGM) {
 		ui.notifications.warn(game.i18n.localize("GAME.PausedWarning"));
 		return false;
 	}
 	if (!this.visible || !this.destination) return false;
-	if (!draggedToken) return;
+	if (!draggedEntity) return;
+
+	// Wait until all scheduled measurements are done
+	await this.deferredMeasurementPromise;
 
 	// Get the movement rays and check collision along each Ray
 	// These rays are center-to-center for the purposes of collision checking
-	const rays = this._getRaysFromWaypoints(this.waypoints, this.destination);
-	if (!game.user.isGM) {
-		const hasCollision = selectedTokens.some(token => {
-			const offset = calculateTokenOffset(token, draggedToken)
-			const offsetRays = rays.map(ray => applyOffsetToRay(ray, offset))
+	const rays = this.constructor.dragRulerGetRaysFromWaypoints(this.waypoints, this.destination);
+	if (!game.user.isGM && draggedEntity instanceof Token) {
+		const hasCollision = selectedEntities.some(token => {
+			const offset = calculateEntityOffset(token, draggedEntity);
+			const offsetRays = rays.filter(ray => !ray.isPrevious).map(ray => applyOffsetToRay(ray, offset))
 			return offsetRays.some(r => canvas.walls.checkCollision(r));
 		})
 		if (hasCollision) {
@@ -33,50 +38,77 @@ export async function moveTokens(draggedToken, selectedTokens) {
 	// Execute the movement path.
 	// Transform each center-to-center ray into a top-left to top-left ray using the prior token offsets.
 	this._state = Ruler.STATES.MOVING;
-	await Promise.all(selectedTokens.map(token => {
-		// Return the promise so we can wait for it outside the loop
-		const offset = calculateTokenOffset(token, draggedToken)
-		return animateToken.call(this, token, rays, offset, wasPaused)
-	}))
+	await animateEntities.call(this, selectedEntities, draggedEntity, rays, wasPaused);
 
 	// Once all animations are complete we can clear the ruler
+	if (this.draggedEntity?.id === draggedEntity.id)
 		this._endMeasurement();
 }
 
 // This is a modified version code extracted from Ruler.moveToken from foundry 0.7.9
-async function animateToken(token, rays, tokenOffset, wasPaused) {
-	const offsetRays = rays.map(ray => applyOffsetToRay(ray, tokenOffset))
+async function animateEntities(entities, draggedEntity, draggedRays, wasPaused) {
+	const newRays = draggedRays.filter(r => !r.isPrevious);
+	const entityAnimationData = entities.map(entity => {
+		const entityOffset = calculateEntityOffset(entity, draggedEntity);
+		const offsetRays = newRays.map(ray => applyOffsetToRay(ray, entityOffset));
 
 		// Determine offset relative to the Token top-left.
 		// This is important so we can position the token relative to the ruler origin for non-1x1 tokens.
-	const origin = [this.waypoints[0].x + tokenOffset.x, this.waypoints[0].y + tokenOffset.y]
-	let dx, dy
+		const firstWaypoint = this.waypoints.find(w => !w.isPrevious);
+		const origin = [firstWaypoint.x + entityOffset.x, firstWaypoint.y + entityOffset.y];
+		let dx, dy;
 		if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
-		dx = token.data.x - origin[0]
-		dy = token.data.y - origin[1]
+			dx = entity.data.x - origin[0];
+			dy = entity.data.y - origin[1];
 		}
 		else {
-		dx = token.data.x - origin[0]
-		dy = token.data.y - origin[1]
+			dx = entity.data.x - origin[0];
+			dy = entity.data.y - origin[1];
 		}
 
-	token._noAnimate = true;
-	for (let r of offsetRays) {
+		return {entity, rays: offsetRays, dx, dy};
+	});
+
+	const isToken = draggedEntity instanceof Token;
+	const animate = isToken && !game.keyboard.isDown("Alt");
+	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
+	this.cancelMovement = false;
+
+	for (let i = startWaypoint;i < entityAnimationData[0].rays.length; i++) {
 		if (!wasPaused && game.paused) break;
-		const dest = [r.B.x, r.B.y];
-		const path = new Ray({ x: token.x, y: token.y }, { x: dest[0] + dx, y: dest[1] + dy });
-		await token.update(path.B);
-		await token.animateMovement(path);
+		const entityPaths = entityAnimationData.map(({entity, rays, dx, dy}) => {
+			const ray = rays[i];
+			const dest = [ray.B.x, ray.B.y];
+			const path = new Ray({x: entity.x, y: entity.y}, {x: dest[0] + dx, y: dest[1] + dy});
+			return {entity, path};
+		});
+		const updates = entityPaths.map(({entity, path}) => {
+			return {x: path.B.x, y: path.B.y, _id: entity.id};
+		});
+		await draggedEntity.scene.updateEmbeddedDocuments(draggedEntity.constructor.embeddedName, updates, {animate});
+		if (animate)
+			await Promise.all(entityPaths.map(({entity, path}) => entity.animateMovement(path)));
+
+		// This is a flag of the "Monk's Active Tile Triggers" module that signals that the movement should be cancelled early
+		if (this.cancelMovement) {
+			entityAnimationData.forEach(ead => ead.rays = ead.rays.slice(0, i + 1));
+			break;
 		}
-	token._noAnimate = false;
+	}
+	if (isToken)
+		trackRays(entities, entityAnimationData.map(({rays}) => rays)).then(() => recalculate(entities));
 }
 
-function calculateTokenOffset(tokenA, tokenB) {
-	return {x: tokenA.data.x - tokenB.data.x, y: tokenA.data.y - tokenB.data.y}
+function calculateEntityOffset(entityA, entityB) {
+	return {x: entityA.data.x - entityB.data.x, y: entityA.data.y - entityB.data.y};
 }
 
 function applyOffsetToRay(ray, offset) {
-	return new Ray({x: ray.A.x + offset.x, y: ray.A.y + offset.y}, {x: ray.B.x + offset.x, y: ray.B.y + offset.y})
+	const newRay = new Ray({x: ray.A.x + offset.x, y: ray.A.y + offset.y}, {x: ray.B.x + offset.x, y: ray.B.y + offset.y});
+	newRay.isPrevious = ray.isPrevious;
+	return newRay;
 }
 
 // This is a modified version of Ruler._onMouseMove from foundry 0.7.9
@@ -84,8 +116,6 @@ export function onMouseMove(event) {
 	if (this._state === Ruler.STATES.MOVING) return;
 
 	// Extract event data
-	const mt = event._measureTime || 0;
-	const originalEvent = event.data.originalEvent;
 	const destination = {x: event.data.destination.x + this.rulerOffset.x, y: event.data.destination.y + this.rulerOffset.y}
 
 	// Hide any existing Token HUD
@@ -93,24 +123,48 @@ export function onMouseMove(event) {
 	delete event.data.hudState;
 
 	// Draw measurement updates
-	if (Date.now() - mt > 50) {
+	scheduleMeasurement.call(this, destination, event);
+}
+
+function scheduleMeasurement(destination, event) {
+	const measurementInterval = 50;
+	const mt = event._measureTime || 0;
+	const originalEvent = event.data.originalEvent;
+	if (Date.now() - mt > measurementInterval) {
 		this.measure(destination, {snap: !originalEvent.shiftKey});
 		event._measureTime = Date.now();
 		this._state = Ruler.STATES.MEASURING;
+		window.clearTimeout(this.deferredMeasurementTimeout);
+		this.deferredMeasurementTimeout = undefined;
+		this.deferredMeasurementResolve?.();
+	}
+	else {
+		this.deferredMeasurementData = {destination, event};
+		if (!this.deferredMeasurementTimeout) {
+			this.deferredMeasurementPromise = new Promise((resolve, reject) => this.deferredMeasurementResolve = resolve);
+			this.deferredMeasurementTimeout = window.setTimeout(() => scheduleMeasurement.call(this, this.deferredMeasurementData.destination, this.deferredMeasurementData.event), measurementInterval);
+		}
 	}
 }
 
 // This is a modified version of Ruler.measure form foundry 0.7.9
 export function measure(destination, {gridSpaces=true, snap=false} = {}) {
-	if (this.isDragRuler && !this.draggedToken.isVisible)
+	const isToken = this.draggedEntity instanceof Token;
+	if (isToken && !this.draggedEntity.isVisible)
 		return []
 
-	if (snap)
-		destination = getSnapPointForToken(destination.x, destination.y, this.draggedToken)
+	if (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);
 
 	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 = applyTokenSizeOffset(waypoints, this.draggedToken)
+	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)
+		centeredWaypoints.forEach(w => [w.x, w.y] = canvas.grid.getCenter(w.x, w.y));
 
 	const r = this.ruler;
 	this.destination = destination;
@@ -125,6 +179,12 @@ export function measure(destination, {gridSpaces=true, snap=false} = {}) {
 		const label = this.labels.children[i];
 		const ray = new Ray(origin, dest);
 		const centeredRay = new Ray(centeredOrigin, centeredDest)
+		ray.isPrevious = Boolean(origin.isPrevious);
+		centeredRay.isPrevious = ray.isPrevious;
+		ray.dragRulerVisitedSpaces = origin.dragRulerVisitedSpaces;
+		centeredRay.dragRulerVisitedSpaces = ray.dragRulerVisitedSpaces;
+		ray.dragRulerFinalState = origin.dragRulerFinalState;
+		centeredRay.dragRulerFinalState = ray.dragRulerFinalState;
 		if (ray.distance < 10) {
 			if (label) label.visible = false;
 			continue;
@@ -133,15 +193,11 @@ export function measure(destination, {gridSpaces=true, snap=false} = {}) {
 		centeredSegments.push({ray: centeredRay, label})
 	}
 
-	const shape = getTokenShape(this.draggedToken)
+
+	const shape = isToken ? getTokenShape(this.draggedEntity) : null;
 
 	// Compute measured distance
-	const terrainRulerAvailable = game.modules.get("terrain-ruler")?.active && canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS
-	let distances
-	if (terrainRulerAvailable)
-		distances = game.terrainRuler.measureDistances(centeredSegments, {costFunction: (x, y) => getCostFromSpeedProvider(this.draggedToken, getAreaFromPositionAndShape({x, y}, shape), {x, y})});
-	else
-		distances = canvas.grid.measureDistances(centeredSegments, { gridSpaces });
+	const distances = measureDistances(centeredSegments, this.draggedEntity, shape, {gridSpaces});
 
 	let totalDistance = 0;
 	for (let [i, d] of distances.entries()) {
@@ -168,23 +224,40 @@ export function measure(destination, {gridSpaces=true, snap=false} = {}) {
 		const { label, text, last } = cs;
 
 		// Draw line segment
-		r.lineStyle(6, 0x000000, 0.5).moveTo(s.ray.A.x, s.ray.A.y).lineTo(s.ray.B.x, s.ray.B.y)
-			.lineStyle(4, rulerColor, 0.25).moveTo(s.ray.A.x, s.ray.A.y).lineTo(s.ray.B.x, s.ray.B.y);
+		const opacityMultiplier = s.ray.isPrevious ? 0.33 : 1;
+		r.lineStyle(6, 0x000000, 0.5 * opacityMultiplier).moveTo(s.ray.A.x, s.ray.A.y).lineTo(s.ray.B.x, s.ray.B.y)
+			.lineStyle(4, rulerColor, 0.25 * opacityMultiplier).moveTo(s.ray.A.x, s.ray.A.y).lineTo(s.ray.B.x, s.ray.B.y);
 
 		// Draw the distance label just after the endpoint of the segment
 		if (label) {
 			label.text = text;
 			label.alpha = last ? 1.0 : 0.5;
 			label.visible = true;
-			let labelPosition = cs.ray.project((cs.ray.distance + 50) / cs.ray.distance);
+			let labelPosition = {x: s.ray.x0, y: s.ray.y0};
+			labelPosition.x -= label.width / 2;
+			labelPosition.y -= label.height / 2;
+			const rayLine = Line.fromPoints(s.ray.A, s.ray.B);
+			const rayLabelXHitY = rayLine.calcY(labelPosition.x);
+			let innerDistance;
+			// If ray hits top or bottom side of label
+			if (rayLine.isVertical || rayLabelXHitY < labelPosition.y || rayLabelXHitY > labelPosition.y + label.height)
+				innerDistance = Math.abs((label.height / 2) / Math.sin(s.ray.angle));
+			// If ray hits left or right side of label
+			else
+				innerDistance = Math.abs((label.width / 2) / Math.cos(s.ray.angle));
+			labelPosition = s.ray.project((s.ray.distance + 50 + innerDistance) / s.ray.distance);
+			labelPosition.x -= label.width / 2;
+			labelPosition.y -= label.height / 2;
 			label.position.set(labelPosition.x, labelPosition.y);
 		}
 
 		// Highlight grid positions
+		if (isToken && canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS) {
 			if (terrainRulerAvailable)
-			highlightMeasurementTerrainRuler.call(this, cs.ray, cs.startDistance, shape)
+				highlightMeasurementTerrainRuler.call(this, cs.ray, cs.startDistance, shape, opacityMultiplier)
 			else
-			highlightMeasurementNative.call(this, cs.ray, cs.startDistance, shape);
+				highlightMeasurementNative.call(this, cs.ray, cs.startDistance, shape, opacityMultiplier);
+		}
 	}
 
 	// Draw endpoints
@@ -196,7 +269,7 @@ export function measure(destination, {gridSpaces=true, snap=false} = {}) {
 	return segments;
 }
 
-export function highlightMeasurementNative(ray, startDistance, tokenShape=[{x: 0, y: 0}]) {
+export function highlightMeasurementNative(ray, startDistance, 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);
@@ -217,7 +290,7 @@ export function highlightMeasurementNative(ray, startDistance, tokenShape=[{x: 0
 		let [xg, yg] = canvas.grid.grid.getPixelsFromGridPosition(x1, y1);
 		const subDistance = canvas.grid.measureDistances([{ray: new Ray(ray.A, {x: xg, y: yg})}], {gridSpaces: true})[0]
 		const color = dragRuler.getColorForDistance.call(this, startDistance, subDistance)
-		const snapPoint = getSnapPointForToken(...canvas.grid.getTopLeft(x, y), this.draggedToken);
+		const snapPoint = getSnapPointForToken(...canvas.grid.getTopLeft(x, y), this.draggedEntity);
 		const [snapX, snapY] = getGridPositionFromPixels(snapPoint.x + 1, snapPoint.y + 1);
 
 		prior = [x1, y1];
@@ -230,11 +303,11 @@ export function highlightMeasurementNative(ray, startDistance, tokenShape=[{x: 0
 			let [xgh, ygh] = canvas.grid.grid.getPixelsFromGridPosition(x1h, y1h);
 			const subDistance = canvas.grid.measureDistances([{ray: new Ray(ray.A, {x: xgh, y: ygh})}], {gridSpaces: true})[0]
 			const color = dragRuler.getColorForDistance.call(this, startDistance, subDistance)
-			const snapPoint = getSnapPointForToken(...canvas.grid.getTopLeft(x, y), this.draggedToken);
+			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);
+			highlightTokenShape.call(this, {x: snapX, y: snapY}, tokenShape, color, alpha);
 		}
 
-		highlightTokenShape.call(this, {x: snapX, y: snapY}, tokenShape, color);
+		highlightTokenShape.call(this, {x: snapX, y: snapY}, tokenShape, color, alpha);
 	}
 }

src/geometry.js

@@ -0,0 +1,21 @@
+export class Line {
+	constructor(m, b) {
+		this.m = m;
+		this.b = b;
+	}
+
+	static fromPoints(p1, p2) {
+		// Bring line into y=mx+b form
+		const m = (p1.y - p2.y) / (p1.x - p2.x);
+		const b = p1.y - m * p1.x;
+		return new Line(m, b);
+	}
+
+	get isVertical() {
+		return !isFinite(this.m);
+	}
+
+	calcY(x) {
+		return this.m * x + this.b;
+	}
+}

src/main.js

@@ -1,116 +1,88 @@
 "use strict"
 
-import {currentSpeedProvider, getRangesFromSpeedProvider, getUnreachableColorFromSpeedProvider, initApi, registerModule, registerSystem} from "./api.js"
-import {getHexSizeSupportTokenGridCenter} from "./compatibility.js"
-import {measure, moveTokens, onMouseMove} from "./foundry_imports.js"
+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"
-import { getSnapPointForToken } from "./util.js"
 
 Hooks.once("init", () => {
 	registerSettings()
 	initApi()
-	hookTokenDragHandlers()
-	hookRulerFunctions()
+	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.draggedToken = null
+		ruler.draggedEntity = null;
 		Object.defineProperty(ruler, "isDragRuler", {
 			get: function isDragRuler() {
-				return Boolean(this.draggedToken) // If draggedToken is set this is a drag ruler
+				return Boolean(this.draggedEntity); // If draggedEntity is set this is a drag ruler
 			}
 		})
 	})
 })
 
-function hookTokenDragHandlers() {
-	const originalDragLeftStartHandler = Token.prototype._onDragLeftStart
-	Token.prototype._onDragLeftStart = function(event) {
+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)
-		onTokenLeftDragStart.call(this, event)
+		onEntityLeftDragStart.call(this, event)
 	}
 
-	const originalDragLeftMoveHandler = Token.prototype._onDragLeftMove
-	Token.prototype._onDragLeftMove = function (event) {
+	const originalDragLeftMoveHandler = entityType.prototype._onDragLeftMove
+	entityType.prototype._onDragLeftMove = function (event) {
 		originalDragLeftMoveHandler.call(this, event)
-		onTokenLeftDragMove.call(this, event)
+		onEntityLeftDragMove.call(this, event)
 	}
 
-	const originalDragLeftDropHandler = Token.prototype._onDragLeftDrop
-	Token.prototype._onDragLeftDrop = function (event) {
-		const eventHandled = onTokenDragLeftDrop.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 = Token.prototype._onDragLeftCancel
-	Token.prototype._onDragLeftCancel = function (event) {
-		const eventHandled = onTokenDragLeftCancel.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 hookRulerFunctions() {
-	const originalMoveTokenHandler = Ruler.prototype.moveToken
-	Ruler.prototype.moveToken = function (event) {
-		const eventHandled = onRulerMoveToken.call(this, event)
-		if (!eventHandled)
-			return originalMoveTokenHandler.call(this, event)
-		return true
-	}
-
-	const originalToJSON = Ruler.prototype.toJSON
-	Ruler.prototype.toJSON = function () {
-		const json = originalToJSON.call(this)
-		if (this.draggedToken)
-			json["draggedToken"] = this.draggedToken.data._id
-		return json
-	}
-
-	const originalUpdate = Ruler.prototype.update
-	Ruler.prototype.update = function (data) {
-		// Don't show a GMs drag ruler to non GM players
-		if (data.draggedToken && this.user.isGM && !game.user.isGM && !game.settings.get(settingsKey, "showGMRulerToPlayers"))
-			return
-		if (data.draggedToken) {
-			this.draggedToken = canvas.tokens.get(data.draggedToken)
-		}
-		originalUpdate.call(this, data)
-	}
-
-	const originalMeasure = Ruler.prototype.measure
-	Ruler.prototype.measure = function (destination, options={}) {
-		if (this.isDragRuler) {
-			return measure.call(this, destination, options)
-		}
-		else {
-			return originalMeasure.call(this, destination, options)
-		}
-	}
-
-	const originalEndMeasurement = Ruler.prototype._endMeasurement
-	Ruler.prototype._endMeasurement = function () {
-		originalEndMeasurement.call(this)
-		this.draggedToken = null
-	}
-}
-
 function hookKeyboardManagerFunctions() {
 	const originalHandleKeys = KeyboardManager.prototype._handleKeys
 	KeyboardManager.prototype._handleKeys = function (event, key, up) {
@@ -132,10 +104,11 @@ function handleKeys(event, key, up) {
 function onKeyX(up) {
 	if (up)
 		return false
-	if (!canvas.controls.ruler.isDragRuler)
+	const ruler = canvas.controls.ruler;
+	if (!ruler.isDragRuler)
 		return false
 
-	deleteWaypoint()
+	ruler.dragRulerDeleteWaypoint();
 	return true
 }
 
@@ -143,6 +116,8 @@ 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
@@ -150,111 +125,80 @@ function onKeyShift(up) {
 	ruler.measure(measurePosition, {snap: up})
 }
 
-function onTokenLeftDragStart(event) {
-	if (!currentSpeedProvider.usesRuler(this))
+function onEntityLeftDragStart(event) {
+	const isToken = this instanceof Token;
+	if (isToken && !currentSpeedProvider.usesRuler(this))
 		return
 	const ruler = canvas.controls.ruler
-	ruler.draggedToken = this
-	let tokenCenter
-	if (canvas.grid.isHex && game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(this))
-		tokenCenter = getHexSizeSupportTokenGridCenter(this)
+	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
-		tokenCenter = this.center
+		entityCenter = this.center;
 	ruler.clear();
 	ruler._state = Ruler.STATES.STARTING;
-	ruler.rulerOffset = {x: tokenCenter.x - event.data.origin.x, y: tokenCenter.y - event.data.origin.y}
-	addWaypoint.call(ruler, tokenCenter, false)
+	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 onTokenLeftDragMove(event) {
+function onEntityLeftDragMove(event) {
 	const ruler = canvas.controls.ruler
 	if (ruler.isDragRuler)
 		onMouseMove.call(ruler, event)
 }
 
-function onTokenDragLeftDrop(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
-	moveTokens.call(ruler, ruler.draggedToken, selectedTokens)
+	moveEntities.call(ruler, ruler.draggedEntity, selectedTokens);
 	return true
 }
 
-function onTokenDragLeftCancel(event) {
+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")) {
-			if (ruler.waypoints.length > 1)
-				event.preventDefault()
-			deleteWaypoint()
+			ruler.dragRulerDeleteWaypoint(event);
 		}
 		else {
 			event.preventDefault()
 			const snap = !event.shiftKey
-			addWaypoint.call(ruler, ruler.destination, snap)
+			ruler.dragRulerAddWaypoint(ruler.destination, snap);
 		}
 	}
 	return true
 }
 
-function onRulerMoveToken(event) {
-	// This function is invoked by left clicking
-	if (!this.isDragRuler)
-		return false
-	if (!game.settings.get(settingsKey, "swapSpacebarRightClick")) {
-		const snap = !event.shiftKey
-		addWaypoint.call(this, this.destination, snap)
-	}
-	else
-		deleteWaypoint()
-	return true
-}
-
-function addWaypoint(point, snap=true) {
-	if (snap)
-		point = getSnapPointForToken(point.x, point.y, this.draggedToken)
-	this.waypoints.push(new PIXI.Point(point.x, point.y));
-	this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
-}
-
-function deleteWaypoint() {
-	const ruler = canvas.controls.ruler
-	if (ruler.waypoints.length > 1) {
-		const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens)
-		const rulerOffset = ruler.rulerOffset
-		ruler._removeWaypoint({x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y})
-		game.user.broadcastActivity({ruler: ruler})
-	}
-	else {
-		const token = ruler.draggedToken
-		ruler._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({preventDefault: () => {return}})
-	}
-}
-
 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.draggedToken.actor.permission < 2) {
+	if (this.draggedEntity.actor.permission < 2) {
 		// If this is a pc and alwaysShowSpeedForPCs is enabled we show the color anyway
-		if (!(this.draggedToken.actor.data.type === "character" && game.settings.get(settingsKey, "alwaysShowSpeedForPCs")))
+		if (!(this.draggedEntity.actor.data.type === "character" && game.settings.get(settingsKey, "alwaysShowSpeedForPCs")))
 			return this.color
 	}
 	const distance = startDistance + subDistance
-	const ranges = getRangesFromSpeedProvider(this.draggedToken)
+	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) => {

src/movement_tracking.js

@@ -0,0 +1,94 @@
+import {measureDistances} from "./compatibility.js";
+import {recalculate, updateCombatantDragRulerFlags} from "./socket.js";
+import {getTokenShape, zip} from "./util.js";
+
+function initTrackingFlag(combatant) {
+	const initialFlag = {passedWaypoints: [], trackedRound: 0};
+	let dragRulerFlag = combatant.data.flags.dragRuler;
+	if (dragRulerFlag) {
+		if (isNaN(dragRulerFlag.trackedRound)) {
+			mergeObject(dragRulerFlag, initialFlag);
+		}
+	}
+	else {
+		combatant.data.flags.dragRuler = initialFlag;
+	}
+}
+
+function getInitializedCombatant(token, combat) {
+	const combatant = combat.getCombatantByToken(token.id);
+	if (!combatant)
+		return undefined;
+	initTrackingFlag(combatant);
+	return combatant;
+}
+
+export async function trackRays(tokens, tokenRays) {
+	const combat = game.combat;
+	if (!combat)
+		return;
+	if (!combat.started)
+		return;
+	if (!(tokens instanceof Array)) {
+		tokens = [tokens];
+		tokenRays = [tokenRays];
+	}
+	const updates = Array.from(zip(tokens, tokenRays)).map(([token, rays]) => calculateUpdate(combat, token, rays)).filter(Boolean);
+	await updateCombatantDragRulerFlags(combat, updates);
+}
+
+function calculateUpdate(combat, token, rays) {
+	const combatant = getInitializedCombatant(token, combat);
+	if (!combatant)
+		return;
+
+	// Check if we have entered a new round. If so, remove the currently stored path
+	if (combat.data.round > combatant.data.flags.dragRuler.trackedRound) {
+		combatant.data.flags.dragRuler.passedWaypoints = [];
+		combatant.data.flags.dragRuler.trackedRound = combat.data.round;
+	}
+
+	// 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 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});
+				ray.A.dragRulerVisitedSpaces = ray.terrainRulerVisitedSpaces;
+				ray.A.dragRulerFinalState = ray.terrainRulerFinalState;
+			}
+			waypoints.push(ray.A);
+		}
+	}
+	return {_id: combatant.id, dragRulerFlags};
+}
+
+export function getMovementHistory(token) {
+	const combat = game.combat;
+	if (!combat)
+		return [];
+	const combatant = combat.getCombatantByToken(token.id);
+	if (!combatant)
+		return [];
+	const dragRulerFlags = combatant.data.flags.dragRuler;
+	if (!dragRulerFlags)
+		return [];
+	if (combat.data.round > dragRulerFlags.trackedRound)
+		return [];
+	return dragRulerFlags.passedWaypoints ?? [];
+}
+
+export async function resetMovementHistory(combat, combatantId) {
+	const combatant = combat.combatants.get(combatantId);
+	const dragRulerFlags = combatant.data.flags.dragRuler;
+	if (!dragRulerFlags)
+		return;
+	dragRulerFlags.passedWaypoints = null;
+	dragRulerFlags.trackedRound = null;
+	dragRulerFlags.rulerState = null;
+	await updateCombatantDragRulerFlags(combat, [{_id: combatantId, dragRulerFlags}]);
+	recalculate();
+}

src/ruler.js

@@ -0,0 +1,141 @@
+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/settings.js

@@ -38,6 +38,27 @@ export function registerSettings() {
 		default: true,
 	})
 
+	game.settings.register(settingsKey, "enableMovementHistory", {
+		name: "drag-ruler.settings.enableMovementHistory.name",
+		hint: "drag-ruler.settings.enableMovementHistory.hint",
+		scope: "world",
+		config: true,
+		type: Boolean,
+		default: true,
+	});
+
+	game.settings.register(settingsKey, "lastTerrainRulerHintTime", {
+		config: false,
+		type: Number,
+		default: 0,
+	});
+
+	game.settings.register(settingsKey, "neverShowTerrainRulerHint", {
+		config: false,
+		type: Boolean,
+		default: false,
+	});
+
 	// This setting will be modified by the api if modules register to it
 	game.settings.register(settingsKey, "speedProvider", {
 		scope: "world",

src/socket.js

@@ -0,0 +1,43 @@
+import {currentSpeedProvider} from "./api.js";
+
+let socket;
+
+Hooks.once("socketlib.ready", () => {
+	socket = socketlib.registerModule("drag-ruler");
+	socket.register("updateCombatantDragRulerFlags", _socketUpdateCombatantDragRulerFlags);
+	socket.register("recalculate", _socketRecalculate);
+});
+
+export function updateCombatantDragRulerFlags(combat, updates) {
+	const combatId = combat.id;
+	// TODO Check if canvas.tokens.get is still neccessary in future foundry versions
+	return socket.executeAsGM(_socketUpdateCombatantDragRulerFlags, combatId, updates)
+	             .then(() => currentSpeedProvider.onMovementHistoryUpdate(updates.map(update => canvas.tokens.get(combat.combatants.get(update._id).token.id))));
+}
+
+async function _socketUpdateCombatantDragRulerFlags(combatId, updates) {
+	const user = game.users.get(this.socketdata.userId);
+	const combat = game.combats.get(combatId);
+	const requestedUpdates = updates.length;
+	updates = updates.filter(update => {
+		const actor = combat.combatants.get(update._id).actor;
+		if (!actor)
+			return false;
+		return actor.testUserPermission(user, "OWNER");
+	});
+	if (updates.length !== requestedUpdates) {
+		console.warn(`Some of the movement history updates requested by user '${game.users.get(this.socketdata.userId).name}' were not performed because the user lacks owner permissions for those tokens`);
+	}
+	updates = updates.map(update => {
+		return {_id: update._id, flags: {dragRuler: update.dragRulerFlags}};
+	});
+	await combat.updateEmbeddedDocuments("Combatant", updates, {diff: false});
+}
+
+export function recalculate(tokens) {
+	socket.executeForEveryone(_socketRecalculate, tokens ? tokens.map(token => token.id) : undefined);
+}
+
+function _socketRecalculate(tokenIds) {
+	return canvas.controls.ruler.dragRulerRecalculate(tokenIds);
+}

src/speed_provider.js

@@ -67,7 +67,7 @@ export class SpeedProvider {
 	 */
 	getCostForStep(token, area) {
 		// Lookup the cost for each square occupied by the token
-		const costs = area.map(space => canvas.terrain.costGrid[space.y]?.[space.x]?.multiple ?? 1)
+		const costs = area.map(space => terrainRuler.getCost(space.x, space.y, {token}));
 		// Return the maximum of the costs
 		return costs.reduce((max, current) => Math.max(max, current))
 	}
@@ -84,6 +84,14 @@ export class SpeedProvider {
 		return true
 	}
 
+	/**
+	 * This hook is being called after Drag Ruler has updated the movement history for one or more tokens.
+	 * It'll receive an array of tokens that have been updated.
+	 * If your speed provider is storing any additional values that are relevant for the movement history, this function should
+	 * await until those updates have completed inside foundry.
+	 */
+	async onMovementHistoryUpdate(tokens) {}
+
 	/**
 	 * Returns the value that is currently set for the setting registered with the provided settingId.
 	 *
@@ -124,7 +132,7 @@ export class GenericSpeedProvider extends SpeedProvider {
 		const speedAttribute = this.getSetting("speedAttribute")
 		if (!speedAttribute)
 			return []
-		const tokenSpeed = getProperty(token, speedAttribute)
+		const tokenSpeed = parseFloat(getProperty(token, speedAttribute));
 		if (tokenSpeed === undefined) {
 			console.warn(`Drag Ruler (Generic Speed Provider) | The configured token speed attribute "${speedAttribute}" didn't return a speed value. To use colors based on drag distance set the setting to the correct value (or clear the box to disable this feature).`)
 			return []

src/systems.js

@@ -1,12 +1,19 @@
 
 export function getDefaultSpeedAttribute() {
 	switch (game.system.id) {
+		case "dcc":
+			return "actor.data.data.attributes.speed.value";
 		case "dnd5e":
 			return "actor.data.data.attributes.movement.walk"
 		case "lancer":
 			return "actor.data.data.mech.speed"
 		case "pf1":
+		case "D35E":
 			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"
 	}
@@ -17,9 +24,13 @@ export function getDefaultDashMultiplier() {
 	switch (game.system.id) {
 		case "swade":
 			return 0
+		case "dcc":
 		case "dnd5e":
 		case "lancer":
 		case "pf1":
+		case "D35E":
+		case "sfrpg":
+		case "shadowrun5e":
 			return 2
 	}
 	return 0

src/util.js

@@ -7,6 +7,9 @@ export function* zip(it1, it2) {
 }
 
 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)
@@ -16,18 +19,65 @@ 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);
+	}
+	// 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 highlightTokenShape(position, shape, color) {
+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.highlightPosition(this.name, {x, y, color})
+		canvas.grid.grid.highlightGridPosition(layer, {x, y, color, alpha: 0.25 * alpha});
 	}
 }