Fix rare bug where vehicle would not move to next track piece if start and end positions overlapped

Author: Basssiiie

lib/duktape.d.ts

@@ -21,6 +21,18 @@ interface Duktape
 	 */
 	act(depth: number): DukStackEntry;
 
+	/**
+	 * Encodes its argument value into chosen format.
+	 */
+	enc(format: "hex" | "base64", value: any): string;
+	enc(format: "jx" | "jc", value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+	enc(format: "jx" | "jc", value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+
+	/**
+	 * Decodes and parses its argument value from chosen format into a value.
+	 */
+	dec(format: "hex" | "base64", value: string): any;
+	dec(format: "jx" | "jc", value: string, reviver?: (this: any, key: string, value: any) => any): any;
 
 	/**
 	 * Callback that gets triggered after an ECMAScript error has occured.
@@ -62,4 +74,4 @@ interface Performance
 	 * Gets the monotonic time in milliseconds, including fractions.
 	 */
 	now(): number;
-}
+}

package-lock.json

@@ -20,7 +20,7 @@
 		"url": "https://github.com/Basssiiie/OpenRCT2-RideVehicleEditor/issues"
 	},
 	"dependencies": {
-		"openrct2-flexui": "^0.1.0-prerelease.15"
+		"openrct2-flexui": "^0.1.0-prerelease.20"
 	},
 	"devDependencies": {
 		"@ava/typescript": "^4.0.0",

package.json

@@ -50,7 +50,7 @@ export function getDistanceFromProgress(car: Car, trackProgress: number): number
 
 	while (subpositionIterator._remainingProgress > 0 && iteratorSegment)
 	{
-		Log.debug("Remaining progress:", subpositionIterator._remainingProgress, ", total:", subpositionIterator._totalDistance);
+		Log.debug("getDistanceFromProgress(): remaining:", subpositionIterator._remainingProgress, ", total:", subpositionIterator._totalDistance);
 
 		const trackPieceLength = trackDistances._progressLength;
 
@@ -59,7 +59,7 @@ export function getDistanceFromProgress(car: Car, trackProgress: number): number
 			// Quick add whole segment.
 			subpositionIterator._totalDistance += trackDistances._totalDistance;
 			subpositionIterator._remainingProgress -= trackPieceLength;
-			Log.debug("total +=", trackDistances._totalDistance, "=", subpositionIterator._totalDistance, "(whole segment)");
+			Log.debug("getDistanceFromProgress(): total +=", trackDistances._totalDistance, "=", subpositionIterator._totalDistance);
 		}
 		else
 		{
@@ -80,15 +80,21 @@ export function getDistanceFromProgress(car: Car, trackProgress: number): number
 
 		const nextTrackPosition = iterator.position;
 		const nextTrackDistance = getTrackDistances(iteratorSegment, subposition, nextTrackPosition.direction);
+		const segmentDistance = subpositionIterator._getDistanceBetweenSegments(trackPosition, trackDistances, nextTrackPosition, nextTrackDistance);
+
+		if (segmentDistance)
+		{
+			// If segment distance is 0, the end and start positions overlap and another step should to be taken.
+			subpositionIterator._totalDistance += segmentDistance;
+			subpositionIterator._remainingProgress--;
+		}
 
-		subpositionIterator._remainingProgress--;
-		subpositionIterator._totalDistance += subpositionIterator._getDistanceBetweenSegments(trackPosition, trackDistances, nextTrackPosition, nextTrackDistance);
 		trackPosition = nextTrackPosition;
 		trackDistances = nextTrackDistance;
 	}
 
 	const totalDistance = subpositionIterator._totalDistance;
-	Log.debug("Move vehicle", totalDistance, "; progress change:", trackProgress);
+	Log.debug("getDistanceFromProgress(): Move vehicle", totalDistance, ", progress change:", trackProgress, ", final progress:", trackDistances._totalDistance, totalDistance > 0 ? "" : "\x1b[93m[WARNING] VEHICLE DID NOT MOVE");
 	return (trackProgress < 0) ? -totalDistance : totalDistance;
 }
 
@@ -250,8 +256,13 @@ function isLocationEqual(left: CoordsXYZD, right: CoordsXYZD): boolean
  */
 abstract class SubpositionIterator
 {
+	/** Amount of track progress that's still to be iterated. */
 	_remainingProgress: number;
+
+	/** Position of the car on the current track piece. */
 	_distanceIndex: number;
+
+	/** Total distance travelled by the iterator. */
 	_totalDistance: number = 0;
 
 	constructor (remainingProgress: number, currentProgress: number)
@@ -304,7 +315,7 @@ class ForwardIterator extends SubpositionIterator
 		for (; distanceIdx < trackPieceLength && remainingProgress > 0; distanceIdx++)
 		{
 			this._totalDistance += distances[distanceIdx];
-			Log.debug("total +=", distances[distanceIdx], "=", this._totalDistance, "(step:", distanceIdx, ", remaining:", remainingProgress, ")");
+			Log.debug("forward(): total +=", distances[distanceIdx], "=", this._totalDistance, "(step:", distanceIdx, "/", trackPieceLength, ", remaining:", remainingProgress, ")");
 			remainingProgress--;
 		}
 
@@ -313,6 +324,7 @@ class ForwardIterator extends SubpositionIterator
 	}
 	override _jumpSegment(trackIterator: TrackIterator): boolean
 	{
+		Log.debug("forward(): next segment:", trackIterator.position, "->", trackIterator.nextPosition);
 		return trackIterator.next();
 	}
 	override _getDistanceBetweenSegments(previousTile: CoordsXYZ, previousTrack: Readonly<TrackDistances>, nextTile: CoordsXYZ, nextTrack: Readonly<TrackDistances>): number
@@ -350,14 +362,15 @@ class BackwardIterator extends SubpositionIterator
 		while (--distanceIdx >= 0 && remainingProgress > 0)
 		{
 			this._totalDistance += distances[distanceIdx];
-			Log.debug("total +=", distances[distanceIdx], "=", this._totalDistance, "(step:", distanceIdx, ", remaining:", remainingProgress, ")");
+			Log.debug("backward(): total +=", distances[distanceIdx], "=", this._totalDistance, "(step:", distanceIdx, "/", trackPieceLength, ", remaining:", remainingProgress, ")");
 			remainingProgress--;
 		}
 		this._remainingProgress = remainingProgress;
 		this._distanceIndex = 0;
 	}
 	override _jumpSegment(trackIterator: TrackIterator): boolean
 	{
+		Log.debug("backward(): previous segment:", trackIterator.position, "->", trackIterator.previousPosition);
 		return trackIterator.previous();
 	}
 	override _getDistanceBetweenSegments(previousTile: CoordsXYZ, previousTrack: Readonly<TrackDistances>, nextTile: CoordsXYZ, nextTrack: Readonly<TrackDistances>): number

src/services/spacingEditor.ts

@@ -21,7 +21,11 @@ const isDuktapeAvailable = (typeof Duktape !== "undefined");
  */
 function print(level: LogLevel, messages: unknown[]): void
 {
-	console.log(`<RVE/${level}> ${messages.join(" ")}`);
+	const message = messages
+		.map(v => (Array.isArray(v) ? `[${v}]` : typeof v == "object" ? Duktape.enc('jx', v) : v))
+		.join(" ");
+
+	console.log(`\x1b[1;33m<RVE/${level}>\x1b[37m ${message}`);
 }
 
 

src/utilities/logger.ts

@@ -12,7 +12,7 @@ class TrackPiece
 {
 	constructor(
 		public position: CoordsXYZD,
-		public type: number,
+		public type: number, // must be unique in this test file to avoid cache collisions
 		public subpositions: CoordsXYZ[])
 	{}
 
@@ -46,7 +46,7 @@ function setupTrackIterator(trackPieces: TrackPiece[], trackStartIndex?: number)
 			x: Math.floor(p.position.x / 32),
 			y: Math.floor(p.position.y / 32),
 			elements: [
-				Mock.trackElement({ type: "track", baseZ: p.position.z })
+				Mock.trackElement({ type: "track", baseZ: p.position.z, direction: p.position.direction })
 			]
 		})),
 		getTrackIterator()
@@ -331,9 +331,12 @@ const multiTurnTest = test.macro({
 	exec(t, startTrackPiece: number, startProgress: number, progress: number, expectedResult: number): void
 	{
 		const trackPieces = [ rightTurn1TrackPiece, rightTurn2TrackPiece, steepUpTrackPiece, steepTurnTrackPiece ];
-		const trackLocation: CarTrackLocation = { ...trackPieces[startTrackPiece].position, direction: 0, trackType: 0 };
 		setupTrackIterator(trackPieces, startTrackPiece);
-		const car = Mock.car({ trackProgress: startProgress, trackLocation, remainingDistance: (progress >= 0) ? ForwardRemainingDistance : 0 });
+		const car = Mock.car({
+			trackProgress: startProgress,
+			trackLocation: trackPieces[startTrackPiece].toLocation(),
+			remainingDistance: (progress >= 0) ? ForwardRemainingDistance : 0
+		});
 
 		const distance = getDistanceFromProgress(car, progress);
 
@@ -382,6 +385,36 @@ test("Flat track: move backwards by 1 and account for remaining distance cap", t
 });
 
 
+const steepToSlopedDownwardsTrackPiece = new TrackPiece({ x: 64, y: 64, z: 16, direction: 2 }, 21,
+[
+	{ x: 16, y: 0, z: 31 }, { x: 16, y: 10, z: 16 }, { x: 16, y: 32, z: 0 },
+]);
+const slopedToFlatDownwardsTrackPiece = new TrackPiece({ x: 64, y: 96, z: 8, direction: 2 }, 22,
+[
+	{ x: 16, y: 0, z: 8 }, { x: 16, y: 16, z: 1 }, { x: 16, y: 31, z: 0 },
+]);
+
+test("Downward slope: move extra step forward if end point overlaps with start point", t =>
+{
+	setupTrackIterator([ steepToSlopedDownwardsTrackPiece, slopedToFlatDownwardsTrackPiece ], 0);
+	const car = Mock.car({ trackProgress: 2, remainingDistance: ForwardRemainingDistance, trackLocation: steepToSlopedDownwardsTrackPiece.toLocation() });
+
+	const distance = getDistanceFromProgress(car, 1);
+
+	t.is(distance, 10_905);
+});
+
+test("Downward slope: move extra step backwards if end point overlaps with start point", t =>
+{
+	setupTrackIterator([ steepToSlopedDownwardsTrackPiece, slopedToFlatDownwardsTrackPiece ], 1);
+	const car = Mock.car({ trackProgress: 0, remainingDistance: 0, trackLocation: slopedToFlatDownwardsTrackPiece.toLocation() });
+
+	const distance = getDistanceFromProgress(car, -1);
+
+	t.is(distance, -10_905);
+});
+
+
 function createTrain(mapMock: GameMapMock, cars: Partial<Car>[]): RideTrain
 {
 	const length = cars.length;