Release v1.2.2

This allows us to move multiple tokens at a time
and allows the gm to move tokens through walls again

CHANGELOG.md

@@ -0,0 +1,39 @@
+## 1.2.2
+### Translation
+- Added japanese translation (thanks to touge)
+
+## 1.2.1
+### Compatiblity
+- Drag Ruler is now compatible with Hex Token Size Support. For compatibility Hex Token Size Support Version 0.5.4 or higher is required. Thanks to Ourobor for helping making this possible.
+
+## 1.2.0
+### New features
+- Right click and spacebar can now be swapped, allowing to place waypoints with right click and removing them with spacebar
+- The module can now be configured use a fixed color instead of the player color for the first speed range
+- On gridless maps the ruler will now change it's color to indicate the different speed ranges
+- As an alternative to right click (or spacebar, if you have swapped right and spacebar behavior) waypoints can now also be deleted with the `X` key
+
+### Bugfixes
+- Disabling snap to grid with shift now works as expected
+- Fixed a bug where the ruler would sometimes jump to a different target location when deleting a waypoint
+
+## 1.1.1
+### Bugfixes
+- Fixed a bug where tokens wouldn't be moved to the corect end position on gridless maps
+- Ruler now appears immediately when the token is being dragged
+- On gridless maps the ruler will always start measuring at the center of the token
+  - This change has no impact on the distance that is being measured
+  - In addition to the cosmetical aspect this also fixes a bug that allowed players to glitch through walls
+
+## 1.1.0
+### New features
+- The drag ruler will now be colored for other players than the dragging player as well (only if they have at least observer permissions for that token)
+- The drag ruler won't be shown to other players if they cannot see the dragged token
+
+### Bugfixes
+- Fixed a bug where Drag Ruler wouldn't work at all on some windows installations (specificially where the `foundry.js` has `CRLF` line endings)
+
+## 1.0.1
+### Bugfixes
+- The GM can now move tokens through walls
+- It is now possible to move multiple tokens with Drag Ruler enabled

README.md

@@ -1,5 +1,7 @@
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/staebchenfisch)
+
 # Drag Ruler
-This module shows a ruler when you drag a token 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.
+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.
 
 
 ## Path color
@@ -20,6 +22,18 @@ ShowDragDistance isn't maintained anymore. This means that it is at risk to stop
 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.
 
 
+## Game systems with Drag Ruler integration
+Drag Ruler will work with all Foundry VTT game systems. However some game systems offer a special integration via the [Drag Ruler API](#api), that allows Drag Ruler to take the rules of the game system into account when dispaying speeds (such as weight carried or conditions that apply to the character), offering a smoother experience. While some game systems offer this integration natively, for other game systems there are modules providing the integration. If the integration is provided via a module you need to install and activate both Drag Ruler and the integration module to benefit from the integration.
+
+The game systems that offer Drag Ruler integration are:
+- Pathfinder 1 (starting with version 0.77.3)
+- Pathfinder 2e (via the module [PF2E Drag Ruler Integration](https://foundryvtt.com/packages/pf2e-dragruler/))
+
+
+## Translations
+Drag Ruler is available in the follwing languages:
+- Japanese (thanks to touge)
+
 ## API
 *Audience: This paragraph is intended for module and system devleopers that want to add more complex behavior to Drag Ruler. If you just want to use this plugins features skip this paragraph.*
 
@@ -49,7 +63,7 @@ Here is an example of how a Speed Provider might look like:
 ```javascript
 function mySpeedProvider(token, playerColor) {
 	const baseSpeed = token.actor.data.speed
-	const ranges = [{range: baseSpeed, color: playerColor, range: baseSpeed * 2, color: 0xFFFF00}]
+	const ranges = [{range: baseSpeed, color: playerColor}, {range: baseSpeed * 2, color: 0xFFFF00}]
 	if (!token.actor.data.isWearingArmor) {
 		ranges.push({range: baseSpeed * 3, color: 0xFF8000})
 	}
@@ -69,7 +83,7 @@ Hooks.once("dragRuler.ready", () => {
 
 function mySpeedProvider(token, playerColor) {
 	const baseSpeed = token.actor.data.speed
-	const ranges = [{range: baseSpeed, color: playerColor, range: baseSpeed * 2, color: 0xFFFF00}]
+	const ranges = [{range: baseSpeed, color: playerColor}, {range: baseSpeed * 2, color: 0xFFFF00}]
 	if (!token.actor.data.isWearingArmor) {
 		ranges.push({range: baseSpeed * 3, color: 0xFF8000})
 	}

lang/en.json

@@ -1,6 +1,10 @@
 {
 	"drag-ruler": {
 		"settings": {
+			"alwaysShowSpeedForPCs": {
+				"name": "Show PC speed to everyone",
+				"hint": "If enabled the coloring based on actor speed for player characters will shown to everyone, even if they don't have observer permission for the character sheet."
+			},
 			"dashMultiplier": {
 				"name": "Dash Multiplier",
 				"hint": "This can be used to give tokens a secondary speed during coloring of the measured path. Set it to 0 to disable the secondary speed."
@@ -17,6 +21,14 @@
 					"native": "Drag Ruler",
 					"system": "System"
 				}
+			},
+			"staticFirstColor": {
+				"name": "Static First Color",
+				"hint": "Use a static color for the first movement range instead of the player color"
+			},
+			"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"
 			}
 		}
 	}

lang/ja.json

@@ -0,0 +1,35 @@
+{
+	"drag-ruler": {
+		"settings": {
+			"alwaysShowSpeedForPCs": {
+				"name": "プレイヤーキャラクターの移動速度を全員に公開する",
+				"hint": "有効にすると、アクターの観察者（Observer）権限を持たない人にも，移動範囲の色分けが表示されるようになります。"
+			},
+			"dashMultiplier": {
+				"name": "早足の倍率",
+				"hint": "有効にすると、移動範囲に二つ目の色分けが追加されます。0にすると、この機能は無効になります。"
+			},
+			"speedAttribute": {
+				"name": "移動速度の属性値",
+				"hint": "コマの移動速度が定義された属性値を指定します。移動範囲表示の色分けに使用されます。"
+			},
+			"speedProvider": {
+				"name": "移動速度設定の提供元",
+				"hint": "色分けに使用する速度情報の提供元を選択します。ゲームシステムやモジュールを選択すると、Drag Ruler自体が提供するものより柔軟な色分けが行える可能性があります。",
+				"choices": {
+					"module": "モジュール",
+					"native": "Drag Ruler",
+					"system": "ゲームシステム"
+				}
+			},
+			"staticFirstColor": {
+				"name": "一つ目の色を固定する",
+				"hint": "一つ目の移動範囲の色に、プレイヤーの色でなく固定された色を使用します。"
+			},
+			"swapSpacebarRightClick": {
+				"name": "スペースキーと右クリックを入れ替える",
+				"hint": "ドラッグ中のスペースキーと右クリックの機能を入れ替えます。有効にすると右クリックがウェイポイントの配置、スペースキーが削除になります。"
+			}
+		}
+	}
+}

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.0.0",
+	"version": "1.2.2",
 	"minimumCoreVersion" : "0.7.9",
 	"compatibleCoreVersion" : "0.7.9",
 	"authors": [
@@ -20,11 +20,17 @@
 			"lang": "en",
 			"name": "English",
 			"path": "lang/en.json"
+		},
+		{
+			"lang": "ja",
+			"name": "日本語",
+			"path": "lang/ja.json"
 		}
 	],
 	"url": "https://github.com/manuelVo/foundryvtt-drag-ruler",
-	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/archive/v1.0.0.zip",
+	"download": "https://github.com/manuelVo/foundryvtt-drag-ruler/archive/v1.2.2.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",
 	"bugs": "https://github.com/manuelVo/foundryvtt-drag-ruler/issues"
 }

src/compatibility.js

@@ -0,0 +1,19 @@
+export function getHexSizeSupportTokenGridCenter(token) {
+	const tokenCenterOffset = CONFIG.hexSizeSupport.getCenterOffset(token)
+	const tokenCenter = {x: token.x + tokenCenterOffset.x, y: token.y + tokenCenterOffset.y}
+	if (token.getFlag("hex-size-support", "borderSize") % 2 === 1)
+		return tokenCenter
+	if (canvas.grid.grid.columns) {
+		let hexOffset = canvas.grid.w / 2
+		if (!CONFIG.hexSizeSupport.getAltOrientationFlag(token))
+			hexOffset *= -1
+		tokenCenter.x += hexOffset
+	}
+	else {
+		let hexOffset = canvas.grid.h / 2
+		if (CONFIG.hexSizeSupport.getAltOrientationFlag(token))
+			hexOffset *= -1
+		tokenCenter.y += hexOffset
+	}
+	return tokenCenter
+}

src/foundry_imports.js

@@ -0,0 +1,179 @@
+import {getColorForDistance} from "./main.js"
+
+// This is a modified version of Ruler.moveToken from foundry 0.7.9
+export async function moveTokens(draggedToken, selectedTokens) {
+	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;
+
+	// 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))
+			return offsetRays.some(r => canvas.walls.checkCollision(r));
+		})
+		if (hasCollision) {
+			ui.notifications.error(game.i18n.localize("ERROR.TokenCollide"));
+			this._endMeasurement();
+			return true;
+		}
+	}
+
+	// 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)
+	}))
+
+	// Once all animations are complete we can clear the ruler
+	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))
+
+	// 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
+	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
+		dx = token.data.x - origin[0]
+		dy = token.data.y - origin[1]
+	}
+	else {
+		dx = token.data.x - origin[0]
+		dy = token.data.y - origin[1]
+	}
+
+	token._noAnimate = true;
+	for (let r of offsetRays) {
+		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);
+	}
+	token._noAnimate = false;
+}
+
+function calculateTokenOffset(tokenA, tokenB) {
+	return {x: tokenA.data.x - tokenB.data.x, y: tokenA.data.y - tokenB.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})
+}
+
+// This is a modified version of Ruler._onMouseMove from foundry 0.7.9
+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
+	canvas.hud.token.clear();
+	delete event.data.hudState;
+
+	// Draw measurement updates
+	if (Date.now() - mt > 50) {
+		this.measure(destination, {snap: !originalEvent.shiftKey});
+		event._measureTime = Date.now();
+		this._state = Ruler.STATES.MEASURING;
+	}
+}
+
+// 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)
+		return []
+
+	if (snap)
+		destination = new PIXI.Point(...canvas.grid.getCenter(destination.x, destination.y));
+	const waypoints = this.waypoints.concat([destination]);
+	const centeredWaypoints = waypoints.map(w => new PIXI.Point(...canvas.grid.getCenter(w.x, w.y)))
+	const r = this.ruler;
+	this.destination = destination;
+
+	// Iterate over waypoints and construct segment rays
+	const segments = [];
+	const centeredSegments = []
+	for (let [i, dest] of waypoints.slice(1).entries()) {
+		const centeredDest = centeredWaypoints[i + 1]
+		const origin = waypoints[i];
+		const centeredOrigin = centeredWaypoints[i]
+		const label = this.labels.children[i];
+		const ray = new Ray(origin, dest);
+		const centeredRay = new Ray(centeredOrigin, centeredDest)
+		if (ray.distance < 10) {
+			if (label) label.visible = false;
+			continue;
+		}
+		segments.push({ ray, label });
+		centeredSegments.push({ray: centeredRay, label})
+	}
+
+	// Compute measured distance
+	const distances = canvas.grid.measureDistances(centeredSegments, { gridSpaces });
+	let totalDistance = 0;
+	for (let [i, d] of distances.entries()) {
+		let s = segments[i];
+		s.startDistance = totalDistance
+		totalDistance += d;
+		s.last = i === (segments.length - 1);
+		s.distance = d;
+		s.text = this._getSegmentLabel(d, totalDistance, s.last);
+	}
+
+	// Clear the grid highlight layer
+	const hlt = canvas.grid.highlightLayers[this.name] || canvas.grid.addHighlightLayer(this.name);
+	hlt.clear();
+
+	// Draw measured path
+	r.clear();
+	let rulerColor
+	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS)
+		rulerColor = getColorForDistance.call(this, totalDistance)
+	else
+		rulerColor = this.color
+	for (let s of segments) {
+		const { ray, label, text, last } = s;
+
+		// Draw line segment
+		r.lineStyle(6, 0x000000, 0.5).moveTo(ray.A.x, ray.A.y).lineTo(ray.B.x, ray.B.y)
+			.lineStyle(4, rulerColor, 0.25).moveTo(ray.A.x, ray.A.y).lineTo(ray.B.x, 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 = ray.project((ray.distance + 50) / ray.distance);
+			label.position.set(labelPosition.x, labelPosition.y);
+		}
+
+		// Highlight grid positions
+		this._highlightMeasurement(ray, s.startDistance);
+	}
+
+	// Draw endpoints
+	for (let p of waypoints) {
+		r.lineStyle(2, 0x000000, 0.5).beginFill(rulerColor, 0.25).drawCircle(p.x, p.y, 8);
+	}
+
+	// Return the measured segments
+	return segments;
+}

src/main.js

@@ -1,13 +1,15 @@
 "use strict"
 
 import {availableSpeedProviders, currentSpeedProvider, registerModule, registerSystem, setCurrentSpeedProvider} from "./api.js"
+import {getHexSizeSupportTokenGridCenter} from "./compatibility.js"
+import {measure, moveTokens, onMouseMove} from "./foundry_imports.js"
 import {registerSettings, settingsKey} from "./settings.js"
 
 Hooks.once("init", () => {
 	registerSettings()
 	hookTokenDragHandlers()
-	hookRulerHandlers()
-	patchRulerMeasure()
+	hookRulerFunctions()
+	hookKeyboardManagerFunctions()
 	patchRulerHighlightMeasurement()
 
 	availableSpeedProviders["native"] = nativeSpeedProvider
@@ -26,11 +28,13 @@ Hooks.once("ready", () => {
 })
 
 Hooks.on("canvasReady", () => {
-	canvas.controls.ruler.draggedToken = null
-	Object.defineProperty(canvas.controls.ruler, "isDragRuler", {
-		get: function isDragRuler() {
-			return Boolean(this.draggedToken) // If draggedToken is set this is a drag ruler
-		}
+	canvas.controls.rulers.children.forEach(ruler => {
+		ruler.draggedToken = null
+		Object.defineProperty(ruler, "isDragRuler", {
+			get: function isDragRuler() {
+				return Boolean(this.draggedToken) // If draggedToken is set this is a drag ruler
+			}
+		})
 	})
 })
 
@@ -62,7 +66,7 @@ function hookTokenDragHandlers() {
 	}
 }
 
-function hookRulerHandlers() {
+function hookRulerFunctions() {
 	const originalMoveTokenHandler = Ruler.prototype.moveToken
 	Ruler.prototype.moveToken = function (event) {
 		const eventHandled = onRulerMoveToken.call(this, event)
@@ -70,66 +74,173 @@ function hookRulerHandlers() {
 			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) {
+		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)
+		}
+	}
+}
+
+function hookKeyboardManagerFunctions() {
+	const originalHandleKeys = KeyboardManager.prototype._handleKeys
+	KeyboardManager.prototype._handleKeys = function (event, key, up) {
+		const eventHandled = handleKeys.call(this, event, key, up)
+		if (!eventHandled)
+			originalHandleKeys.call(this, event, key, up)
+	}
+}
+
+function handleKeys(event, key, up) {
+	if (event.repeat || this.hasFocus)
+		return false
+
+	if (key.toLowerCase() === "x") return onKeyX(up)
+	if (key.toLowerCase() === "shift") return onKeyShift(up)
+	return false
+}
+
+function onKeyX(up) {
+	if (up)
+		return false
+	if (!canvas.controls.ruler.isDragRuler)
+		return false
+
+	deleteWaypoint()
+	return true
+}
+
+function onKeyShift(up) {
+	const ruler = canvas.controls.ruler
+	if (!ruler.isDragRuler)
+		return false
+
+	const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens)
+	const rulerOffset = ruler.rulerOffset
+	const measurePosition = {x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y}
+	ruler.measure(measurePosition, {snap: up})
 }
 
 function onTokenLeftDragStart(event) {
-	canvas.controls.ruler._onDragStart(event)
-	canvas.controls.ruler.draggedToken = this
+	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)
+	else
+		tokenCenter = {x: this.x + canvas.grid.grid.w / 2, y: this.y + canvas.grid.grid.h / 2}
+	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)
 }
 
 function onTokenLeftDragMove(event) {
-	if (canvas.controls.ruler.isDragRuler)
-		canvas.controls.ruler._onMouseMove(event)
+	const ruler = canvas.controls.ruler
+	if (ruler.isDragRuler)
+		onMouseMove.call(ruler, event)
 }
 
 function onTokenDragLeftDrop(event) {
-	if (!canvas.controls.ruler.isDragRuler)
+	const ruler = canvas.controls.ruler
+	if (!ruler.isDragRuler)
 		return false
-	canvas.controls.ruler.draggedToken = null
-	canvas.controls.ruler.moveToken(event)
+	const selectedTokens = canvas.tokens.placeables.filter(token => token._controlled)
+	moveTokens.call(ruler, ruler.draggedToken, selectedTokens)
+	ruler.draggedToken = null
 	return true
 }
 
 function onTokenDragLeftCancel(event) {
-	if (!canvas.controls.ruler.isDragRuler)
+	// This function is invoked by right clicking
+	const ruler = canvas.controls.ruler
+	if (!ruler.isDragRuler)
 		return false
-	if (canvas.controls.ruler._state === Ruler.STATES.MEASURING) {
-		if (canvas.controls.ruler.waypoints.length > 1) {
-			canvas.controls.ruler._removeWaypoint(canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens), {snap: !event.shiftKey})
-			game.user.broadcastActivity({ruler: canvas.controls.ruler})
-			event.preventDefault()
+	if (ruler._state === Ruler.STATES.MEASURING) {
+		if (!game.settings.get(settingsKey, "swapSpacebarRightClick")) {
+			if (ruler.waypoints.length > 1)
+				event.preventDefault()
+			deleteWaypoint()
 		}
 		else {
-			canvas.controls.ruler._endMeasurement()
-			canvas.controls.ruler.draggedToken = null
-			return false
+			event.preventDefault()
+			const snap = !event.shiftKey
+			addWaypoint.call(ruler, ruler.destination, snap)
 		}
 	}
 	return true
 }
 
 function onRulerMoveToken(event) {
+	// This function is invoked by left clicking
 	if (!this.isDragRuler)
 		return false
-	this._addWaypoint(this.destination)
+	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 = canvas.grid.getCenter(point.x, point.y);
+	else
+		point = [point.x, point.y]
+	this.waypoints.push(new PIXI.Point(point[0], point[1]));
+	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()
+		ruler.draggedToken = null
+
+		// 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}})
+	}
+}
+
 function strInsertAfter(haystack, needle, strToInsert) {
 	const pos = haystack.indexOf(needle) + needle.length
 	return haystack.slice(0, pos) + strToInsert + haystack.slice(pos)
 }
 
-// These patches were written with foundry-0.7.9.js as reference
-function patchRulerMeasure() {
-	let code = Ruler.prototype.measure.toString()
-	// Remove function signature and closing curly bracket (those are on the first and last line)
-	code = code.slice(code.indexOf("\n"), code.lastIndexOf("\n"))
-	code = strInsertAfter(code, "for ( let [i, d] of distances.entries() ) {\n", "segments[i].startDistance = totalDistance\n")
-	code = strInsertAfter(code, "this._highlightMeasurement(ray", ", s.startDistance")
-	Ruler.prototype.measure = new Function("destination", "{gridSpaces=true}={}", code)
-}
-
 function nativeSpeedProvider(token, playercolor) {
 	const speedAttribute = game.settings.get(settingsKey, "speedAttribute")
 	if (!speedAttribute)
@@ -145,11 +256,18 @@ function nativeSpeedProvider(token, playercolor) {
 	return [{range: tokenSpeed, color: playercolor}, {range: tokenSpeed * dashMultiplier, color: 0xFFFF00}]
 }
 
-function getColorForDistance(startDistance, subDistance) {
+export function getColorForDistance(startDistance, subDistance=0) {
 	if (!this.isDragRuler)
 		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 is a pc and alwaysShowSpeedForPCs is enabled we show the color anyway
+		if (!(this.draggedToken.actor.data.type === "character" && game.settings.get(settingsKey, "alwaysShowSpeedForPCs")))
+			return this.color
+	}
 	const distance = startDistance + subDistance
-	const ranges = currentSpeedProvider(this.draggedToken, this.color)
+	const firstColor = game.settings.get(settingsKey, "staticFirstColor") ? 0x00FF00 : this.color
+	const ranges = currentSpeedProvider(this.draggedToken, firstColor)
 	if (ranges.length === 0)
 		return this.color
 	const currentRange = ranges.reduce((minRange, currentRange) => {
@@ -163,6 +281,8 @@ function getColorForDistance(startDistance, subDistance) {
 // These patches were written with foundry-0.7.9.js as reference
 function patchRulerHighlightMeasurement() {
 	let code = Ruler.prototype._highlightMeasurement.toString()
+	// Replace CRLF with LF in case foundry.js has CRLF for some reason
+	code = code.replace(/\r\n/g, "\n")
 	// Remove function signature and closing curly bracket (those are on the first and last line)
 	code = code.slice(code.indexOf("\n"), code.lastIndexOf("\n"))
 

src/settings.js

@@ -4,6 +4,24 @@ import {getDefaultDashMultiplier, getDefaultSpeedAttribute} from "./systems.js"
 export const settingsKey = "drag-ruler";
 
 export function registerSettings() {
+	game.settings.register(settingsKey, "swapSpacebarRightClick", {
+		name: "drag-ruler.settings.swapSpacebarRightClick.name",
+		hint: "drag-ruler.settings.swapSpacebarRightClick.hint",
+		scope: "client",
+		config: true,
+		type: Boolean,
+		default: false,
+	})
+
+	game.settings.register(settingsKey, "alwaysShowSpeedForPCs", {
+		name: "drag-ruler.settings.alwaysShowSpeedForPCs.name",
+		hint: "drag-ruler.settings.alwaysShowSpeedForPCs.hint",
+		scope: "world",
+		config: true,
+		type: Boolean,
+		default: true,
+	})
+
 	// This setting will be modified by the api if modules register to it
 	game.settings.register(settingsKey, "speedProvider", {
 		name: "drag-ruler.settings.speedProvider.name",
@@ -35,4 +53,13 @@ export function registerSettings() {
 		type: Number,
 		default: getDefaultDashMultiplier(),
 	})
+
+	game.settings.register(settingsKey, "staticFirstColor", {
+		name: "drag-ruler.settings.staticFirstColor.name",
+		hint: "drag-ruler.settings.staticFirstColor.hint",
+		scope: "world",
+		config: true,
+		type: Boolean,
+		default: false,
+	})
 }