pth_to_lyt 1.0.0

package/.prettierrc.json

@@ -0,0 +1,6 @@
+{
+    "endOfLine": "crlf",
+    "semi": true,
+    "singleAttributePerLine": true,
+    "tabWidth": 4
+}

package/dist/core/PTHToLYT.d.ts

@@ -0,0 +1 @@
+export declare function convertPTHtoLYT(pthFolderPath: string, lytFolderPath: string, trackPrefix: string, lytName: string): void;

package/dist/core/PTHToLYT.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPTHtoLYT = convertPTHtoLYT;
+const PTH_parser_1 = require("input/PTH.parser");
+const PTH_reader_1 = require("input/PTH.reader");
+const LYT_transform_1 = require("output/LYT.transform");
+const LYT_writer_1 = require("output/LYT.writer");
+function convertPTHtoLYT(pthFolderPath, lytFolderPath, trackPrefix, lytName) {
+    const pthPath = `${pthFolderPath}/${trackPrefix}.pth`;
+    const lytPath = `${lytFolderPath}/${trackPrefix}_${lytName}.lyt`;
+    const raw = (0, PTH_reader_1.readPTH)(pthPath);
+    const data = (0, PTH_parser_1.parserPTH)(raw);
+    const objectArray = (0, LYT_transform_1.transformLYT)(data.mainNodes, data.numberNodes);
+    (0, LYT_writer_1.writeLYT)(lytPath, objectArray);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { convertPTHtoLYT } from "./core/PTHToLYT";
+export { calculateDriveLimits, calculateHalfWidth, calculateHeading, calculateMidPoint, transformLYT, transformLYTObjectPosition, } from "./output/LYT.transform";

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLYTObjectPosition = exports.transformLYT = exports.calculateMidPoint = exports.calculateHeading = exports.calculateHalfWidth = exports.calculateDriveLimits = exports.convertPTHtoLYT = void 0;
+var PTHToLYT_1 = require("./core/PTHToLYT");
+Object.defineProperty(exports, "convertPTHtoLYT", { enumerable: true, get: function () { return PTHToLYT_1.convertPTHtoLYT; } });
+var LYT_transform_1 = require("./output/LYT.transform");
+Object.defineProperty(exports, "calculateDriveLimits", { enumerable: true, get: function () { return LYT_transform_1.calculateDriveLimits; } });
+Object.defineProperty(exports, "calculateHalfWidth", { enumerable: true, get: function () { return LYT_transform_1.calculateHalfWidth; } });
+Object.defineProperty(exports, "calculateHeading", { enumerable: true, get: function () { return LYT_transform_1.calculateHeading; } });
+Object.defineProperty(exports, "calculateMidPoint", { enumerable: true, get: function () { return LYT_transform_1.calculateMidPoint; } });
+Object.defineProperty(exports, "transformLYT", { enumerable: true, get: function () { return LYT_transform_1.transformLYT; } });
+Object.defineProperty(exports, "transformLYTObjectPosition", { enumerable: true, get: function () { return LYT_transform_1.transformLYTObjectPosition; } });

package/dist/input/PTH.parser.d.ts

@@ -0,0 +1,2 @@
+import { PTH } from "./types";
+export declare function parserPTH(buffer: Buffer<ArrayBuffer>): PTH;

package/dist/input/PTH.parser.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parserPTH = parserPTH;
+function parserPTH(buffer) {
+    const systemHeader = readSystemHeader(buffer);
+    const localHeader = readLocalHeader(buffer);
+    const numberNodes = readNumberNodes(buffer);
+    const mainNodes = readMainNodes(buffer, numberNodes);
+    return {
+        systemHeader,
+        localHeader,
+        numberNodes,
+        mainNodes,
+    };
+}
+function readSystemHeader(buffer) {
+    let offset = 0;
+    const magic = buffer.toString("ascii", offset, offset + 6);
+    offset += 6;
+    if (magic !== "SRPATH") {
+        throw new Error("Invalid File (SRPATH not found)");
+    }
+    const version = buffer.readUInt8(offset++);
+    const revision = buffer.readUInt8(offset++);
+    if (version > 0 || revision > 252) {
+        throw new Error("Wrong version");
+    }
+    const flags = buffer.readInt32LE(offset);
+    return {
+        version,
+        revision,
+        flags,
+    };
+}
+function readLocalHeader(buffer) {
+    let offset = 12;
+    const miniRev = buffer.readUInt8(offset++);
+    return {
+        miniRev,
+    };
+}
+function readNumberNodes(buffer) {
+    let offset = 16;
+    const numberNodes = buffer.readUInt16LE(offset);
+    if (numberNodes <= 0)
+        throw new Error("The number of nodes is too low");
+    return numberNodes;
+}
+function readNode(offset, buffer) {
+    const node = {
+        centre: {
+            x: buffer.readInt32LE(offset + 4),
+            y: buffer.readInt32LE(offset + 8),
+        },
+        dir: {
+            x: buffer.readFloatLE(offset + 16),
+            y: buffer.readFloatLE(offset + 20),
+        },
+        limits: {
+            driveLeft: buffer.readFloatLE(offset + 36),
+            driveRight: buffer.readFloatLE(offset + 40),
+        },
+    };
+    return node;
+}
+function readMainNodes(buffer, length) {
+    const startOffset = 56;
+    const nodes = [];
+    for (let i = 0; i < length; i++) {
+        const offset = startOffset + 44 * i;
+        nodes[i] = readNode(offset, buffer);
+    }
+    return nodes;
+}

package/dist/input/PTH.reader.d.ts

@@ -0,0 +1 @@
+export declare function readPTH(path: string): Buffer<ArrayBuffer>;

package/dist/input/PTH.reader.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPTH = readPTH;
+const fs_1 = __importDefault(require("fs"));
+function readPTH(path) {
+    const buffer = fs_1.default.readFileSync(path);
+    if (buffer === undefined) {
+        throw new Error("Invalid File");
+    }
+    return buffer;
+}

package/dist/input/types.d.ts

@@ -0,0 +1,28 @@
+export type PTH = {
+    systemHeader: SystemHeader;
+    localHeader: LocalHeader;
+    numberNodes: number;
+    mainNodes: PTHNode[];
+};
+export type SystemHeader = {
+    version: number;
+    revision: number;
+    flags: number;
+};
+export type LocalHeader = {
+    miniRev: number;
+};
+export type PTHNode = {
+    centre: {
+        x: number;
+        y: number;
+    };
+    dir: {
+        x: number;
+        y: number;
+    };
+    limits: {
+        driveLeft: number;
+        driveRight: number;
+    };
+};

package/dist/input/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/output/LYT.transform.d.ts

@@ -0,0 +1,8 @@
+import { PTHNode } from "input/types";
+import { DriveLimits, LYTObject, Vector2 } from "./types";
+export declare function transformLYT(nodes: PTHNode[], numberNodes: number): LYTObject[];
+export declare function transformLYTObjectPosition(value: number): number;
+export declare function calculateHeading(dirX: number, dirY: number): number;
+export declare function calculateDriveLimits(node: PTHNode): DriveLimits;
+export declare function calculateMidPoint(driveLimits: DriveLimits): Vector2;
+export declare function calculateHalfWidth(driveLimits: DriveLimits, widthOffset?: number): number;

package/dist/output/LYT.transform.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLYT = transformLYT;
+exports.transformLYTObjectPosition = transformLYTObjectPosition;
+exports.calculateHeading = calculateHeading;
+exports.calculateDriveLimits = calculateDriveLimits;
+exports.calculateMidPoint = calculateMidPoint;
+exports.calculateHalfWidth = calculateHalfWidth;
+const constants_1 = require("./constants");
+// LFS NOTATION
+// 0 = world y axis direction
+// LYT NOTATION
+// 128 : heading of zero
+// 192 : heading of 90 degrees
+// 0   : heading of 180 degrees
+// 64  : heading of -90 degrees
+function transformLYT(nodes, numberNodes) {
+    const ZBYTE = 240;
+    const CHECKPOINT_INDEX = 252;
+    const FIRST_CHECKPOINT_FLAG = 0x01;
+    const MAX_NODE = 180;
+    const objectArray = [];
+    const length = numberNodes < MAX_NODE ? numberNodes : MAX_NODE;
+    const gap = numberNodes / length;
+    for (let i = 0; i < length; i++) {
+        const nodeIndex = Math.round(gap * i);
+        const node = nodes[nodeIndex];
+        const heading = calculateHeading(node.dir.x, node.dir.y);
+        const driveLimits = calculateDriveLimits(node);
+        const halfWidth = calculateHalfWidth(driveLimits);
+        const midPoint = calculateMidPoint(driveLimits);
+        const lytObjectX = transformLYTObjectPosition(midPoint.x);
+        const lytObjectY = transformLYTObjectPosition(midPoint.y);
+        objectArray.push({
+            x: lytObjectX,
+            y: lytObjectY,
+            z: ZBYTE,
+            flags: (halfWidth << 2) | FIRST_CHECKPOINT_FLAG,
+            index: CHECKPOINT_INDEX,
+            heading: heading,
+        });
+    }
+    return objectArray;
+}
+function transformLYTObjectPosition(value) {
+    return Math.round(value / constants_1.SCALAR_FACTOR);
+}
+function calculateHeading(dirX, dirY) {
+    const angleRadians = Math.atan2(dirY, dirX);
+    const angleDegrees = angleRadians * (180 / Math.PI);
+    //"Heading represents 360 degrees in 256 values."
+    const heading = Math.round(((angleDegrees - 90 + 180) * 256) / 360) & 0xff;
+    return heading;
+}
+function calculateDriveLimits(node) {
+    // "A node is represented by a line perpendicular to its direction."
+    // perpendicular = 90 degrees
+    // rotate 90 degrees to left for find drive limits direct
+    const perpendicularX = -node.dir.y;
+    const perpendicularY = node.dir.x;
+    // driveLeft negative
+    // driveRight positive
+    const left = {
+        x: node.centre.x - perpendicularX * node.limits.driveLeft * constants_1.LFS_METER,
+        y: node.centre.y - perpendicularY * node.limits.driveLeft * constants_1.LFS_METER,
+    };
+    const right = {
+        x: node.centre.x - perpendicularX * node.limits.driveRight * constants_1.LFS_METER,
+        y: node.centre.y - perpendicularY * node.limits.driveRight * constants_1.LFS_METER,
+    };
+    return { left, right };
+}
+function calculateMidPoint(driveLimits) {
+    const x = (driveLimits.right.x + driveLimits.left.x) / 2;
+    const y = (driveLimits.right.y + driveLimits.left.y) / 2;
+    return { x, y };
+}
+// "half width in metres (1 to 31 ...)."
+function calculateHalfWidth(driveLimits, widthOffset = 2) {
+    const distanceX = Math.pow(driveLimits.right.x - driveLimits.left.x, 2);
+    const distanceY = Math.pow(driveLimits.right.y - driveLimits.left.y, 2);
+    const distance = Math.sqrt(distanceX + distanceY);
+    const halfWidth = Math.round(distance / constants_1.LFS_METER / 2 + widthOffset);
+    return halfWidth > 31 ? 31 : halfWidth;
+}

package/dist/output/LYT.writer.d.ts

@@ -0,0 +1,2 @@
+import { LYTObject } from "./types";
+export declare function writeLYT(path: string, objectArray: LYTObject[]): void;

package/dist/output/LYT.writer.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeLYT = writeLYT;
+const fs_1 = __importDefault(require("fs"));
+function writeLYT(path, objectArray) {
+    const bufferHeader = buildBufferHeader(objectArray.length);
+    const bufferObjects = buildBufferLYTObject(objectArray);
+    const bufferList = [bufferHeader, bufferObjects];
+    const buffer = Buffer.concat(bufferList);
+    fs_1.default.writeFileSync(path, buffer);
+}
+function buildBufferHeader(length) {
+    const buffer = Buffer.alloc(12);
+    buffer.write("LFSLYT", 0, "ascii");
+    buffer.writeUInt8(0, 6);
+    buffer.writeUInt8(252, 7);
+    buffer.writeUInt16LE(length, 8);
+    buffer.writeUInt8(0, 10);
+    buffer.writeUInt8(9, 11);
+    return buffer;
+}
+function buildBufferLYTObject(objectArray) {
+    const buffer = Buffer.alloc(8 * objectArray.length);
+    let offset = 0;
+    for (let i = 0; i < objectArray.length; i++) {
+        const object = objectArray[i];
+        buffer.writeInt16LE(object.x, offset);
+        offset += 2;
+        buffer.writeInt16LE(object.y, offset);
+        offset += 2;
+        buffer.writeUInt8(object.z, offset);
+        offset++;
+        buffer.writeUInt8(object.flags, offset);
+        offset++;
+        buffer.writeUInt8(object.index, offset);
+        offset++;
+        buffer.writeUInt8(object.heading, offset);
+        offset++;
+    }
+    return buffer;
+}

package/dist/output/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const LFS_METER: number;
+export declare const LYT_METER: number;
+export declare const SCALAR_FACTOR: number;

package/dist/output/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCALAR_FACTOR = exports.LYT_METER = exports.LFS_METER = void 0;
+exports.LFS_METER = 65536; // 1m
+exports.LYT_METER = 16; // 1m
+exports.SCALAR_FACTOR = exports.LFS_METER / exports.LYT_METER;

package/dist/output/types.d.ts

@@ -0,0 +1,16 @@
+export type LYTObject = {
+    x: number;
+    y: number;
+    z: number;
+    flags: number;
+    index: number;
+    heading: number;
+};
+export type Vector2 = {
+    x: number;
+    y: number;
+};
+export type DriveLimits = {
+    right: Vector2;
+    left: Vector2;
+};

package/dist/output/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "pth_to_lyt",
+    "version": "1.0.0",
+    "main": "dist/main.js",
+    "private": false,
+    "scripts": {
+        "start": "tsx watch src/main.ts",
+        "build": "tsc",
+        "serve:production": "node dist/main.js"
+    },
+    "devDependencies": {
+        "@types/node": "^20.10.5",
+        "prettier": "^3.7.4",
+        "tsx": "^4.7.0",
+        "typescript": "^5.3.3"
+    }
+}

package/src/core/PTHToLYT.ts

@@ -0,0 +1,24 @@
+import { parserPTH } from "input/PTH.parser";
+import { readPTH } from "input/PTH.reader";
+import { PTH } from "input/types";
+import { transformLYT } from "output/LYT.transform";
+import { writeLYT } from "output/LYT.writer";
+import { LYTObject } from "output/types";
+
+export function convertPTHtoLYT(
+    pthFolderPath: string,
+    lytFolderPath: string,
+    trackPrefix: string,
+    lytName: string,
+) {
+    const pthPath: string = `${pthFolderPath}/${trackPrefix}.pth`;
+    const lytPath: string = `${lytFolderPath}/${trackPrefix}_${lytName}.lyt`;
+
+    const raw: Buffer<ArrayBuffer> = readPTH(pthPath);
+    const data: PTH = parserPTH(raw);
+    const objectArray: LYTObject[] = transformLYT(
+        data.mainNodes,
+        data.numberNodes,
+    );
+    writeLYT(lytPath, objectArray);
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export { convertPTHtoLYT } from "./core/PTHToLYT";
+export {
+    calculateDriveLimits,
+    calculateHalfWidth,
+    calculateHeading,
+    calculateMidPoint,
+    transformLYT,
+    transformLYTObjectPosition,
+} from "./output/LYT.transform";

package/src/input/PTH.parser.ts

@@ -0,0 +1,86 @@
+import { PTHNode, LocalHeader, PTH, SystemHeader } from "./types";
+
+export function parserPTH(buffer: Buffer<ArrayBuffer>): PTH {
+    const systemHeader: SystemHeader = readSystemHeader(buffer);
+    const localHeader: LocalHeader = readLocalHeader(buffer);
+    const numberNodes: number = readNumberNodes(buffer);
+    const mainNodes: PTHNode[] = readMainNodes(buffer, numberNodes);
+
+    return {
+        systemHeader,
+        localHeader,
+        numberNodes,
+        mainNodes,
+    };
+}
+
+function readSystemHeader(buffer: Buffer<ArrayBuffer>): SystemHeader {
+    let offset: number = 0;
+    const magic: string = buffer.toString("ascii", offset, offset + 6);
+    offset += 6;
+
+    if (magic !== "SRPATH") {
+        throw new Error("Invalid File (SRPATH not found)");
+    }
+
+    const version: number = buffer.readUInt8(offset++);
+    const revision: number = buffer.readUInt8(offset++);
+
+    if (version > 0 || revision > 252) {
+        throw new Error("Wrong version");
+    }
+
+    const flags: number = buffer.readInt32LE(offset);
+
+    return {
+        version,
+        revision,
+        flags,
+    };
+}
+
+function readLocalHeader(buffer: Buffer<ArrayBuffer>): LocalHeader {
+    let offset: number = 12;
+    const miniRev: number = buffer.readUInt8(offset++);
+
+    return {
+        miniRev,
+    };
+}
+
+function readNumberNodes(buffer: Buffer<ArrayBuffer>): number {
+    let offset: number = 16;
+    const numberNodes = buffer.readUInt16LE(offset);
+    if (numberNodes <= 0) throw new Error("The number of nodes is too low");
+
+    return numberNodes;
+}
+
+function readNode(offset: number, buffer: Buffer<ArrayBuffer>): PTHNode {
+    const node: PTHNode = {
+        centre: {
+            x: buffer.readInt32LE(offset + 4),
+            y: buffer.readInt32LE(offset + 8),
+        },
+        dir: {
+            x: buffer.readFloatLE(offset + 16),
+            y: buffer.readFloatLE(offset + 20),
+        },
+        limits: {
+            driveLeft: buffer.readFloatLE(offset + 36),
+            driveRight: buffer.readFloatLE(offset + 40),
+        },
+    };
+    return node;
+}
+
+function readMainNodes(buffer: Buffer<ArrayBuffer>, length: number): PTHNode[] {
+    const startOffset: number = 56;
+    const nodes: PTHNode[] = [];
+    for (let i: number = 0; i < length; i++) {
+        const offset: number = startOffset + 44 * i;
+        nodes[i] = readNode(offset, buffer);
+    }
+
+    return nodes;
+}

package/src/input/PTH.reader.ts

@@ -0,0 +1,10 @@
+import fs from "fs";
+
+export function readPTH(path: string): Buffer<ArrayBuffer> {
+    const buffer: Buffer<ArrayBuffer> = fs.readFileSync(path);
+    if (buffer === undefined) {
+        throw new Error("Invalid File");
+    }
+
+    return buffer;
+}

package/src/input/types.ts

@@ -0,0 +1,31 @@
+export type PTH = {
+    systemHeader: SystemHeader;
+    localHeader: LocalHeader;
+    numberNodes: number;
+    mainNodes: PTHNode[];
+};
+
+export type SystemHeader = {
+    version: number;
+    revision: number;
+    flags: number;
+};
+
+export type LocalHeader = {
+    miniRev: number;
+};
+
+export type PTHNode = {
+    centre: {
+        x: number;
+        y: number;
+    };
+    dir: {
+        x: number;
+        y: number;
+    };
+    limits: {
+        driveLeft: number;
+        driveRight: number;
+    };
+};

package/src/output/LYT.transform.ts

@@ -0,0 +1,114 @@
+import { LFS_METER, SCALAR_FACTOR } from "./constants";
+import { PTHNode } from "input/types";
+import { DriveLimits, LYTObject, Vector2 } from "./types";
+
+// LFS NOTATION
+// 0 = world y axis direction
+
+// LYT NOTATION
+// 128 : heading of zero
+// 192 : heading of 90 degrees
+// 0   : heading of 180 degrees
+// 64  : heading of -90 degrees
+
+export function transformLYT(
+    nodes: PTHNode[],
+    numberNodes: number,
+): LYTObject[] {
+    const ZBYTE: number = 240;
+    const CHECKPOINT_INDEX: number = 252;
+    const FIRST_CHECKPOINT_FLAG: number = 0x01;
+    const MAX_NODE: number = 180;
+
+    const objectArray: LYTObject[] = [];
+    const length: number = numberNodes < MAX_NODE ? numberNodes : MAX_NODE;
+    const gap: number = numberNodes / length;
+
+    for (let i: number = 0; i < length; i++) {
+        const nodeIndex: number = Math.round(gap * i);
+        const node: PTHNode = nodes[nodeIndex];
+
+        const heading: number = calculateHeading(node.dir.x, node.dir.y);
+        const driveLimits: DriveLimits = calculateDriveLimits(node);
+        const halfWidth: number = calculateHalfWidth(driveLimits);
+        const midPoint: Vector2 = calculateMidPoint(driveLimits);
+
+        const lytObjectX: number = transformLYTObjectPosition(midPoint.x);
+        const lytObjectY: number = transformLYTObjectPosition(midPoint.y);
+
+        objectArray.push({
+            x: lytObjectX,
+            y: lytObjectY,
+            z: ZBYTE,
+            flags: (halfWidth << 2) | FIRST_CHECKPOINT_FLAG,
+            index: CHECKPOINT_INDEX,
+            heading: heading,
+        });
+    }
+
+    return objectArray;
+}
+
+export function transformLYTObjectPosition(value: number): number {
+    return Math.round(value / SCALAR_FACTOR);
+}
+
+export function calculateHeading(dirX: number, dirY: number): number {
+    const angleRadians: number = Math.atan2(dirY, dirX);
+    const angleDegrees: number = angleRadians * (180 / Math.PI);
+    //"Heading represents 360 degrees in 256 values."
+    const heading: number =
+        Math.round(((angleDegrees - 90 + 180) * 256) / 360) & 0xff;
+
+    return heading;
+}
+
+export function calculateDriveLimits(node: PTHNode): DriveLimits {
+    // "A node is represented by a line perpendicular to its direction."
+    // perpendicular = 90 degrees
+    // rotate 90 degrees to left for find drive limits direct
+    const perpendicularX: number = -node.dir.y;
+    const perpendicularY: number = node.dir.x;
+
+    // driveLeft negative
+    // driveRight positive
+    const left = {
+        x: node.centre.x - perpendicularX * node.limits.driveLeft * LFS_METER,
+        y: node.centre.y - perpendicularY * node.limits.driveLeft * LFS_METER,
+    };
+
+    const right = {
+        x: node.centre.x - perpendicularX * node.limits.driveRight * LFS_METER,
+        y: node.centre.y - perpendicularY * node.limits.driveRight * LFS_METER,
+    };
+
+    return { left, right };
+}
+
+export function calculateMidPoint(driveLimits: DriveLimits): Vector2 {
+    const x: number = (driveLimits.right.x + driveLimits.left.x) / 2;
+    const y: number = (driveLimits.right.y + driveLimits.left.y) / 2;
+
+    return { x, y };
+}
+
+// "half width in metres (1 to 31 ...)."
+export function calculateHalfWidth(
+    driveLimits: DriveLimits,
+    widthOffset: number = 2,
+): number {
+    const distanceX: number = Math.pow(
+        driveLimits.right.x - driveLimits.left.x,
+        2,
+    );
+    const distanceY: number = Math.pow(
+        driveLimits.right.y - driveLimits.left.y,
+        2,
+    );
+    const distance: number = Math.sqrt(distanceX + distanceY);
+    const halfWidth: number = Math.round(
+        distance / LFS_METER / 2 + widthOffset,
+    );
+
+    return halfWidth > 31 ? 31 : halfWidth;
+}

package/src/output/LYT.writer.ts

@@ -0,0 +1,51 @@
+import fs from "fs";
+import { LYTObject } from "./types";
+
+export function writeLYT(path: string, objectArray: LYTObject[]) {
+    const bufferHeader: Buffer<ArrayBuffer> = buildBufferHeader(
+        objectArray.length,
+    );
+    const bufferObjects: Buffer<ArrayBuffer> =
+        buildBufferLYTObject(objectArray);
+    const bufferList: Buffer<ArrayBuffer>[] = [bufferHeader, bufferObjects];
+    const buffer: Buffer<ArrayBuffer> = Buffer.concat(bufferList);
+
+    fs.writeFileSync(path, buffer);
+}
+
+function buildBufferHeader(length: number) {
+    const buffer: Buffer<ArrayBuffer> = Buffer.alloc(12);
+
+    buffer.write("LFSLYT", 0, "ascii");
+    buffer.writeUInt8(0, 6);
+    buffer.writeUInt8(252, 7);
+    buffer.writeUInt16LE(length, 8);
+    buffer.writeUInt8(0, 10);
+    buffer.writeUInt8(9, 11);
+
+    return buffer;
+}
+
+function buildBufferLYTObject(objectArray: LYTObject[]) {
+    const buffer: Buffer<ArrayBuffer> = Buffer.alloc(8 * objectArray.length);
+    let offset: number = 0;
+
+    for (let i: number = 0; i < objectArray.length; i++) {
+        const object: LYTObject = objectArray[i];
+
+        buffer.writeInt16LE(object.x, offset);
+        offset += 2;
+        buffer.writeInt16LE(object.y, offset);
+        offset += 2;
+        buffer.writeUInt8(object.z, offset);
+        offset++;
+        buffer.writeUInt8(object.flags, offset);
+        offset++;
+        buffer.writeUInt8(object.index, offset);
+        offset++;
+        buffer.writeUInt8(object.heading, offset);
+        offset++;
+    }
+
+    return buffer;
+}

package/src/output/constants.ts

@@ -0,0 +1,3 @@
+export const LFS_METER: number = 65536; // 1m
+export const LYT_METER: number = 16; // 1m
+export const SCALAR_FACTOR: number = LFS_METER / LYT_METER;

package/src/output/types.ts

@@ -0,0 +1,18 @@
+export type LYTObject = {
+    x: number;
+    y: number;
+    z: number;
+    flags: number;
+    index: number;
+    heading: number;
+};
+
+export type Vector2 = {
+    x: number;
+    y: number;
+};
+
+export type DriveLimits = {
+    right: Vector2;
+    left: Vector2;
+};

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "baseUrl": "./src",
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "strict": true,
+        "declaration": true,
+        "moduleResolution": "Node",
+        "target": "es2015",
+        "module": "commonjs",
+        "skipLibCheck": true,
+        "skipDefaultLibCheck": true,
+        "esModuleInterop": true,
+        "noImplicitAny": true
+    },
+    "ts-node": {
+        "esm": true
+    },
+    "include": ["**/*.ts", "src"],
+    "exclude": ["dist", "node_modules"]
+}