@fboes/aerofly-custom-missions 1.13.0 → 1.13.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 This changelog documents all notable changes to the Aerofly Custom Missions project. Each version entry includes a list of changes, with the most recent version at the top.
 
+## [Unreleased]
+
+## [1.13.1] - 2026-07-24
+
+- Fixed orientation / heading parsing
+
 ## [1.13.0] - 2026-07-23
 
 - Made unit conversions more precise

package/dist/dto-flight/AeroflyNavRouteBase.js

@@ -1,5 +1,6 @@
 import { convertLonLatToVector, convertVectorToLonLat } from "../node/Convert.js";
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
+import { AeroflyVector3Float } from "../node/AeroflyTypes.js";
 export class AeroflyNavRouteBase {
     /**
      * @property {AeroflyNavRouteType} type like "origin", "departure_runway", "departure", "waypoint", "arrival", "approach", "destination_runway" or "destination"
@@ -53,13 +54,13 @@ export class AeroflyNavRouteBase {
      * @returns {this} for chaining
      */
     setPosition(position) {
-        this.position = position;
+        this.position = AeroflyVector3Float.fromArray(position);
         return this;
     }
     getElement(index = 0) {
         const element = new AeroflyConfigurationNode("tmnav_route_" + this.type, this.identifier, String(index))
             .appendChild("string8u", "Identifier", this.identifier)
-            .appendChild("vector3_float64", "Position", this.position, `Lon ${this.longitude.toFixed(6)}, Lat ${this.latitude.toFixed(6)}`)
+            .appendChild("vector3_float64", "Position", this.position.toArray(), `Lon ${this.longitude.toFixed(6)}, Lat ${this.latitude.toFixed(6)}`)
             .appendChild("uint64", "Uid", this.uid ?? this.getUidFallback(), this.uid ? "" : "Fallback UID, not matching Aerofly FS internal UID");
         return element;
     }

package/dist/dto-flight/AeroflyNavRouteBase.test.js

@@ -1,26 +1,56 @@
 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) => {
             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/dist/dto-flight/AeroflyNavRouteRunway.js

@@ -1,6 +1,7 @@
-import { convertFeetToMeter, convertMeterToFeet } from "../node/Convert.js";
+import { convertDirectionToHeading, convertFeetToMeter, convertMeterToFeet } from "../node/Convert.js";
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
 import { AeroflyNavRouteBase } from "./AeroflyNavRouteBase.js";
+import { AeroflyVector3Float } from "../node/AeroflyTypes.js";
 class AeroflyNavRouteRunway extends AeroflyNavRouteBase {
     /**
      * @property {?number} direction_degree runway direction in degrees, null if not set
@@ -45,16 +46,15 @@ class AeroflyNavRouteRunway extends AeroflyNavRouteBase {
      * @returns {AeroflyVector3Float | null} runway direction, null if not set
      */
     get direction() {
-        // 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) {
-        this.direction_degree = 0; // TODO: calculate direction_degree from direction vector
+        this.direction_degree = convertDirectionToHeading(direction, this.position);
     }
     getElement(index = 0) {
         const element = super.getElement(index);
         if (this.direction !== null) {
-            element.appendChild("vector3_float64", "Direction", this.direction, `Runway direction ${Math.round(this.direction_degree ?? 0)}°`);
+            element.appendChild("vector3_float64", "Direction", this.direction.toArray(), `Runway direction ${Math.round(this.direction_degree ?? 0)}°`);
         }
         if (this.elevation !== null) {
             element.appendChild("float64", "Elevation", this.elevation, this.elevation_ft ? `Elevation ${Math.ceil(this.elevation_ft)} ft` : undefined);

package/dist/dto-flight/AeroflyNavRouteTransition.js

@@ -1,6 +1,7 @@
 import { convertFeetToMeter, convertMeterToFeet } from "../node/Convert.js";
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
 import { AeroflyNavRouteBase } from "./AeroflyNavRouteBase.js";
+import { AeroflyVector3Float } from "../node/AeroflyTypes.js";
 class AeroflyNavRouteTransition extends AeroflyNavRouteBase {
     /**
      * @property {string} airport ICAO code of the airport this transition belongs to, e.g. "SEA", "PDX"
@@ -38,19 +39,19 @@ class AeroflyNavRouteTransition extends AeroflyNavRouteBase {
      * @returns {AeroflyVector3Float} deliberately empty
      */
     get position() {
-        return [0, 0, 0]; // sic!
+        return new AeroflyVector3Float(0, 0, 0); // sic!
     }
     /**
      * @returns {AeroflyVector3Float} deliberately empty
      */
     get direction() {
-        return [0, 0, 0]; // sic!
+        return new AeroflyVector3Float(0, 0, 0); // sic!
     }
     getElement(index = 0) {
         const element = super.getElement(index);
         element
             .appendChild("string8u", "Airport", this.airport)
-            .appendChild("vector3_float64", "Direction", this.direction)
+            .appendChild("vector3_float64", "Direction", this.direction.toArray())
             .appendChild("float64", "Elevation", this.elevation ?? 0, `Elevation ${this.elevation_ft !== null ? Math.ceil(this.elevation_ft) + " ft" : "unknown"}`)
             .appendChild("string8u", "Transition", this.transition)
             .appendChild("uint64", "TransitionUid", this.transitionUid ?? 0);
@@ -86,7 +87,7 @@ export class AeroflyNavRouteArrival extends AeroflyNavRouteTransition {
         const element = super.getElement(index);
         element
             .appendChild("string8u", "Airport", this.airport)
-            .appendChild("vector3_float64", "Direction", this.direction)
+            .appendChild("vector3_float64", "Direction", this.direction.toArray())
             .appendChild("float64", "Elevation", this.elevation ?? 0, `Elevation ${this.elevation_ft !== null ? Math.ceil(this.elevation_ft) + " ft" : "unknown"}`);
         return element;
     }

package/dist/dto-flight/AeroflySettingsFlight.js

@@ -1,5 +1,6 @@
 import { AeroflyConfigurationNode } from "../node/AeroflyConfigurationNode.js";
-import { convertFeetToMeter, convertLonLatToVector, convertVectorToLonLat, convertDegreeToMatrix, convertMatrixToDegree, convertMeterToFeet, } from "../node/Convert.js";
+import { AeroflyMatrix3Float, AeroflyVector3Float, } from "../node/AeroflyTypes.js";
+import { convertFeetToMeter, convertLonLatToVector, convertVectorToLonLat, convertHeadingToOrientation, convertOrientationToHeading, convertMeterToFeet, } from "../node/Convert.js";
 export class AeroflySettingsFlight {
     longitude;
     latitude;
@@ -56,9 +57,9 @@ export class AeroflySettingsFlight {
     }
     static createInCartesian(position, velocity, orientation, additionalAttributes = {}) {
         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;
     }
     /**
@@ -109,17 +110,17 @@ export class AeroflySettingsFlight {
     get velocity() {
         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 new AeroflyVector3Float(Math.cos(heading_rad) * speed, Math.sin(heading_rad) * speed, 0);
     }
     set velocity(velocity) {
         // TODO: implement setting velocity vector and updating speed accordingly
         this.speed_ms = 0;
     }
     get orientation() {
-        return convertDegreeToMatrix(this.heading_degree);
+        return convertHeadingToOrientation(this.heading_degree, this.position);
     }
     set orientation(orientation) {
-        this.heading_degree = convertMatrixToDegree(orientation);
+        this.heading_degree = convertOrientationToHeading(orientation, this.position);
     }
     /**
      * @returns {number} altitude in feet AGL
@@ -141,9 +142,9 @@ export class AeroflySettingsFlight {
     }
     getElement() {
         return new AeroflyConfigurationNode("tmsettings_flight", "flight_setting")
-            .appendChild("vector3_float64", "position", this.position, `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("matrix3_float64", "orientation", this.orientation, `${Math.round(this.heading_degree)}° heading`)
+            .appendChild("vector3_float64", "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.toArray(), `${Math.round(this.speed_kts)} kts`)
+            .appendChild("matrix3_float64", "orientation", this.orientation.toArray(), `${Math.round(this.heading_degree)}° heading`)
             .appendChild("float64", "gear", this.gear)
             .appendChild("float64", "throttle", this.throttle)
             .appendChild("float64", "flaps", this.flaps)

package/dist/dto-flight/AeroflySettingsFlight.test.js

@@ -27,28 +27,6 @@ describe("AeroflySettingsFlight", () => {
         assert.strictEqual(flight.runway, "16L", `Expected runway to be 16L, got ${flight.runway}`);
         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",

package/dist/node/AeroflyTypes.js

@@ -0,0 +1,63 @@
+export class AeroflyVector3Float {
+    x;
+    y;
+    z;
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    normalize() {
+        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) {
+        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);
+    }
+    dot(b) {
+        return this.x * b.x + this.y * b.y + this.z * b.z;
+    }
+    static fromArray(array) {
+        return new this(...array);
+    }
+    toArray() {
+        return [this.x, this.y, this.z];
+    }
+}
+export class AeroflyMatrix3Float {
+    xx;
+    yx;
+    zx;
+    xy;
+    yy;
+    zy;
+    xz;
+    yz;
+    zz;
+    constructor(xx, yx, zx, xy, yy, zy, xz, yz, zz) {
+        this.xx = xx;
+        this.yx = yx;
+        this.zx = zx;
+        this.xy = xy;
+        this.yy = yy;
+        this.zy = zy;
+        this.xz = xz;
+        this.yz = yz;
+        this.zz = zz;
+    }
+    transpose() {
+        return new AeroflyMatrix3Float(this.xx, this.xy, this.xz, this.yx, this.yy, this.yz, this.zx, this.zy, this.zz);
+    }
+    multiplyVector(v) {
+        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) {
+        return new this(...array);
+    }
+    toArray() {
+        return [this.xx, this.yx, this.zx, this.xy, this.yy, this.zy, this.xz, this.yz, this.zz];
+    }
+}

package/dist/node/Convert.js

@@ -1,3 +1,4 @@
+import { AeroflyVector3Float, AeroflyMatrix3Float } from "./AeroflyTypes.js";
 /**
  * @param {number} longitude in degrees
  * @param {number} latitude in degrees
@@ -19,37 +20,35 @@ export function convertLonLatToVector(longitude, latitude, altitude_meter) {
     const x = (N + h) * cosLat * cosLon;
     const y = (N + h) * cosLat * sinLon;
     const z = (N * (1 - e2) + h) * sinLat;
-    return [x, y, z];
+    return new AeroflyVector3Float(x, y, z);
 }
 /**
  * @param {AeroflyVector3Float} coordinates to convert
  * @returns {object} as with longitude, latitude, altitude_meter
  */
 export function convertVectorToLonLat(coordinates) {
-    // TODO: This implementation is not correct
     const f = 1.0 / 298.257223563; // WGS84
     const e2 = 2 * f - f * f;
-    //const lambda = VectorToAngle( coordinates[0], coordinates[1] );
     let lambda = 0;
-    if (coordinates[0] > 0) {
-        if (coordinates[1] < 0) {
-            lambda = 2 * Math.PI + Math.atan(coordinates[1] / coordinates[0]);
+    if (coordinates.x > 0) {
+        if (coordinates.y < 0) {
+            lambda = 2 * Math.PI + Math.atan(coordinates.y / coordinates.x);
         }
         else {
-            lambda = Math.atan(coordinates[1] / coordinates[0]);
+            lambda = Math.atan(coordinates.y / coordinates.x);
         }
     }
-    else if (coordinates[0] < 0) {
-        lambda = Math.PI + Math.atan(coordinates[1] / coordinates[0]);
+    else if (coordinates.x < 0) {
+        lambda = Math.PI + Math.atan(coordinates.y / coordinates.x);
     }
-    else if (coordinates[1] > 0) {
+    else if (coordinates.y > 0) {
         lambda = 0.5 * Math.PI;
     }
     else {
         lambda = 1.5 * Math.PI;
     }
-    const rho = Math.sqrt(coordinates[0] * coordinates[0] + coordinates[1] * coordinates[1]);
-    const phi = Math.atan(coordinates[2] / ((1.0 - e2) * rho));
+    const rho = Math.sqrt(coordinates.x * coordinates.x + coordinates.y * coordinates.y);
+    const phi = Math.atan(coordinates.z / ((1.0 - e2) * rho));
     const longitude = (lambda * 180) / Math.PI;
     const latitude = (phi * 180) / Math.PI;
     const altitude_meter = rho / Math.cos(phi) - 6378137.0 / Math.sqrt(1 - e2 * Math.sin(phi) * Math.sin(phi));
@@ -60,29 +59,61 @@ export function convertVectorToLonLat(coordinates) {
     };
 }
 /**
+ * This method receives a heading in degrees and a position vector, and calculates the orientation matrix.
+ * The orientation matrix is calculated based on the heading and the position of the aircraft.
  * @param {number} heading_degree in deg
+ * @param {AeroflyVector3Float} position as vector
  * @returns {AeroflyMatrix3Float} for Aerofly
  */
-export function convertDegreeToMatrix(heading_degree) {
-    // TODO: This implementation is not correct
+export function convertHeadingToOrientation(heading_degree, position) {
     const theta = heading_degree * (Math.PI / 180); // heading in radians
-    const cosTheta = Math.cos(theta);
     const sinTheta = Math.sin(theta);
-    return [cosTheta, -sinTheta, 0, sinTheta, cosTheta, 0, 0, 0, 1];
+    const cosTheta = Math.cos(theta);
+    // Local ENU frame at this position — mirrors convertOrientationToHeading
+    const east = new AeroflyVector3Float(-position.y, position.x, 0).normalize();
+    const upRaw = new AeroflyVector3Float(position.x, position.y, position.z / (1.0 - 0.00669437999014));
+    const up = upRaw.normalize();
+    const north = up.cross(east).normalize();
+    // Heading -> forward vector in ENU space (sinθ, cosθ, 0), then rotated into world space
+    const forward = new AeroflyVector3Float(east.x * sinTheta + north.x * cosTheta, east.y * sinTheta + north.y * cosTheta, east.z * sinTheta + north.z * cosTheta).normalize();
+    // Complete the right-handed orthonormal basis (x = forward, z = up, y = up × forward)
+    const right = up.cross(forward).normalize();
+    return new AeroflyMatrix3Float(...forward.toArray(), ...right.toArray(), ...up.toArray());
 }
 /**
- * @param {AeroflyMatrix3Float} orientation as Matrxi
+ * This method receives an orientation matrix and a position vector, and calculates the heading in degrees.
+ * The heading is calculated based on the direction of the aircraft in relation to the north direction.
+ * @param {AeroflyMatrix3Float} orientation as matrix
+ * @param {AeroflyVector3Float} position as vector
  * @returns {number} heading in degrees
  * @see https://www.aerofly.com/community/forum/index.php?thread/28025-custom-missions-file-livery-and-parking-position-property/&postID=184313#post184313
  * @see
  */
-export function convertMatrixToDegree(orientation) {
-    // TODO: https://www.aerofly.com/community/forum/index.php?thread/28025-custom-missions-file-livery-and-parking-position-property/&postID=184313#post184313
-    const headingRad = Math.atan2(orientation[3], orientation[0]);
-    let headingDeg = headingRad * (180 / Math.PI);
-    // Normalize to [0, 360)
-    if (headingDeg < 0)
+export function convertOrientationToHeading(orientation, position) {
+    const direction = orientation.multiplyVector(new AeroflyVector3Float(1, 0, 0));
+    return convertDirectionToHeading(direction, position);
+}
+/**
+ * This method receives an orientation matrix and a position vector, and calculates the heading in degrees.
+ * The heading is calculated based on the direction of the aircraft in relation to the north direction.
+ * @param {AeroflyVector3Float} direction as vector
+ * @param {AeroflyVector3Float} position as vector
+ * @returns {number} heading in degrees
+ * @see https://www.aerofly.com/community/forum/index.php?thread/28025-custom-missions-file-livery-and-parking-position-property/&postID=184313#post184313
+ * @see
+ */
+export function convertDirectionToHeading(direction, position) {
+    const east = new AeroflyVector3Float(-position.y, position.x, 0).normalize();
+    let up = position;
+    up.z *= 1.0 / (1.0 - 0.00669437999014); // WGS84
+    up = up.normalize();
+    const north = up.cross(east).normalize();
+    const m = new AeroflyMatrix3Float(...east.toArray(), ...north.toArray(), ...up.toArray()).transpose();
+    const local_direction = m.multiplyVector(direction);
+    let headingDeg = Math.atan2(local_direction.x, local_direction.y) * (180 / Math.PI);
+    if (headingDeg < 0) {
         headingDeg += 360;
+    }
     return headingDeg;
 }
 /**

package/dist/node/Convert.test.js

@@ -1,6 +1,7 @@
 import { describe, it } from "node:test";
 import { strict as assert } from "node:assert";
-import { convertDegreeToMatrix, convertFeetToMeter, convertLonLatToVector, convertMatrixToDegree, convertMeterToFeet, convertVectorToLonLat, } from "./Convert.js";
+import { convertHeadingToOrientation, convertFeetToMeter, convertLonLatToVector, convertOrientationToHeading, convertMeterToFeet, convertVectorToLonLat, } from "./Convert.js";
+import { AeroflyMatrix3Float, AeroflyVector3Float } from "./AeroflyTypes.js";
 describe("Convert", () => {
     it("should convert feet to meters correctly", () => {
         const feet = 1000;
@@ -24,27 +25,56 @@ describe("Convert", () => {
         assert.strictEqual(lonLat.longitude.toFixed(4), expectedLongitude.toFixed(4), `Expected longitude to be ${expectedLongitude.toFixed(4)}, got ${lonLat.longitude.toFixed(4)}`);
         assert.strictEqual(lonLat.latitude.toFixed(4), expectedLatitude.toFixed(4), `Expected latitude to be ${expectedLatitude.toFixed(4)}, got ${lonLat.latitude.toFixed(4)}`);
     });
-    it("should convert heading degree to orientation matrix and back correctly", () => {
-        const orientationMatrix = [0, -1, 0, 1, 0, 0, 0, 0, 1];
-        const expectedHeadingDegree = 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)}`);
-    });
-    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);
-        const actualHeadingDegree = convertMatrixToDegree(orientationMatrix);
-        assert.strictEqual(actualHeadingDegree.toFixed(4), expectedHeadingDegree.toFixed(4), `Expected heading degree to be ${expectedHeadingDegree.toFixed(4)}, got ${actualHeadingDegree.toFixed(4)}`);
+    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 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,
+            },
+        ];
+        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 = [
-            -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);
+        }
     });
 });

package/docs/flight.json

@@ -8,7 +8,7 @@
   "flightSetting": {
     "longitude": -107.90107635928504,
     "latitude": 37.95381167941058,
-    "heading_degree": 117.3584840119476,
+    "heading_degree": 195.1999966628333,
     "speed_kts": 0,
     "gear": 1,
     "throttle": 0,

package/docs/flight.mcf

@@ -9,7 +9,7 @@
         <[tmsettings_flight][flight_setting][]
             <[vector3_float64][position][-1548480.2914129882 -4793879.340758891 3903103.47375716]> // Lon -107.901076, Lat 37.953812, 9073 ft
             <[vector3_float64][velocity][0 0 0]> // 0 kts
-            <[matrix3_float64][orientation][-0.4595563612734764 -0.8881486085183504 0 0.8881486085183504 -0.4595563612734764 0 0 0 1]> // 117° heading
+            <[matrix3_float64][orientation][-0.4319264385609424 -0.48418840234394955 -0.7609212460614266 0.8687335474152472 -0.45006838984503683 -0.20673767933692305 -0.24236661335130477 -0.7503332829469246 0.6150271451202048]> // 195° heading
             <[float64][gear][1]>
             <[float64][throttle][0]>
             <[float64][flaps][0]>

package/docs/flight.xml

@@ -9,7 +9,7 @@
         <flight_setting type="tmsettings_flight">
             <position type="vector3_float64">-1548480.2914129882 -4793879.340758891 3903103.47375716</position> <!-- Lon -107.901076, Lat 37.953812, 9073 ft -->
             <velocity type="vector3_float64">0 0 0</velocity> <!-- 0 kts -->
-            <orientation type="matrix3_float64">-0.4595563612734764 -0.8881486085183504 0 0.8881486085183504 -0.4595563612734764 0 0 0 1</orientation> <!-- 117° heading -->
+            <orientation type="matrix3_float64">-0.4319264385609424 -0.48418840234394955 -0.7609212460614266 0.8687335474152472 -0.45006838984503683 -0.20673767933692305 -0.24236661335130477 -0.7503332829469246 0.6150271451202048</orientation> <!-- 195° heading -->
             <gear type="float64">1</gear>
             <throttle type="float64">0</throttle>
             <flaps type="float64">0</flaps>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fboes/aerofly-custom-missions",
-  "version": "1.13.0",
+  "version": "1.13.1",
   "description": "Builder for Aerofly FS4 Custom Missions Files",
   "main": "dist/index.js",
   "scripts": {