@woosh/meep-engine 2.165.6 → 2.166.0

package/src/engine/knowledge/database/StaticKnowledgeDatabase.d.ts

@@ -10,7 +10,7 @@ export class StaticKnowledgeDatabase {
      *
      * @type {ObservedEnum<StaticKnowledgeState>}
      */
-    __state: ObservedEnum<StaticKnowledgeState>;
+    __state: any;
     /**
      *
      * @type {StaticKnowledgeDataTableDescriptor[]}
@@ -38,7 +38,7 @@ export class StaticKnowledgeDatabase {
      * @param {string} id
      * @returns {StaticKnowledgeDataTableDescriptor|undefined}
      */
-    getDescriptorById<T>(id: string): StaticKnowledgeDataTableDescriptor<any> | undefined;
+    getDescriptorById<T>(id: string): StaticKnowledgeDataTableDescriptor | undefined;
     /**
      * @template T
      * @param {string} id
@@ -98,6 +98,5 @@ export class StaticKnowledgeDatabase {
     isStaticKnowledgeDatabase: boolean;
     #private;
 }
-import ObservedEnum from "../../../core/model/ObservedEnum.js";
 import { StaticKnowledgeDataTableDescriptor } from "./StaticKnowledgeDataTableDescriptor.js";
 //# sourceMappingURL=StaticKnowledgeDatabase.d.ts.map

package/src/engine/knowledge/database/StaticKnowledgeDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticKnowledgeDatabase.d.ts","sourceRoot":"","sources":["../../../../../src/engine/knowledge/database/StaticKnowledgeDatabase.js"],"names":[],"mappings":"mCAWU,MAAM;;;;;;;AAShB;IAEI;;;OAGG;IACH,SAFU,aAAa,oBAAoB,CAAC,CAEmC;IAG/E;;;;OAIG;IACH,gBAAa;IAQb;;;OAGG;IACH,qCAEC;IAGD;;OAEG;IACH,cAUC;IAED;;;;;OAKG;IACH,QAJW,MAAM,QACN,MAAM,yCAiChB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,0CAAmC,SAAS,CAkBxD;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,gCAA4B,SAAS,CAUjD;IAGD;;;OAGG;IACH,wBAcC;IAED;;;;OAIG;IACH,qDAiBC;IAGD;;;;;;OAMG;IACH,qBAQC;IAED;;;;;OAKG;IACH,mEAiBC;IAED;;;;;;;OAOG;IACH,qBAeC;IAED;;;;;;OAMG;IACH,mBAIC;IAED;;;;;OAKG;IACH,mEAmCC;IAGL,mCAA2D;;CAF1D;yBAnTwB,qCAAqC;mDAIX,yCAAyC"}
+{"version":3,"file":"StaticKnowledgeDatabase.d.ts","sourceRoot":"","sources":["../../../../../src/engine/knowledge/database/StaticKnowledgeDatabase.js"],"names":[],"mappings":"mCAWU,MAAM;;;;;;;AAShB;IAEI;;;OAGG;IACH,aAA+E;IAG/E;;;;OAIG;IACH,gBAAa;IAQb;;;OAGG;IACH,qCAEC;IAGD;;OAEG;IACH,cAUC;IAED;;;;;OAKG;IACH,QAJW,MAAM,QACN,MAAM,yCAiChB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,kCAAkC,GAAC,SAAS,CAkBxD;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,gCAA4B,SAAS,CAUjD;IAGD;;;OAGG;IACH,wBAcC;IAED;;;;OAIG;IACH,qDAiBC;IAGD;;;;;;OAMG;IACH,qBAQC;IAED;;;;;OAKG;IACH,mEAiBC;IAED;;;;;;;OAOG;IACH,qBAeC;IAED;;;;;;OAMG;IACH,mBAIC;IAED;;;;;OAKG;IACH,mEAmCC;IAGL,mCAA2D;;CAF1D;mDA/SkD,yCAAyC"}

package/src/engine/navigation/ecs/components/InterpolationType.d.ts

@@ -1,4 +1,8 @@
-export enum InterpolationType {
-    Linear = 1,
-    CatmullRom = 3
-}
+export type InterpolationType = number;
+export namespace InterpolationType {
+    let Zero: number;
+    let Linear: number;
+    let Second: number;
+    let CatmullRom: number;
+}
+//# sourceMappingURL=InterpolationType.d.ts.map

package/src/engine/navigation/ecs/components/Path.d.ts

@@ -1,47 +1,170 @@
-import Vector3 from "../../../../core/geom/Vector3";
-import {InterpolationType} from "./InterpolationType";
-
-export default class Path {
-    public interpolation: InterpolationType
-    /**
-     * Absolute length of the path
-     */
-    public readonly length: number
-
-    public isEmpty(): boolean
-
-    public reverse(): void
-
-    public clear(): void
-
-    /**
-     * Number of points that make up this path
-     */
-    public getPointCount(): number
-
-    public setPointCount(v: number): void
-
-    public removePoint(index: number): boolean
-
-    public getPosition(index: number, result: Vector3): void;
-
-    public setPosition(index: number, x: number, y: number, z: number): void
-
-    public insertPoint(index: number, x: number, y: number, z: number): void
-
-    public computeLength(): number
-
-    public sample(result: Vector3, offset: number, interpolation?: InterpolationType): boolean
-
-    find_index_and_normalized_distance(result:ArrayLike<number>, absolute_distance:number):boolean
-
-    public copy(other: Path): void
-
-    public clone(): Path
-
-    public toJSON(): any
-
-    public fromJSON(json: any): void
-
-    getLowIndexOfNearestPoint(reference: Vector3): number
-}
+export default Path;
+declare class Path {
+    static fromJSON(j: any): Path;
+    /**
+     *
+     * @type {AttributeGroupSpec}
+     * @private
+     */
+    private __spec;
+    /**
+     * @readonly
+     * @type {RowFirstTable}
+     * @private
+     */
+    private readonly __data;
+    /**
+     * Now to get in-between values
+     * @type {InterpolationType|number}
+     */
+    interpolation: InterpolationType | number;
+    /**
+     * Absolute length of the path, measured as straight-line distance sum of point pairs
+     * @type {number}
+     * @private
+     */
+    private __length;
+    /**
+     *
+     * @return {boolean}
+     */
+    isEmpty(): boolean;
+    clear(): void;
+    /**
+     *
+     * @return {number}
+     */
+    getPointCount(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    get count(): number;
+    /**
+     *
+     * @param {number} v
+     */
+    setPointCount(v: number): void;
+    /**
+     *
+     * @param {number} index
+     * @returns {boolean}
+     */
+    removePoint(index: number): boolean;
+    /**
+     * Insert an point
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    insertPoint(index: number, x: number, y: number, z: number): void;
+    /**
+     *
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setPosition(index: number, x: number, y: number, z: number): void;
+    /**
+     *
+     * @param {number} index
+     * @param {Vector3} result
+     */
+    getPosition(index: number, result: Vector3): void;
+    /**
+     *
+     * @param {number} index
+     * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} result
+     * @param {number} result_offset
+     */
+    readPositionToArray(index: number, result: ArrayLike<number> | number[] | Float32Array | Float64Array, result_offset: number): void;
+    /**
+     *
+     * @param {number} index
+     * @param {Vector3} v
+     */
+    setPositionFromVector(index: number, v: Vector3): void;
+    /**
+     *
+     * @param {Vector3[]} array
+     */
+    setPositionsFromVectorArray(array: Vector3[]): void;
+    /**
+     * Reverse order of points
+     */
+    reverse(): void;
+    /**
+     *
+     * @param {Path} other
+     */
+    copy(other: Path): void;
+    /**
+     *
+     * @return {Path}
+     */
+    clone(): Path;
+    /**
+     * Get low index of a point that makes up a line segment closest to the reference point
+     * @param {Vector3} reference
+     * @returns {number}
+     */
+    getLowIndexOfNearestPoint(reference: Vector3): number;
+    /**
+     * Read position along the path at a given 1D offset
+     * @param {Vector3} result
+     * @param {number} offset
+     * @returns {boolean} true while `offset` lies within the path (a genuine interpolated point was
+     * produced); false once `offset` is at or beyond the end (the result is clamped to the last point)
+     * or the path is empty
+     */
+    sample_linear(result: Vector3, offset: number): boolean;
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} absolute_distance absolute distance along the path
+     * @returns {boolean}
+     */
+    find_index_and_normalized_distance(result: number[], absolute_distance: number): boolean;
+    /**
+     *
+     * @param {Vector3} result
+     * @param {number} offset
+     * @returns {boolean}
+     */
+    sample_catmull_rom(result: Vector3, offset: number): boolean;
+    /**
+     *
+     * @param {Vector3} result
+     * @param {number} offset absolute distance offset along the path
+     * @param {InterpolationType} [interpolation=this.interpolation]
+     * @returns {boolean} true while `offset` lies within the path; false once it is clamped to the end
+     * (offset >= length) or the path is empty
+     */
+    sample(result: Vector3, offset: number, interpolation?: InterpolationType): boolean;
+    toString(): string;
+    toJSON(): {
+        points: any[];
+        rowSize: number;
+    };
+    fromJSON({ points, rowSize }: {
+        points?: any[];
+        rowSize?: number;
+    }): void;
+    /**
+     *
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    computeLength(): number;
+}
+declare namespace Path {
+    let typeName: string;
+}
+import { InterpolationType } from "./InterpolationType.js";
+//# sourceMappingURL=Path.d.ts.map

package/src/engine/navigation/ecs/components/Path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/Path.js"],"names":[],"mappings":";AAyDA;IAqcI,8BAMC;IAzcG;;;;OAIG;IACH,eAOC;IAED;;;;OAIG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,eAFU,iBAAiB,GAAC,MAAM,CAEW;IAE7C;;;;OAIG;IACH,iBAAkB;IAGtB;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cAEC;IAED;;;OAGG;IACH,iBAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,QAkBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAenB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,yBAWhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,UACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBACpD,MAAM,QAYhB;IAED;;;;OAIG;IACH,6BAHW,MAAM,oBAMhB;IAED;;;OAGG;IACH,mCAFW,SAAS,QAYnB;IAED;;OAEG;IACH,gBAEC;IAED;;;OAGG;IACH,YAFW,IAAI,QAMd;IAED;;;OAGG;IACH,SAFY,IAAI,CAQf;IAED;;;;OAIG;IACH,+CAFa,MAAM,CA0ClB;IAED;;;;;OAKG;IACH,uCAHW,MAAM,GACJ,OAAO,CA0BnB;IAED;;;;;OAKG;IACH,2CAJW,MAAM,EAAE,qBACR,MAAM,GACJ,OAAO,CAkDnB;IAED;;;;;OAKG;IACH,4CAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,gCAJW,MAAM,kBACN,iBAAiB,GACf,OAAO,CAWnB;IAED,mBAEC;IAED;;;MAaC;IAUD;;;aAcC;IAED;;;OAGG;IACH,qBAYC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAsClB;CAEJ;;;;kCAlkBiC,wBAAwB"}
+{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/Path.js"],"names":[],"mappings":";AAyDA;IA2cI,8BAMC;IA/cG;;;;OAIG;IACH,eAOC;IAED;;;;OAIG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,eAFU,iBAAiB,GAAC,MAAM,CAEW;IAE7C;;;;OAIG;IACH,iBAAkB;IAGtB;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cAEC;IAED;;;OAGG;IACH,iBAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,QAkBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAenB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,yBAWhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,UACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBACpD,MAAM,QAYhB;IAED;;;;OAIG;IACH,6BAHW,MAAM,oBAMhB;IAED;;;OAGG;IACH,mCAFW,SAAS,QAYnB;IAED;;OAEG;IACH,gBAEC;IAED;;;OAGG;IACH,YAFW,IAAI,QAMd;IAED;;;OAGG;IACH,SAFY,IAAI,CAQf;IAED;;;;OAIG;IACH,+CAFa,MAAM,CA0ClB;IAED;;;;;;;OAOG;IACH,uCALW,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;OAKG;IACH,2CAJW,MAAM,EAAE,qBACR,MAAM,GACJ,OAAO,CAkDnB;IAED;;;;;OAKG;IACH,4CAHW,MAAM,GACJ,OAAO,CAwCnB;IAED;;;;;;;OAOG;IACH,gCALW,MAAM,kBACN,iBAAiB,GACf,OAAO,CAYnB;IAED,mBAEC;IAED;;;MAaC;IAUD;;;aAcC;IAED;;;OAGG;IACH,qBAYC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAsClB;CAEJ;;;;kCAxkBiC,wBAAwB"}

package/src/engine/navigation/ecs/components/Path.js

@@ -342,7 +342,9 @@ class Path {
      * Read position along the path at a given 1D offset
      * @param {Vector3} result
      * @param {number} offset
-     * @returns {boolean}
+     * @returns {boolean} true while `offset` lies within the path (a genuine interpolated point was
+     * produced); false once `offset` is at or beyond the end (the result is clamped to the last point)
+     * or the path is empty
      */
     sample_linear(result, offset) {
 
@@ -366,7 +368,9 @@ class Path {
             lerp(scratch_v3_a[1], scratch_v3_b[1], t),
             lerp(scratch_v3_a[2], scratch_v3_b[2], t),
         )
-        return (t < 0 && index_next !== max_index);
+
+        // false once the offset is clamped to the last point (offset >= length); true while inside the path
+        return index !== max_index;
 
     }
 
@@ -468,7 +472,8 @@ class Path {
 
         result.fromArray(scratch_array_4, 0);
 
-        return (t < 0 && i1 !== max_index);
+        // false once the offset is clamped to the last point (offset >= length); true while inside the path
+        return i1 !== max_index;
     }
 
     /**
@@ -476,7 +481,8 @@ class Path {
      * @param {Vector3} result
      * @param {number} offset absolute distance offset along the path
      * @param {InterpolationType} [interpolation=this.interpolation]
-     * @returns {boolean}
+     * @returns {boolean} true while `offset` lies within the path; false once it is clamped to the end
+     * (offset >= length) or the path is empty
      */
     sample(result, offset, interpolation = this.interpolation) {
         switch (interpolation) {

package/src/engine/navigation/ecs/components/PathEvents.d.ts

@@ -1,6 +1,8 @@
-export enum PathEvents {
-    Changed = '@ecd-component-Path/changed',
-    PointAdded = "@ecd-component-Path/point-added",
-    PointRemoved = "@ecd-component-Path/point-removed",
-    PointChanged = "@ecd-component-Path/point-changes"
-}
+export type PathEvents = string;
+export namespace PathEvents {
+    let Changed: string;
+    let PointAdded: string;
+    let PointRemoved: string;
+    let PointChanged: string;
+}
+//# sourceMappingURL=PathEvents.d.ts.map

package/src/engine/navigation/ecs/components/PathSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class PathSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof Path;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/navigation/ecs/components/PathSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/PathSerializationAdapter.js"],"names":[],"mappings":"AAOA;;IAEI,mBAAa;IACb,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,IAAI,QAkBd;IAED;;;;OAIG;IACH,yCAFW,IAAI,QAkBd;CACJ;gDAxD+C,gEAAgE;iBAC/F,WAAW"}
+{"version":3,"file":"PathSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/PathSerializationAdapter.js"],"names":[],"mappings":"AAOA;;IAEI,mBAAa;IAGb;;;;OAIG;IACH,uCAFW,IAAI,QAkBd;IAED;;;;OAIG;IACH,yCAFW,IAAI,QAkBd;CACJ;gDAxD+C,gEAAgE;iBAC/F,WAAW"}

package/src/engine/navigation/ecs/path_following/PathFollower.d.ts

@@ -1,45 +1,85 @@
-import Vector1 from "../../../../core/geom/Vector1";
-import {PathFollowerFlags} from "./PathFollowerFlags";
-
-export default class PathFollower {
-    /**
-     * Movement speed along the path in world units per second
-     */
-    readonly speed: Vector1
-
-    /**
-     *
-     * Speed at which path follower can adjust rotation in Rad/s
-     */
-    readonly rotationSpeed: Vector1
-
-    /**
-     *
-     * Absolute position along the path
-     */
-    position: number
-
-    flags: number
-
-    /**
-     *
-     * Maximum distance that the follower can move along the path in a single step
-     */
-    maxMoveDistance: number
-
-    public setFlag(flag: PathFollowerFlags | number): void
-
-    public clearFlag(flag: PathFollowerFlags | number): void
-
-    public writeFlag(flag: PathFollowerFlags | number, value: boolean): void
-
-    public getFlag(flag: PathFollowerFlags | number): boolean
-
-    public toJSON(): any
-
-    public fromJSON(json: any): void
-
-    static typeName: string
-
-    static fromJSON(json: any): PathFollower
-}
+export default PathFollower;
+declare class PathFollower {
+    /**
+     *
+     * @param json
+     * @returns {PathFollower}
+     */
+    static fromJSON(json: any): PathFollower;
+    /**
+     * Movement speed along the path in world units per second
+     * @type {Vector1}
+     */
+    speed: Vector1;
+    /**
+     * Speed at which path follower can adjust rotation in Rad/s
+     * @type {Vector1}
+     */
+    rotationSpeed: Vector1;
+    /**
+     *
+     * @type {number}
+     */
+    flags: number;
+    /**
+     * Maximum distance that the follower can move along the path in a single step
+     * @type {number}
+     */
+    maxMoveDistance: number;
+    /**
+     * Absolute position along the path
+     * @type {number}
+     */
+    position: number;
+    get rotationAlignment(): void;
+    get positionWriting(): void;
+    set active(arg: boolean);
+    get active(): boolean;
+    set lock(arg: boolean);
+    get lock(): boolean;
+    /**
+     *
+     * @param {number|PathFollowerFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag: number | PathFollowerFlags): void;
+    /**
+     *
+     * @param {number|PathFollowerFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag: number | PathFollowerFlags): void;
+    /**
+     *
+     * @param {number|PathFollowerFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag: number | PathFollowerFlags, value: boolean): void;
+    /**
+     *
+     * @param {number|PathFollowerFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | PathFollowerFlags): boolean;
+    toJSON(): {
+        active: boolean;
+        loop: boolean;
+        writePositionX: boolean;
+        writePositionY: boolean;
+        writePositionZ: boolean;
+        writeRotationX: boolean;
+        writeRotationY: boolean;
+        writeRotationZ: boolean;
+        speed: number;
+        rotationSpeed: number;
+        position: number;
+        maxMoveDistance: number;
+    };
+    fromJSON(json: any): void;
+}
+declare namespace PathFollower {
+    let typeName: string;
+}
+import Vector1 from "../../../../core/geom/Vector1.js";
+import { PathFollowerFlags } from "./PathFollowerFlags.js";
+//# sourceMappingURL=PathFollower.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowerEventType.d.ts

@@ -1,3 +1,5 @@
-export enum PathFollowerEventType {
-    EndReached = "path-end-reached"
-}
+export type PathFollowerEventType = string;
+export namespace PathFollowerEventType {
+    let EndReached: string;
+}
+//# sourceMappingURL=PathFollowerEventType.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowerFlags.d.ts

@@ -1,20 +1,14 @@
-export enum PathFollowerFlags {
-    Active = 1,
-    Locked = 2,
-    Loop = 4,
-    Finished = 8,
-
-    /**
-     * On which axis to write position
-     */
-    WritePositionX = 16,
-    WritePositionY = 32,
-    WritePositionZ = 64,
-
-    /**
-     * On which axis to write rotation
-     */
-    WriteRotationX = 128,
-    WriteRotationY = 256,
-    WriteRotationZ = 512,
-}
+export type PathFollowerFlags = any;
+export namespace PathFollowerFlags {
+    let Active: number;
+    let Locked: number;
+    let Loop: number;
+    let Finished: number;
+    let WritePositionX: number;
+    let WritePositionY: number;
+    let WritePositionZ: number;
+    let WriteRotationX: number;
+    let WriteRotationY: number;
+    let WriteRotationZ: number;
+}
+//# sourceMappingURL=PathFollowerFlags.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class PathFollowerSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof PathFollower;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowerSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,2BAAqB;IACrB,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,YAAY,QAUtB;IAED;;;;OAIG;IACH,yCAFW,YAAY,QAUtB;CACJ;gDArC+C,gEAAgE;yBACvF,mBAAmB"}
+{"version":3,"file":"PathFollowerSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,2BAAqB;IAGrB;;;;OAIG;IACH,uCAFW,YAAY,QAUtB;IAED;;;;OAIG;IACH,yCAFW,YAAY,QAUtB;CACJ;gDArC+C,gEAAgE;yBACvF,mBAAmB"}

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts

@@ -1,6 +1,31 @@
-import {System} from "../../../ecs/System";
-import PathFollower from "./PathFollower";
-
-export default class PathFollowingSystem extends System<PathFollower> {
-
-}
+export default PathFollowingSystem;
+declare class PathFollowingSystem extends System<any> {
+    constructor();
+    dependencies: (typeof PathFollower)[];
+    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof PathFollower> | ResourceAccessSpecification<typeof Path>)[];
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __time_delta;
+    /**
+     *
+     * @param {PathFollower} pathFollower
+     * @param {Transform} transform
+     * @param {Path} path
+     * @param {number} entity Entity ID
+     */
+    __visit_entity(pathFollower: PathFollower, transform: Transform, path: Path, entity: number): void;
+    /**
+     *
+     * @param {number} timeDelta Time in seconds
+     */
+    update(timeDelta: number): void;
+}
+import { System } from '../../../ecs/System.js';
+import PathFollower from './PathFollower.js';
+import { Transform } from '../../../ecs/transform/Transform.js';
+import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
+import Path from '../components/Path.js';
+//# sourceMappingURL=PathFollowingSystem.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAwHA;IACI,cAiBC;IAdG,sCAAkC;IAElC,iKAIC;IAED;;;;OAIG;IACH,qBAAqB;IAGzB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,SAAS,QACT,IAAI,UACJ,MAAM,QAuBhB;CAgBJ;uBAnLsB,wBAAwB;yBAGtB,mBAAmB;0BAFlB,qCAAqC;4CAFnB,uDAAuD;iBAGlF,uBAAuB"}
+{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAwHA;IACI,cAiBC;IAdG,sCAAkC;IAElC,iKAIC;IAED;;;;OAIG;IACH,qBAAqB;IAGzB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,SAAS,QACT,IAAI,UACJ,MAAM,QAuBhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAWhB;CACJ;uBAnLsB,wBAAwB;yBAGtB,mBAAmB;0BAFlB,qCAAqC;4CAFnB,uDAAuD;iBAGlF,uBAAuB"}

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.js

@@ -48,7 +48,7 @@ function performStep(pathFollower, path, transform, timeDelta) {
         const next_offset = pathFollower.position + stepDistance;
         const next_offset_truncated = next_offset % path_length;
 
-        if (next_offset > path_length && !pathFollower.getFlag(PathFollowerFlags.Loop)) {
+        if (next_offset >= path_length && !pathFollower.getFlag(PathFollowerFlags.Loop)) {
             // we're not looping
             remainingDistance = 0;
             path.sample(nextPosition, path_length);

package/src/engine/network/adapters/TransformReplicationAdapter.d.ts

@@ -20,7 +20,6 @@
 export class TransformReplicationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof Transform;
-    version: number;
     /**
      * @param {BinaryBuffer} buffer
      * @param {Transform} value

package/src/engine/network/adapters/TransformReplicationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformReplicationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformReplicationAdapter.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,wBAAkB;IAClB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,SAAS,QAoBnB;IAED;;;OAGG;IACH,yCAFW,SAAS,QAmBnB;CACJ;gDAlF+C,6DAA6D;0BACnF,kCAAkC"}
+{"version":3,"file":"TransformReplicationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformReplicationAdapter.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,wBAAkB;IAGlB;;;OAGG;IACH,uCAFW,SAAS,QAoBnB;IAED;;;OAGG;IACH,yCAFW,SAAS,QAmBnB;CACJ;gDAlF+C,6DAA6D;0BACnF,kCAAkC"}

package/src/engine/network/ecs/NetworkSystem.d.ts

@@ -29,7 +29,7 @@
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export class NetworkSystem extends System<any, any, any, any, any> {
+export class NetworkSystem extends System<any> {
     /**
      * @param {NetworkPeer} peer
      */

package/src/engine/network/ecs/serialization/NetworkIdentitySerializationAdapter.d.ts

@@ -23,7 +23,6 @@ export const MAX_OWNER_PEER_ID: number;
 export class NetworkIdentitySerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof NetworkIdentity;
-    version: number;
     /**
      * @param {BinaryBuffer} buffer
      * @param {NetworkIdentity} value

package/src/engine/network/ecs/serialization/NetworkIdentitySerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkIdentitySerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/ecs/serialization/NetworkIdentitySerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;;;;;;;;;;GAYG;AACH;;IAEI,8BAAwB;IACxB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,eAAe,QAmBzB;IAED;;;OAGG;IACH,yCAFW,eAAe,QAMzB;CACJ;gDA/D+C,gEAAgE;gCAChF,kCAAkC"}
+{"version":3,"file":"NetworkIdentitySerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/ecs/serialization/NetworkIdentitySerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;;;;;;;;;;GAYG;AACH;;IAEI,8BAAwB;IAGxB;;;OAGG;IACH,uCAFW,eAAe,QAmBzB;IAED;;;OAGG;IACH,yCAFW,eAAe,QAMzB;CACJ;gDA/D+C,gEAAgE;gCAChF,kCAAkC"}

package/src/engine/options/Option.d.ts

@@ -9,9 +9,9 @@ export class Option extends OptionAbstract {
      */
     constructor(id: string, read: Function, write?: Function, settings?: object);
     on: {
-        written: Signal<any, any, any, any, any, any, any, any>;
-        writeFailed: Signal<any, any, any, any, any, any, any, any>;
-        settingsUpdated: Signal<any, any, any, any, any, any, any, any>;
+        written: Signal;
+        writeFailed: Signal;
+        settingsUpdated: Signal;
     };
     read: Function;
     write: (v: any) => any;