@directivegames/genesys.js 3.1.24

package/dist/src/components/movement/PathMovementComponent.d.ts

@@ -0,0 +1,54 @@
+/**
+ * PathMovementComponent animates a component along a predefined curve.
+ *
+ * It moves the owning SceneComponent along a THREE.Curve at a configurable
+ * speed and supports optional looping or ping-pong behavior. The component can
+ * start automatically and updates both world position and kinematic physics
+ * velocity so physics-aware actors remain in sync. Progress through the path is
+ * tracked internally and can be queried or set directly by callers.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Provide a THREE.Curve via the `path` option at construction time.
+ * - Call `startMovement` and `stopMovement` to control playback.
+ * - Use with kinematic physics bodies when path movement should drive physics.
+ */
+import * as THREE from 'three';
+import { SceneComponent } from '../SceneComponent.js';
+import type { SceneComponentOptions } from '../SceneComponent.js';
+export interface PathMovementOptions extends SceneComponentOptions {
+    /** The path to follow */
+    path: THREE.Curve<THREE.Vector3>;
+    /** The speed of the movement */
+    speed: number;
+    /** The loop mode of the movement */
+    loop: 'NoLoop' | 'Loop' | 'PingPong';
+    /** Whether the movement should start automatically */
+    autoStart: boolean;
+}
+export declare class PathMovementComponent extends SceneComponent<PathMovementOptions> {
+    private path;
+    private speed;
+    private loop;
+    private currentProgress;
+    private autoStart;
+    private rootComponent;
+    private moving;
+    private direction;
+    static get DEFAULT_OPTIONS(): Partial<PathMovementOptions>;
+    constructor(options: PathMovementOptions);
+    beginPlay(): void;
+    endPlay(): void;
+    tickPrePhysics(deltaTime: number): void;
+    private updateProgress;
+    private handleNoLoop;
+    private handleLoop;
+    private handlePingPong;
+    private updatePosition;
+    private updatePhysicsVelocity;
+    tickPostPhysics(deltaTime: number): void;
+    startMovement(): void;
+    stopMovement(): void;
+    isMoving(): boolean;
+    setProgress(progress: number): void;
+    getEditorClassIcon(): string | null;
+}

package/dist/src/components/movement/PathMovementComponent.js

@@ -0,0 +1,211 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var PathMovementComponent_1;
+/**
+ * PathMovementComponent animates a component along a predefined curve.
+ *
+ * It moves the owning SceneComponent along a THREE.Curve at a configurable
+ * speed and supports optional looping or ping-pong behavior. The component can
+ * start automatically and updates both world position and kinematic physics
+ * velocity so physics-aware actors remain in sync. Progress through the path is
+ * tracked internally and can be queried or set directly by callers.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Provide a THREE.Curve via the `path` option at construction time.
+ * - Call `startMovement` and `stopMovement` to control playback.
+ * - Use with kinematic physics bodies when path movement should drive physics.
+ */
+import * as THREE from 'three';
+import { PhysicsVectorParam } from '../../physics/PhysicsEngine.js';
+import { PhysicsMotionType } from '../../physics/PhysicsTypes.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+import { SceneComponent } from '../SceneComponent.js';
+let PathMovementComponent = PathMovementComponent_1 = class PathMovementComponent extends SceneComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...SceneComponent.DEFAULT_OPTIONS,
+            speed: 5,
+            loop: 'NoLoop',
+            autoStart: false,
+        };
+    }
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "speed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "loop", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'NoLoop'
+        });
+        Object.defineProperty(this, "currentProgress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "autoStart", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "rootComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "moving", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "direction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        }); // 1 = forward, -1 = backward (for PingPong)
+        this.path = options.path;
+        this.speed = options.speed ?? PathMovementComponent_1.DEFAULT_OPTIONS.speed;
+        this.loop = options.loop ?? PathMovementComponent_1.DEFAULT_OPTIONS.loop;
+        this.autoStart = options.autoStart ?? PathMovementComponent_1.DEFAULT_OPTIONS.autoStart;
+    }
+    beginPlay() {
+        super.beginPlay();
+        this.rootComponent = this.getActor()?.rootComponent ?? null;
+        if (this.autoStart) {
+            this.startMovement();
+        }
+    }
+    endPlay() {
+        super.endPlay();
+    }
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        if (!this.moving)
+            return;
+        const pathLength = this.path.getLength();
+        if (pathLength === 0)
+            return;
+        this.updateProgress(deltaTime, pathLength);
+        this.updatePosition(deltaTime);
+    }
+    updateProgress(deltaTime, pathLength) {
+        const deltaProgress = (this.speed * deltaTime * this.direction) / pathLength;
+        this.currentProgress += deltaProgress;
+        switch (this.loop) {
+            case 'NoLoop':
+                this.handleNoLoop();
+                break;
+            case 'Loop':
+                this.handleLoop();
+                break;
+            case 'PingPong':
+                this.handlePingPong();
+                break;
+        }
+    }
+    handleNoLoop() {
+        if (this.currentProgress >= 1) {
+            this.currentProgress = 1;
+            this.stopMovement();
+        }
+        else if (this.currentProgress <= 0) {
+            this.currentProgress = 0;
+            this.stopMovement();
+        }
+    }
+    handleLoop() {
+        if (this.currentProgress > 1) {
+            this.currentProgress -= 1;
+        }
+        else if (this.currentProgress < 0) {
+            this.currentProgress += 1;
+        }
+    }
+    handlePingPong() {
+        if (this.currentProgress > 1) {
+            this.currentProgress = 1;
+            this.direction = -1;
+        }
+        else if (this.currentProgress < 0) {
+            this.currentProgress = 0;
+            this.direction = 1;
+        }
+    }
+    updatePosition(deltaTime) {
+        const position = this.path.getPoint(THREE.MathUtils.clamp(this.currentProgress, 0, 1));
+        if (this.rootComponent) {
+            const prev = new THREE.Vector3();
+            this.rootComponent.getWorldPosition(prev);
+            const delta = position.clone().sub(prev);
+            this.rootComponent.addWorldPosition(delta);
+            this.updatePhysicsVelocity(delta, deltaTime);
+        }
+    }
+    updatePhysicsVelocity(delta, deltaTime) {
+        if (!this.rootComponent || !(this.rootComponent instanceof PrimitiveComponent))
+            return;
+        const physicsOptions = this.rootComponent.getPhysicsOptions();
+        if (physicsOptions?.enabled &&
+            (physicsOptions.motionType === PhysicsMotionType.KinematicPositionBased ||
+                physicsOptions.motionType === PhysicsMotionType.KinematicVelocityBased)) {
+            let velocity = [0, 0, 0];
+            if (delta.lengthSq() >= 1e-8) {
+                velocity = [delta.x / deltaTime, delta.y / deltaTime, delta.z / deltaTime];
+                velocity = velocity.map(v => Math.abs(v) < 1e-5 ? 0 : v);
+            }
+            this.rootComponent.setPhysicsVectorParam(PhysicsVectorParam.LinearVelocity, velocity);
+        }
+    }
+    tickPostPhysics(deltaTime) {
+        super.tickPostPhysics(deltaTime);
+    }
+    startMovement() {
+        this.moving = true;
+        this.direction = 1;
+    }
+    stopMovement() {
+        this.moving = false;
+    }
+    isMoving() {
+        return this.moving;
+    }
+    setProgress(progress) {
+        this.currentProgress = THREE.MathUtils.clamp(progress, 0, 1);
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Path';
+    }
+};
+PathMovementComponent = PathMovementComponent_1 = __decorate([
+    EngineClass('PathMovementComponent'),
+    __metadata("design:paramtypes", [Object])
+], PathMovementComponent);
+export { PathMovementComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGF0aE1vdmVtZW50Q29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NvbXBvbmVudHMvbW92ZW1lbnQvUGF0aE1vdmVtZW50Q29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7QUFBQTs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFFL0IsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDbEUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzdELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzlELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQWlCL0MsSUFBTSxxQkFBcUIsNkJBQTNCLE1BQU0scUJBQXNCLFNBQVEsY0FBbUM7SUFVNUUsTUFBTSxLQUFjLGVBQWU7UUFDakMsT0FBTztZQUNMLEdBQUcsY0FBYyxDQUFDLGVBQWU7WUFDakMsS0FBSyxFQUFFLENBQUM7WUFDUixJQUFJLEVBQUUsUUFBUTtZQUNkLFNBQVMsRUFBRSxLQUFLO1NBQ2pCLENBQUM7SUFDSixDQUFDO0lBRUQsWUFBWSxPQUE0QjtRQUN0QyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFuQlQ7Ozs7O1dBQWlDO1FBQ2pDOzs7OztXQUFjO1FBQ2Q7Ozs7bUJBQXVDLFFBQVE7V0FBQztRQUNoRDs7OzttQkFBMEIsQ0FBQztXQUFDO1FBQzVCOzs7O21CQUFxQixLQUFLO1dBQUM7UUFDM0I7Ozs7bUJBQXVDLElBQUk7V0FBQztRQUM1Qzs7OzttQkFBa0IsS0FBSztXQUFDO1FBQ3hCOzs7O21CQUFvQixDQUFDO1dBQUMsQ0FBQyw0Q0FBNEM7UUFhekUsSUFBSSxDQUFDLElBQUksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLEtBQUssSUFBSSx1QkFBcUIsQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDO1FBQzFFLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksSUFBSSx1QkFBcUIsQ0FBQyxlQUFlLENBQUMsSUFBSyxDQUFDO1FBQ3hFLElBQUksQ0FBQyxTQUFTLEdBQUcsT0FBTyxDQUFDLFNBQVMsSUFBSSx1QkFBcUIsQ0FBQyxlQUFlLENBQUMsU0FBUyxDQUFDO0lBQ3hGLENBQUM7SUFFZSxTQUFTO1FBQ3ZCLEtBQUssQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUNsQixJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQyxRQUFRLEVBQUUsRUFBRSxhQUFhLElBQUksSUFBSSxDQUFDO1FBQzVELElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ25CLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUN2QixDQUFDO0lBQ0gsQ0FBQztJQUVlLE9BQU87UUFDckIsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ2xCLENBQUM7SUFFZSxjQUFjLENBQUMsU0FBaUI7UUFDOUMsS0FBSyxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUVoQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU07WUFBRSxPQUFPO1FBRXpCLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDekMsSUFBSSxVQUFVLEtBQUssQ0FBQztZQUFFLE9BQU87UUFFN0IsSUFBSSxDQUFDLGNBQWMsQ0FBQyxTQUFTLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDM0MsSUFBSSxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBRU8sY0FBYyxDQUFDLFNBQWlCLEVBQUUsVUFBa0I7UUFDMUQsTUFBTSxhQUFhLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxHQUFHLFNBQVMsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsVUFBVSxDQUFDO1FBQzdFLElBQUksQ0FBQyxlQUFlLElBQUksYUFBYSxDQUFDO1FBRXRDLFFBQVEsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ2xCLEtBQUssUUFBUTtnQkFDWCxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7Z0JBQ3BCLE1BQU07WUFDUixLQUFLLE1BQU07Z0JBQ1QsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO2dCQUNsQixNQUFNO1lBQ1IsS0FBSyxVQUFVO2dCQUNiLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQztnQkFDdEIsTUFBTTtRQUNWLENBQUM7SUFDSCxDQUFDO0lBRU8sWUFBWTtRQUNsQixJQUFJLElBQUksQ0FBQyxlQUFlLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDOUIsSUFBSSxDQUFDLGVBQWUsR0FBRyxDQUFDLENBQUM7WUFDekIsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3RCLENBQUM7YUFBTSxJQUFJLElBQUksQ0FBQyxlQUFlLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDckMsSUFBSSxDQUFDLGVBQWUsR0FBRyxDQUFDLENBQUM7WUFDekIsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3RCLENBQUM7SUFDSCxDQUFDO0lBRU8sVUFBVTtRQUNoQixJQUFJLElBQUksQ0FBQyxlQUFlLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDN0IsSUFBSSxDQUFDLGVBQWUsSUFBSSxDQUFDLENBQUM7UUFDNUIsQ0FBQzthQUFNLElBQUksSUFBSSxDQUFDLGVBQWUsR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNwQyxJQUFJLENBQUMsZUFBZSxJQUFJLENBQUMsQ0FBQztRQUM1QixDQUFDO0lBQ0gsQ0FBQztJQUVPLGNBQWM7UUFDcEIsSUFBSSxJQUFJLENBQUMsZUFBZSxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQzdCLElBQUksQ0FBQyxlQUFlLEdBQUcsQ0FBQyxDQUFDO1lBQ3pCLElBQUksQ0FBQyxTQUFTLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDdEIsQ0FBQzthQUFNLElBQUksSUFBSSxDQUFDLGVBQWUsR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNwQyxJQUFJLENBQUMsZUFBZSxHQUFHLENBQUMsQ0FBQztZQUN6QixJQUFJLENBQUMsU0FBUyxHQUFHLENBQUMsQ0FBQztRQUNyQixDQUFDO0lBQ0gsQ0FBQztJQUVPLGNBQWMsQ0FBQyxTQUFpQjtRQUN0QyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3ZGLElBQUksSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQ3ZCLE1BQU0sSUFBSSxHQUFHLElBQUksS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ2pDLElBQUksQ0FBQyxhQUFhLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDMUMsTUFBTSxLQUFLLEdBQUcsUUFBUSxDQUFDLEtBQUssRUFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUN6QyxJQUFJLENBQUMsYUFBYSxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxDQUFDO1lBRTNDLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsU0FBUyxDQUFDLENBQUM7UUFDL0MsQ0FBQztJQUNILENBQUM7SUFFTyxxQkFBcUIsQ0FBQyxLQUFvQixFQUFFLFNBQWlCO1FBQ25FLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsYUFBYSxZQUFZLGtCQUFrQixDQUFDO1lBQUUsT0FBTztRQUV2RixNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLGlCQUFpQixFQUFFLENBQUM7UUFDOUQsSUFBSSxjQUFjLEVBQUUsT0FBTztZQUN6QixDQUFDLGNBQWMsQ0FBQyxVQUFVLEtBQUssaUJBQWlCLENBQUMsc0JBQXNCO2dCQUNyRSxjQUFjLENBQUMsVUFBVSxLQUFLLGlCQUFpQixDQUFDLHNCQUFzQixDQUFDLEVBQUUsQ0FBQztZQUM1RSxJQUFJLFFBQVEsR0FBNkIsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQ25ELElBQUksS0FBSyxDQUFDLFFBQVEsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDO2dCQUM3QixRQUFRLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLFNBQVMsRUFBRSxLQUFLLENBQUMsQ0FBQyxHQUFHLFNBQVMsRUFBRSxLQUFLLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQUFDO2dCQUMzRSxRQUFRLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBNkIsQ0FBQztZQUN2RixDQUFDO1lBQ0QsSUFBSSxDQUFDLGFBQWEsQ0FBQyxxQkFBcUIsQ0FBQyxrQkFBa0IsQ0FBQyxjQUFjLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDeEYsQ0FBQztJQUNILENBQUM7SUFFZSxlQUFlLENBQUMsU0FBaUI7UUFDL0MsS0FBSyxDQUFDLGVBQWUsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNuQyxDQUFDO0lBRU0sYUFBYTtRQUNsQixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQztRQUNuQixJQUFJLENBQUMsU0FBUyxHQUFHLENBQUMsQ0FBQztJQUNyQixDQUFDO0lBRU0sWUFBWTtRQUNqQixJQUFJLENBQUMsTUFBTSxHQUFHLEtBQUssQ0FBQztJQUN0QixDQUFDO0lBRU0sUUFBUTtRQUNiLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztJQUNyQixDQUFDO0lBRU0sV0FBVyxDQUFDLFFBQWdCO1FBQ2pDLElBQUksQ0FBQyxlQUFlLEdBQUcsS0FBSyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUMvRCxDQUFDO0lBRUQsc0dBQXNHO0lBQ3RHLG1CQUFtQjtJQUNuQixzR0FBc0c7SUFFdEYsa0JBQWtCO1FBQ2hDLE9BQU8sV0FBVyxDQUFDO0lBQ3JCLENBQUM7Q0FDRixDQUFBO0FBeEpZLHFCQUFxQjtJQURqQyxXQUFXLENBQUMsdUJBQXVCLENBQUM7O0dBQ3hCLHFCQUFxQixDQXdKakMifQ==

package/dist/src/components/movement/TopDownMovementComponent.d.ts

@@ -0,0 +1,25 @@
+import { BasePawnMovementComponent } from './BasePawnMovementComponent.js';
+import type { SceneComponentOptions } from '../SceneComponent.js';
+export interface TopDownMovementOptions extends SceneComponentOptions {
+    /** Panning speed in units per second */
+    panSpeed: number;
+    /** Zoom speed in units per scroll tick */
+    zoomSpeed: number;
+    /** Invert panning */
+    invertPan: boolean;
+}
+export declare class TopDownMovementComponent extends BasePawnMovementComponent<TopDownMovementOptions> {
+    static get DEFAULT_OPTIONS(): TopDownMovementOptions;
+    /**
+       * Creates a new top-down movement component
+       * @param options Configuration options for movement behavior
+       */
+    constructor(options?: TopDownMovementOptions);
+    /**
+       * Called before physics simulation each frame
+       * Processes panning and zooming inputs and applies them to the camera
+       * @param deltaTime Time in seconds since the last frame
+       */
+    tickPrePhysics(deltaTime: number): void;
+    getEditorClassIcon(): string | null;
+}

package/dist/src/components/movement/TopDownMovementComponent.js

@@ -0,0 +1,79 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var TopDownMovementComponent_1;
+/**
+ * TopDownMovementComponent implements simple panning and zoom for overhead
+ * camera rigs.
+ *
+ * The component interprets forward and right inputs as planar panning, with an
+ * optional inversion toggle. Zoom input adjusts the actor's world position along
+ * the vertical axis. This lightweight movement style is useful for strategy or
+ * editor cameras where gravity and collision are not required.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Attach to an actor containing a camera for top-down views.
+ * - Feed `addForwardInput`, `addRightInput`, and `addZoomInput` each frame from
+ *   mouse or keyboard controls.
+ * - Adjust `panSpeed` and `zoomSpeed` to tune responsiveness.
+ */
+import * as THREE from 'three';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { BasePawnMovementComponent } from './BasePawnMovementComponent.js';
+// Component that handles top-down movement for pawns
+let TopDownMovementComponent = TopDownMovementComponent_1 = class TopDownMovementComponent extends BasePawnMovementComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...BasePawnMovementComponent.DEFAULT_OPTIONS,
+            panSpeed: 10,
+            zoomSpeed: 5,
+            invertPan: false,
+        };
+    }
+    /**
+       * Creates a new top-down movement component
+       * @param options Configuration options for movement behavior
+       */
+    constructor(options = TopDownMovementComponent_1.DEFAULT_OPTIONS) {
+        super(options);
+    }
+    /**
+       * Called before physics simulation each frame
+       * Processes panning and zooming inputs and applies them to the camera
+       * @param deltaTime Time in seconds since the last frame
+       */
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        const owner = this.getActor();
+        const panInputY = -this.forwardInput.value * (this.options.invertPan ? -1 : 1);
+        const panInputX = this.rightInput.value * (this.options.invertPan ? -1 : 1);
+        if (panInputX || panInputY) {
+            var deltaPosition = new THREE.Vector3(0, 0, 0);
+            deltaPosition.add(new THREE.Vector3(panInputX, 0, panInputY).multiplyScalar(this.options.panSpeed * deltaTime));
+            deltaPosition.multiplyScalar(this.speedModifier);
+            owner.rootComponent.addWorldPosition(deltaPosition);
+        }
+        if (this.zoomInput.value !== 0) {
+            const zoomChange = this.zoomInput.value * this.options.zoomSpeed * deltaTime;
+            owner.rootComponent.addWorldPosition(new THREE.Vector3(0, zoomChange, 0).multiplyScalar(this.speedModifier));
+        }
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_TopDownMovement';
+    }
+};
+TopDownMovementComponent = TopDownMovementComponent_1 = __decorate([
+    EngineClass('TopDownMovementComponent'),
+    __metadata("design:paramtypes", [Object])
+], TopDownMovementComponent);
+export { TopDownMovementComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/components/movement/TweenMovementComponent.d.ts

@@ -0,0 +1,59 @@
+import * as THREE from 'three';
+import { SceneComponent } from '../SceneComponent.js';
+import type { EditorClassMeta } from '../../utils/EditorClassMeta.js';
+import type { SceneComponentOptions } from '../SceneComponent.js';
+export type TweenEasingType = 'Linear' | 'Quadratic.In' | 'Quadratic.Out' | 'Quadratic.InOut' | 'Cubic.In' | 'Cubic.Out' | 'Cubic.InOut' | 'Quartic.In' | 'Quartic.Out' | 'Quartic.InOut' | 'Quintic.In' | 'Quintic.Out' | 'Quintic.InOut' | 'Sinusoidal.In' | 'Sinusoidal.Out' | 'Sinusoidal.InOut' | 'Exponential.In' | 'Exponential.Out' | 'Exponential.InOut' | 'Circular.In' | 'Circular.Out' | 'Circular.InOut' | 'Elastic.In' | 'Elastic.Out' | 'Elastic.InOut' | 'Back.In' | 'Back.Out' | 'Back.InOut' | 'Bounce.In' | 'Bounce.Out' | 'Bounce.InOut';
+export type TweenLoopMode = 'NoLoop' | 'Loop';
+export interface TweenMovementOptions extends SceneComponentOptions {
+    /** Duration in seconds */
+    duration?: number;
+    /** Target position for animation */
+    targetPosition?: THREE.Vector3;
+    /** Target rotation for animation (in degrees) */
+    targetRotation?: THREE.Vector3;
+    /** Target scale for animation */
+    targetScale?: THREE.Vector3;
+    /** Easing function */
+    easing?: TweenEasingType;
+    /** Loop mode */
+    loop?: TweenLoopMode;
+    /** Whether to start automatically on begin play */
+    autoStart?: boolean;
+}
+export declare class TweenMovementComponent extends SceneComponent<TweenMovementOptions> {
+    private currentTween;
+    private rootComponent;
+    private startPosition;
+    private startRotation;
+    private startScale;
+    private isPlaying;
+    private debugLine;
+    private debugSpheres;
+    private debugGroup;
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    static get DEFAULT_OPTIONS(): TweenMovementOptions;
+    constructor(options?: TweenMovementOptions);
+    beginPlay(): void;
+    endPlay(): void;
+    /**
+     * Starts the tween animation
+     */
+    startTween(): void;
+    /**
+     * Stops the tween animation
+     */
+    stopTween(): void;
+    /**
+     * Resets the actor to its initial transform
+     */
+    resetToStart(): void;
+    /**
+     * Gets the Tween.js easing function from a string name
+     */
+    private getEasingFunction;
+    private initializeEditorVisualization;
+    private updateEditorVisualization;
+    private cleanupEditorVisualization;
+    onEditorSelectedChanged(isSelected: boolean): void;
+    getEditorClassIcon(): string | null;
+}