@fboes/aerofly-custom-missions 1.13.0 → 1.14.0

package/src/dto-flight/AeroflyNavRouteBase.test.ts

@@ -1,30 +1,65 @@
 import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
 import { AeroflyNavRouteDestination } from "../index.js";
 
 describe("AeroflyNavRouteBase", () => {
-    it("should create a valid AeroflyNavRouteBase structure", () => {
-        const waypoints = [
-            { wp: new AeroflyNavRouteDestination("MAX-NE", 179.999, 89.999), uid: 0n },
-            { wp: new AeroflyNavRouteDestination("MAX-SW", -179.999, -89.999), uid: 0n },
-            { wp: new AeroflyNavRouteDestination("KEYW", -81.7599558, 24.5561197), uid: 5033914504046249216n },
-            { wp: new AeroflyNavRouteDestination("EGLL", -0.45277777, 51.47138888), uid: 9199731073154483456n },
-            { wp: new AeroflyNavRouteDestination("YSSY", 151.177, -33.4961), uid: 16969837613165511936n },
-            { wp: new AeroflyNavRouteDestination("RJTT", 139.779, 35.709), uid: 16385890514078663936n },
+    it("should create UIDs almost matching the ingame UIDs", () => {
+        const testCases = [
+            {
+                wp: new AeroflyNavRouteDestination("MAX-NE", 179.999, 89.999),
+                assertUid: 18446694595666707712n,
+                ingameUid: 0n,
+            },
+            {
+                wp: new AeroflyNavRouteDestination("MAX-SW", -179.999, -89.999),
+                assertUid: 51677066167552n,
+                ingameUid: 0n,
+            },
+            {
+                wp: new AeroflyNavRouteDestination("KEYW", -81.7599558, 24.5561197),
+                assertUid: 5033914504046314752n,
+                ingameUid: 5033914504046249216n,
+            },
+            {
+                wp: new AeroflyNavRouteDestination("EGLL", -0.45277777, 51.47138888),
+                assertUid: 9200173076798702848n,
+                ingameUid: 9199731073154483456n,
+            },
+            {
+                wp: new AeroflyNavRouteDestination("YSSY", 151.177, -33.4961),
+                assertUid: 16969826619723154688n,
+                ingameUid: 16969837613165511936n,
+            },
+            {
+                wp: new AeroflyNavRouteDestination("RJTT", 139.779, 35.709),
+                assertUid: 16385782762532177152n,
+                ingameUid: 16385890514078663936n,
+            },
         ];
 
-        for (const waypoint of waypoints) {
-            console.log(waypoint.wp.getUidFallback(), waypoint.uid);
+        for (const testCase of testCases) {
+            assert.strictEqual(
+                testCase.wp.getUidFallback(),
+                testCase.assertUid,
+                `${testCase.wp.identifier} was ${testCase.ingameUid}`,
+            );
         }
     });
 
-    it("should test some unpacking of UIDs", () => {
+    it("should unpack UIDs for airports to code 1280", () => {
         const unpackPayload = (packed: bigint) => {
             return Number(packed & 0xffffn);
         };
 
-        console.log("KEYW", unpackPayload(5033914504046314752n));
-        console.log("EGLL", unpackPayload(9200173076798702848n));
-        console.log("YSSY", unpackPayload(16969826619723154688n));
-        console.log("RJTT", unpackPayload(16385782762532177152n));
+        const testCases = [
+            { uid: 5033914504046314752n, code: 1280, airport: "KEYW" },
+            { uid: 9200173076798702848n, code: 1280, airport: "EGLL" },
+            { uid: 16969826619723154688n, code: 1280, airport: "YSSY" },
+            { uid: 16385782762532177152n, code: 1280, airport: "RJTT" },
+        ];
+
+        for (const testCase of testCases) {
+            assert.strictEqual(unpackPayload(testCase.uid), testCase.code, testCase.airport);
+        }
     });
 });

package/src/dto-flight/AeroflyNavRouteBase.ts

@@ -1,5 +1,6 @@
-import { convertLonLatToVector, convertVectorToLonLat, type AeroflyVector3Float } from "../node/Convert.js";
+import { convertLonLatToVector, convertVectorToLonLat } from "../node/Convert.js";
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
+import { AeroflyVector3Float, type AeroflyVector3FloatArray } from "../node/AeroflyTypes.js";
 
 export type AeroflyNavRouteType =
     | "origin"
@@ -77,8 +78,8 @@ export class AeroflyNavRouteBase {
      * @param {AeroflyVector3Float} position to set longitude and latitude from
      * @returns {this} for chaining
      */
-    setPosition(position: AeroflyVector3Float): this {
-        this.position = position;
+    setPosition(position: AeroflyVector3FloatArray): this {
+        this.position = AeroflyVector3Float.fromArray(position);
         return this;
     }
 
@@ -88,7 +89,7 @@ export class AeroflyNavRouteBase {
             .appendChild(
                 "vector3_float64",
                 "Position",
-                this.position,
+                this.position.toArray(),
                 `Lon ${this.longitude.toFixed(6)}, Lat ${this.latitude.toFixed(6)}`,
             )
             .appendChild(

package/src/dto-flight/AeroflyNavRouteRunway.ts

@@ -1,6 +1,7 @@
-import { convertFeetToMeter, convertMeterToFeet, type AeroflyVector3Float } from "../node/Convert.js";
+import { convertDirectionToHeading, convertFeetToMeter, convertMeterToFeet } from "../node/Convert.js";
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
 import { AeroflyNavRouteBase, type AeroflyNavRouteType } from "./AeroflyNavRouteBase.js";
+import { AeroflyVector3Float } from "../node/AeroflyTypes.js";
 
 class AeroflyNavRouteRunway extends AeroflyNavRouteBase {
     /**
@@ -66,12 +67,11 @@ class AeroflyNavRouteRunway extends AeroflyNavRouteBase {
      * @returns {AeroflyVector3Float | null} runway direction, null if not set
      */
     get direction(): AeroflyVector3Float | null {
-        // TODO: calculate direction vector from direction_degree
-        return this.direction_degree !== null ? [0, 0, 0] : null;
+        return this.direction_degree !== null ? new AeroflyVector3Float(0, 0, 0) : null; // TODO: Get direction vector
     }
 
     set direction(direction: AeroflyVector3Float) {
-        this.direction_degree = 0; // TODO: calculate direction_degree from direction vector
+        this.direction_degree = convertDirectionToHeading(direction, this.position);
     }
 
     getElement(index: number = 0): AeroflyConfigurationNode {
@@ -80,7 +80,7 @@ class AeroflyNavRouteRunway extends AeroflyNavRouteBase {
             element.appendChild(
                 "vector3_float64",
                 "Direction",
-                this.direction,
+                this.direction.toArray(),
                 `Runway direction ${Math.round(this.direction_degree ?? 0)}°`,
             );
         }

package/src/dto-flight/AeroflyNavRouteTransition.ts

@@ -1,6 +1,7 @@
-import { convertFeetToMeter, convertMeterToFeet, type AeroflyVector3Float } from "../node/Convert.js";
+import { convertFeetToMeter, convertMeterToFeet } from "../node/Convert.js";
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
 import { AeroflyNavRouteBase, type AeroflyNavRouteType } from "./AeroflyNavRouteBase.js";
+import { AeroflyVector3Float } from "../node/AeroflyTypes.js";
 
 class AeroflyNavRouteTransition extends AeroflyNavRouteBase {
     /**
@@ -52,14 +53,14 @@ class AeroflyNavRouteTransition extends AeroflyNavRouteBase {
      * @returns {AeroflyVector3Float} deliberately empty
      */
     get position(): AeroflyVector3Float {
-        return [0, 0, 0]; // sic!
+        return new AeroflyVector3Float(0, 0, 0); // sic!
     }
 
     /**
      * @returns {AeroflyVector3Float} deliberately empty
      */
     get direction(): AeroflyVector3Float {
-        return [0, 0, 0]; // sic!
+        return new AeroflyVector3Float(0, 0, 0); // sic!
     }
 
     getElement(index: number = 0): AeroflyConfigurationNode {
@@ -67,7 +68,7 @@ class AeroflyNavRouteTransition extends AeroflyNavRouteBase {
 
         element
             .appendChild("string8u", "Airport", this.airport)
-            .appendChild("vector3_float64", "Direction", this.direction)
+            .appendChild("vector3_float64", "Direction", this.direction.toArray())
             .appendChild(
                 "float64",
                 "Elevation",
@@ -115,7 +116,7 @@ export class AeroflyNavRouteArrival extends AeroflyNavRouteTransition {
 
         element
             .appendChild("string8u", "Airport", this.airport)
-            .appendChild("vector3_float64", "Direction", this.direction)
+            .appendChild("vector3_float64", "Direction", this.direction.toArray())
             .appendChild(
                 "float64",
                 "Elevation",

package/src/dto-flight/AeroflyNavRouteWaypoint.ts

@@ -3,10 +3,10 @@ import {
     convertLonLatToVector,
     convertMeterToFeet,
     convertVectorToLonLat,
-    type AeroflyVector3Float,
 } from "../node/Convert.js";
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
 import { AeroflyNavRouteBase } from "./AeroflyNavRouteBase.js";
+import type { AeroflyVector3Float } from "../node/AeroflyTypes.js";
 
 export class AeroflyNavRouteWaypoint extends AeroflyNavRouteBase {
     /**

package/src/dto-flight/AeroflySettingsFlight.test.ts

@@ -38,36 +38,6 @@ describe("AeroflySettingsFlight", () => {
         assertValidAeroflyStructure(flight.toString());
     });
 
-    it("should use valid orientation from main.mcf", () => {
-        const flight = new AeroflySettingsFlight(-122.3088, 47.4502, 1000, 90, 150);
-
-        // Canada
-        flight.orientation = [
-            -0.763419555334921, 0.645896043270811, 0.00298057365988389, -0.564914354076689, -0.665451427226094,
-            -0.487899754622681, -0.313149094027667, -0.374155982565915, 0.872894578754952,
-        ];
-
-        console.log("Orientation:", flight.heading_degree); // should be 270, is 216
-
-        // South Africa
-        flight.orientation = [
-            0.324874838801671, -0.945743434574979, 0.0050690306677758, -0.526455468124437, -0.185291526716742,
-            -0.829766045466347, 0.785685038164447, 0.266901491350839, -0.5580883574482,
-        ];
-
-        console.log("Orientation:", flight.heading_degree); // should be 270, is 301
-
-        // Japan
-        flight.orientation = [
-            0.717429258146935, 0.696613268777701, 0.00502128644729529, -0.393795668419003, 0.411487688662976,
-            -0.821950639401925, -0.574647919242008, 0.587714076606685, 0.569536595021937,
-        ];
-
-        console.log("Orientation:", flight.heading_degree); // should be 270, is 331
-
-        assertValidAeroflyStructure(flight.toString());
-    });
-
     it("should create fallbacks for flight configurations", () => {
         const flight = new AeroflySettingsFlight(-122.3088, 47.4502, 1000, 90, 150, {
             configuration: "OnGround",
@@ -89,4 +59,26 @@ describe("AeroflySettingsFlight", () => {
         assert.ok(flight.flaps > 0, "Flaps extended");
         assert.strictEqual(flight.onGround, false);
     });
+
+    it("should convert between speed and velocity vector", () => {
+        const flight = new AeroflySettingsFlight(-122.3088, 47.4502, 1000, 90, 150);
+
+        assert.strictEqual(flight.speed_kts, 150);
+        assert.strictEqual(flight.speed_ms, 77.1666);
+
+        const velocity = flight.velocity;
+        assert.ok(velocity.x > 60);
+        assert.ok(velocity.y < -40);
+        assert.ok(velocity.z > 0);
+
+        // Reset speed
+        flight.speed_ms = 0;
+        assert.strictEqual(flight.speed_kts, 0);
+        assert.strictEqual(flight.speed_ms, 0);
+
+        // Set speed from velocity vector
+        flight.velocity = velocity;
+        assert.strictEqual(flight.speed_kts, 150);
+        assert.strictEqual(flight.speed_ms, 77.1666);
+    });
 });

package/src/dto-flight/AeroflySettingsFlight.ts

@@ -1,12 +1,16 @@
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
 import {
-    type AeroflyVector3Float,
-    type AeroflyMatrix3Float,
+    AeroflyMatrix3Float,
+    AeroflyVector3Float,
+    type AeroflyMatrix3FloatArray,
+    type AeroflyVector3FloatArray,
+} from "../node/AeroflyTypes.js";
+import {
     convertFeetToMeter,
     convertLonLatToVector,
     convertVectorToLonLat,
-    convertDegreeToMatrix,
-    convertMatrixToDegree,
+    convertHeadingToOrientation,
+    convertOrientationToHeading,
     convertMeterToFeet,
 } from "../node/Convert.js";
 
@@ -103,15 +107,15 @@ export class AeroflySettingsFlight {
     }
 
     static createInCartesian(
-        position: AeroflyVector3Float,
-        velocity: AeroflyVector3Float,
-        orientation: AeroflyMatrix3Float,
+        position: AeroflyVector3FloatArray,
+        velocity: AeroflyVector3FloatArray,
+        orientation: AeroflyMatrix3FloatArray,
         additionalAttributes: Partial<AeroflySettingsFlight> = {},
     ): AeroflySettingsFlight {
         const flight = new AeroflySettingsFlight(0, 0, 0, 0, 0, additionalAttributes);
-        flight.position = position;
-        flight.velocity = velocity;
-        flight.orientation = orientation;
+        flight.position = AeroflyVector3Float.fromArray(position);
+        flight.velocity = AeroflyVector3Float.fromArray(velocity);
+        flight.orientation = AeroflyMatrix3Float.fromArray(orientation);
         return flight;
     }
 
@@ -142,7 +146,6 @@ export class AeroflySettingsFlight {
                 break;
             default:
                 this.throttle = 0;
-                this.speed_kts = 0;
                 break;
         }
     }
@@ -166,21 +169,19 @@ export class AeroflySettingsFlight {
      */
     get velocity(): AeroflyVector3Float {
         const speed = this.speed_ms;
-        const heading_rad = this.heading_degree * (Math.PI / 180);
-        return [Math.cos(heading_rad) * speed, Math.sin(heading_rad) * speed, 0];
+        return this.orientation.multiplyVector(new AeroflyVector3Float(speed, 0, 0));
     }
 
     set velocity(velocity: AeroflyVector3Float) {
-        // TODO: implement setting velocity vector and updating speed accordingly
-        this.speed_ms = 0;
+        this.speed_ms = Math.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2);
     }
 
     get orientation(): AeroflyMatrix3Float {
-        return convertDegreeToMatrix(this.heading_degree);
+        return convertHeadingToOrientation(this.heading_degree, this.position);
     }
 
     set orientation(orientation: AeroflyMatrix3Float) {
-        this.heading_degree = convertMatrixToDegree(orientation);
+        this.heading_degree = convertOrientationToHeading(orientation, this.position);
     }
 
     /**
@@ -210,14 +211,14 @@ export class AeroflySettingsFlight {
             .appendChild(
                 "vector3_float64",
                 "position",
-                this.position,
+                this.position.toArray(),
                 `Lon ${this.longitude.toFixed(6)}, Lat ${this.latitude.toFixed(6)}, ${Math.ceil(this.altitude_ft)} ft`,
             )
-            .appendChild("vector3_float64", "velocity", this.velocity, `${Math.round(this.speed_kts)} kts`)
+            .appendChild("vector3_float64", "velocity", this.velocity.toArray(), `${Math.round(this.speed_kts)} kts`)
             .appendChild(
                 "matrix3_float64",
                 "orientation",
-                this.orientation,
+                this.orientation.toArray(),
                 `${Math.round(this.heading_degree)}° heading`,
             )
             .appendChild("float64", "gear", this.gear)

package/src/node/AeroflyTypes.ts

@@ -0,0 +1,70 @@
+export type AeroflyVector3FloatArray = [number, number, number];
+
+export class AeroflyVector3Float {
+    constructor(
+        public x: number,
+        public y: number,
+        public z: number,
+    ) {}
+
+    normalize(): AeroflyVector3Float {
+        const norm = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+
+        if (norm === 0) {
+            return new AeroflyVector3Float(0, 0, 0);
+        }
+        return new AeroflyVector3Float(this.x / norm, this.y / norm, this.z / norm);
+    }
+
+    cross(b: AeroflyVector3Float): AeroflyVector3Float {
+        return new AeroflyVector3Float(
+            this.y * b.z - this.z * b.y,
+            this.z * b.x - this.x * b.z,
+            this.x * b.y - this.y * b.x,
+        );
+    }
+
+    static fromArray(array: AeroflyVector3FloatArray): AeroflyVector3Float {
+        return new this(...array);
+    }
+
+    toArray(): AeroflyVector3FloatArray {
+        return [this.x, this.y, this.z];
+    }
+}
+
+export type AeroflyMatrix3FloatArray = [number, number, number, number, number, number, number, number, number];
+
+export class AeroflyMatrix3Float {
+    constructor(
+        public xx: number,
+        public yx: number,
+        public zx: number,
+        public xy: number,
+        public yy: number,
+        public zy: number,
+        public xz: number,
+        public yz: number,
+        public zz: number,
+    ) {}
+
+    transpose(): AeroflyMatrix3Float {
+        return new AeroflyMatrix3Float(this.xx, this.xy, this.xz, this.yx, this.yy, this.yz, this.zx, this.zy, this.zz);
+    }
+
+    multiplyVector(v: AeroflyVector3Float): AeroflyVector3Float {
+        return new AeroflyVector3Float(
+            this.xx * v.x + this.xy * v.y + this.xz * v.z,
+            this.yx * v.x + this.yy * v.y + this.yz * v.z,
+            this.zx * v.x + this.zy * v.y + this.zz * v.z,
+        );
+    }
+
+    static fromArray(array: AeroflyMatrix3FloatArray): AeroflyMatrix3Float {
+        return new this(...array);
+    }
+
+    toArray(): AeroflyMatrix3FloatArray {
+        return [this.xx, this.yx, this.zx, this.xy, this.yy, this.zy, this.xz, this.yz, this.zz];
+    }
+}

package/src/node/Convert.test.ts

@@ -2,14 +2,14 @@ import { describe, it } from "node:test";
 import { strict as assert } from "node:assert";
 
 import {
-    convertDegreeToMatrix,
+    convertHeadingToOrientation,
     convertFeetToMeter,
     convertLonLatToVector,
-    convertMatrixToDegree,
+    convertOrientationToHeading,
     convertMeterToFeet,
     convertVectorToLonLat,
-    type AeroflyMatrix3Float,
 } from "./Convert.js";
+import { AeroflyMatrix3Float, AeroflyVector3Float } from "./AeroflyTypes.js";
 
 describe("Convert", () => {
     it("should convert feet to meters correctly", () => {
@@ -54,45 +54,124 @@ describe("Convert", () => {
         );
     });
 
-    it("should convert heading degree to orientation matrix and back correctly", () => {
-        const orientationMatrix: AeroflyMatrix3Float = [0, -1, 0, 1, 0, 0, 0, 0, 1];
-        const expectedHeadingDegree = 90;
+    it("should convert orientation matrix to heading degree", () => {
+        const positionKEYW = new AeroflyVector3Float(831922.0452075421, -5744695.679418418, 2634432.6068597846);
+        const positionYSSY = new AeroflyVector3Float(-4640429.92586909, 2553500.8064244, -3541489.45541516);
 
-        const actualHeadingDegree = convertMatrixToDegree(orientationMatrix);
-        assert.strictEqual(
-            actualHeadingDegree.toFixed(4),
-            expectedHeadingDegree.toFixed(4),
-            `Expected heading degree to be ${expectedHeadingDegree.toFixed(4)}, got ${actualHeadingDegree.toFixed(4)}`,
-        );
-    });
+        const testCases = [
+            {
+                orientation: new AeroflyMatrix3Float(
+                    -0.0668066264395785,
+                    0.431792064197595,
+                    0.899495685348041,
+                    -0.98941528906399,
+                    -0.145060537051883,
+                    -0.00385050082983023,
+                    0.128818711490931,
+                    -0.890232022500988,
+                    0.43691267512355,
+                ),
+                position: positionKEYW,
+                heading: 0,
+            },
+            {
+                orientation: new AeroflyMatrix3Float(
+                    0.985978516472605,
+                    0.166832368887515,
+                    -0.00365044461148948,
+                    -0.066064640816506,
+                    0.41034317377044,
+                    0.90953501470465,
+                    0.153237816116869,
+                    -0.896540819166301,
+                    0.41561127424596,
+                ),
+                position: positionKEYW,
+                heading: 90,
+            },
 
-    it("should convert heading degree to orientation matrix and back correctly", () => {
-        const heading_degree = 90;
-        const expectedHeadingDegree = 90;
-
-        const orientationMatrix = convertDegreeToMatrix(heading_degree);
-        console.log("Orientation Matrix:", orientationMatrix);
+            {
+                orientation: new AeroflyMatrix3Float(
+                    -0.465135059130883,
+                    -0.885151853036744,
+                    0.0124729239927332,
+                    -0.489418463305539,
+                    0.268872261996669,
+                    0.829564508946978,
+                    -0.737644185595572,
+                    0.379755057628484,
+                    -0.558271575187768,
+                ),
+                position: positionYSSY,
+                heading: 90,
+            },
+        ];
 
-        const actualHeadingDegree = convertMatrixToDegree(orientationMatrix);
-        assert.strictEqual(
-            actualHeadingDegree.toFixed(4),
-            expectedHeadingDegree.toFixed(4),
-            `Expected heading degree to be ${expectedHeadingDegree.toFixed(4)}, got ${actualHeadingDegree.toFixed(4)}`,
-        );
+        for (const testCase of testCases) {
+            const calculatedHeading = convertOrientationToHeading(testCase.orientation, testCase.position);
+            const message = `Expected heading to be ${testCase.heading.toFixed(4)}, got ${calculatedHeading.toFixed(4)}`;
+            assert.strictEqual(Math.round(calculatedHeading) % 360, Math.round(testCase.heading) % 360, message);
+        }
     });
 
-    it("should show the orientation at Tellruide correctly", () => {
-        const orientationMatrix: AeroflyMatrix3Float = [
-            -0.449510470601295, -0.541223404385256, -0.710645877610949, 0.868733701939534, -0.450067862031944,
-            -0.206738179058507, -0.207947329711721, -0.710293000184874, 0.672489228132418,
+    it("should convert heading degree to orientation matrix (ignoring pitch, roll, yaw, etc.)", () => {
+        const positionKEYW = new AeroflyVector3Float(831922.0452075421, -5744695.679418418, 2634432.6068597846);
+        const positionYSSY = new AeroflyVector3Float(-4640429.92586909, 2553500.8064244, -3541489.45541516);
+
+        const testCases = [
+            {
+                orientation: new AeroflyMatrix3Float(
+                    -0.0668066264395785,
+                    0.431792064197595,
+                    0.899495685348041,
+                    -0.98941528906399,
+                    -0.145060537051883,
+                    -0.00385050082983023,
+                    0.128818711490931,
+                    -0.890232022500988,
+                    0.43691267512355,
+                ),
+                position: positionKEYW,
+                heading: 0,
+            },
+            {
+                orientation: new AeroflyMatrix3Float(
+                    0.985978516472605,
+                    0.166832368887515,
+                    -0.00365044461148948,
+                    -0.066064640816506,
+                    0.41034317377044,
+                    0.90953501470465,
+                    0.153237816116869,
+                    -0.896540819166301,
+                    0.41561127424596,
+                ),
+                position: positionKEYW,
+                heading: 90,
+            },
+
+            {
+                orientation: new AeroflyMatrix3Float(
+                    -0.465135059130883,
+                    -0.885151853036744,
+                    0.0124729239927332,
+                    -0.489418463305539,
+                    0.268872261996669,
+                    0.829564508946978,
+                    -0.737644185595572,
+                    0.379755057628484,
+                    -0.558271575187768,
+                ),
+                position: positionYSSY,
+                heading: 90,
+            },
         ];
-        const expectedHeadingDegree = 117.3585;
 
-        const actualHeadingDegree = convertMatrixToDegree(orientationMatrix);
-        assert.strictEqual(
-            actualHeadingDegree.toFixed(4),
-            expectedHeadingDegree.toFixed(4),
-            `Expected heading degree to be ${expectedHeadingDegree.toFixed(4)}, got ${actualHeadingDegree.toFixed(4)}`,
-        );
+        for (const testCase of testCases) {
+            const calculatedOrientation = convertHeadingToOrientation(testCase.heading, testCase.position);
+            const calculatedHeading = convertOrientationToHeading(calculatedOrientation, testCase.position);
+
+            assert.strictEqual(calculatedHeading, testCase.heading);
+        }
     });
 });