@directivegames/genesys.js 3.1.24

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

@@ -0,0 +1,402 @@
+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);
+};
+/**
+ * VehicleMovementComponent handles vehicle physics simulation and input processing.
+ *
+ * This component integrates Rapier's vehicle controller with the Genesys component
+ * system, providing a unified interface for vehicle physics, input handling, and
+ * visual synchronization. It extends BasePawnMovementComponent to support standard
+ * movement input patterns while adding vehicle-specific controls like acceleration,
+ * braking, and steering.
+ *
+ * Features:
+ * - Rapier physics-based vehicle simulation with realistic wheel physics
+ * - Configurable vehicle properties (engine power, steering angles, suspension)
+ * - Automatic wheel mesh synchronization with physics simulation
+ * - Support for different vehicle types through configuration
+ * - Input handling for keyboard, gamepad, and touch controls
+ * - Network replication support for multiplayer vehicles
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Attach to a vehicle actor with a chassis mesh and wheel meshes
+ * - Configure wheel positions and vehicle properties via options
+ * - Use addAccelerateInput, addBrakeInput, and addSteerInput for control
+ * - Call setupVehiclePhysics() after the actor's mesh is initialized
+ */
+import * as THREE from 'three';
+import { PhysicsVectorParam } from '../../physics/PhysicsEngine.js';
+import { PhysicsMotionType } from '../../physics/PhysicsTypes.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { Delegate } from '../../utils/Delegate.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+import { BasePawnMovementComponent } from './BasePawnMovementComponent.js';
+/**
+ * Vehicle movement component that handles both physics simulation and input processing
+ */
+let VehicleMovementComponent = class VehicleMovementComponent extends BasePawnMovementComponent {
+    static get DEFAULT_OPTIONS() {
+        const wheelBaseWidth = 2.6;
+        const wheelBaseLength = 3.0;
+        const wheelBaseHeight = 0;
+        const suspensionRestLength = 0.6;
+        const wheelRadius = 0.5;
+        const wheelWidth = 0.4;
+        const suspensionStiffness = 20;
+        const suspensionCompression = 0.83;
+        const suspensionRelaxation = 0.88;
+        const maxSuspensionForce = 6000.0;
+        const maxSuspensionTravel = 5.0;
+        const sideFrictionStiffness = 2;
+        const frictionSlip = 10.5;
+        return {
+            ...BasePawnMovementComponent.DEFAULT_OPTIONS,
+            maxEnginePower: 35,
+            maxSteeringAngle: Math.PI / 6, // 30 degrees
+            maxBrakeForce: 1,
+            engineResponseRate: 8.0,
+            steeringResponseRate: 12.0,
+            brakeResponseRate: 15.0,
+            createWheelMeshes: true,
+            wheelMaterialColor: 0x333333,
+            autoBreakWhenNotPossessed: 1,
+            autoStopBreak: 0.5,
+            wheels: [
+                // Default 4-wheel configuration
+                {
+                    position: new THREE.Vector3(-wheelBaseWidth / 2, wheelBaseHeight, -wheelBaseLength / 2), // Front left
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: true,
+                    isPowered: false,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(wheelBaseWidth / 2, wheelBaseHeight, -wheelBaseLength / 2), // Front right
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: true,
+                    isPowered: false,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(-wheelBaseWidth / 2, wheelBaseHeight, wheelBaseLength / 2), // Rear left
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: false,
+                    isPowered: true,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(wheelBaseWidth / 2, wheelBaseHeight, wheelBaseLength / 2), // Rear right
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: false,
+                    isPowered: true,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+            ],
+        };
+    }
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "onWheelUpdated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "brakeInput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        // Current smoothed control values
+        Object.defineProperty(this, "currentEngineForce", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "currentBrakeForce", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "currentSteering", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        // Physics integration
+        Object.defineProperty(this, "physicsVehicle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "wheelMeshes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Gets the input state for the vehicle movement component
+     * @returns The input state
+     */
+    getInputState() {
+        return {
+            ...super.getInputState(),
+            brakeInput: this.brakeInput,
+        };
+    }
+    endPlay() {
+        this.cleanupVehiclePhysics();
+        super.endPlay();
+    }
+    getPhysicsVehicle() {
+        return this.physicsVehicle;
+    }
+    /**
+     * Gets the current steering angle in radians
+     */
+    getCurrentSteeringAngle() {
+        return this.currentSteering * this.options.maxSteeringAngle;
+    }
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        this.createVehiclePhysics();
+        this.updateVehicleControls(deltaTime);
+    }
+    tickPostPhysics(deltaTime) {
+        super.tickPostPhysics(deltaTime);
+        this.updateWheels();
+    }
+    jump(strength = 1) {
+        this.brakeInput = 1;
+    }
+    stopJump() {
+        this.brakeInput = 0;
+    }
+    /**
+     * Sets up the vehicle physics simulation
+     */
+    createVehiclePhysics() {
+        if (this.physicsVehicle)
+            return;
+        const physicsEngine = this.getPhysicsEngine();
+        if (!physicsEngine)
+            return;
+        const actor = this.getActor();
+        // TOOD: for now the root component is assumed to be the chassis, this may be somewhat limiting
+        const chassisComponent = actor.rootComponent;
+        if (!(chassisComponent instanceof PrimitiveComponent) || chassisComponent.getMotionType() !== PhysicsMotionType.Dynamic)
+            return;
+        // Create vehicle controller through physics engine
+        this.physicsVehicle = physicsEngine.createVehicle(this, chassisComponent);
+        if (!this.physicsVehicle)
+            return;
+        // Setup wheels
+        this.wheelMeshes.clear();
+        const numWheels = this.options.wheels.length;
+        for (let i = 0; i < numWheels; i++) {
+            const wheelConfig = this.options.wheels[i];
+            // Add wheel to vehicle controller
+            const wheelIndex = this.physicsVehicle.addWheel(wheelConfig);
+            if (this.options.createWheelMeshes) {
+                // Create wheel mesh
+                const geometry = new THREE.CylinderGeometry(wheelConfig.radius, wheelConfig.radius, wheelConfig.width, 16);
+                geometry.rotateZ(Math.PI * 0.5); // Orient wheel correctly
+                const material = new THREE.MeshStandardMaterial({
+                    color: this.options.wheelMaterialColor
+                });
+                const wheelMesh = new THREE.Mesh(geometry, material);
+                wheelMesh.castShadow = true;
+                wheelMesh.position.copy(wheelConfig.position);
+                wheelMesh.setTransient(true);
+                // Add wheel to chassis mesh
+                chassisComponent.add(wheelMesh);
+                this.wheelMeshes.set(wheelIndex, wheelMesh);
+            }
+        }
+        console.log(`VehicleMovementComponent: Created ${this.physicsVehicle.numWheels()} wheels`);
+    }
+    /**
+     * Updates vehicle control inputs with smoothing
+     */
+    updateVehicleControls(deltaTime) {
+        if (!this.physicsVehicle)
+            return;
+        const accelerationInput = -this.forwardInput.value;
+        let brakeInput = this.brakeInput;
+        const steeringInput = -this.rightInput.value;
+        if (this.isPlayerControlled()) {
+            if (accelerationInput === 0 && brakeInput === 0 && steeringInput === 0) {
+                if (this.options.autoStopBreak > 0) {
+                    brakeInput += this.options.autoStopBreak;
+                }
+            }
+        }
+        else {
+            if (this.options.autoBreakWhenNotPossessed > 0) {
+                brakeInput += this.options.autoBreakWhenNotPossessed;
+            }
+        }
+        // Smooth engine force
+        const targetEngineForce = accelerationInput * this.options.maxEnginePower * this.speedModifier;
+        this.currentEngineForce = THREE.MathUtils.lerp(this.currentEngineForce, targetEngineForce, this.options.engineResponseRate * deltaTime);
+        // Smooth brake force
+        const targetBrakeForce = brakeInput * this.options.maxBrakeForce * this.speedModifier;
+        this.currentBrakeForce = THREE.MathUtils.lerp(this.currentBrakeForce, targetBrakeForce, this.options.brakeResponseRate * deltaTime);
+        // Smooth steering
+        this.currentSteering = THREE.MathUtils.lerp(this.currentSteering, steeringInput, this.options.steeringResponseRate * deltaTime);
+        try {
+            this.physicsVehicle.setEngineForce(this.currentEngineForce);
+            this.physicsVehicle.setBrakeForce(this.currentBrakeForce);
+            this.physicsVehicle.setSteering(this.currentSteering * this.options.maxSteeringAngle);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    /**
+     * Updates wheel visual positions and rotations based on physics
+     */
+    updateWheels() {
+        if (!this.physicsVehicle)
+            return;
+        for (let i = 0; i < this.physicsVehicle.numWheels(); i++) {
+            const wheelState = this.physicsVehicle.getWheelState(i);
+            if (!wheelState)
+                continue;
+            this.onWheelUpdated.invoke(this, i, wheelState);
+            const wheelMesh = this.wheelMeshes.get(i);
+            if (wheelMesh) {
+                wheelMesh.position.copy(wheelState.relativePosition);
+                wheelMesh.quaternion.copy(wheelState.relativeQuaternion);
+            }
+        }
+    }
+    /**
+     * Cleans up vehicle physics
+     */
+    cleanupVehiclePhysics() {
+        const physicsEngine = this.getPhysicsEngine();
+        if (!physicsEngine)
+            return;
+        // Destroy vehicle controller
+        if (this.physicsVehicle) {
+            this.physicsVehicle.destroy();
+            this.physicsVehicle = null;
+        }
+        this.wheelMeshes.clear();
+        console.log('VehicleMovementComponent: Physics cleaned up');
+    }
+    /**
+     * Flips the vehicle if it's upside down
+     * @param forceFlip If true, flips the vehicle regardless of orientation
+     * @returns True if the vehicle was flipped, false otherwise
+     */
+    flipVehicle(forceFlip = false) {
+        const actor = this.getActor();
+        if (!actor)
+            return false;
+        const rootComponent = actor.rootComponent;
+        if (!rootComponent)
+            return false;
+        // Get the vehicle's current up vector
+        const vehicleUp = new THREE.Vector3(0, 1, 0);
+        const worldQuaternion = new THREE.Quaternion();
+        rootComponent.getWorldQuaternion(worldQuaternion);
+        vehicleUp.applyQuaternion(worldQuaternion);
+        // Check if the vehicle needs flipping (upside down or on its side)
+        const worldUp = new THREE.Vector3(0, 1, 0);
+        const upDot = vehicleUp.dot(worldUp);
+        // Vehicle needs flipping if:
+        // - Upside down (dot product < 0)
+        // - Tilted more than 60 degrees from upright (dot product < 0.5)
+        const needsFlip = upDot < 0.5;
+        if (forceFlip || needsFlip) {
+            // Get current position and rotation
+            const currentPosition = new THREE.Vector3();
+            const currentQuaternion = new THREE.Quaternion();
+            rootComponent.getWorldPosition(currentPosition);
+            rootComponent.getWorldQuaternion(currentQuaternion);
+            // Set upright rotation directly, preserving only the Y (yaw) rotation
+            const currentEuler = new THREE.Euler();
+            currentEuler.setFromQuaternion(currentQuaternion, 'YXZ');
+            // Create upright rotation keeping only the Y rotation (yaw)
+            const uprightEuler = new THREE.Euler(0, currentEuler.y, 0, 'YXZ');
+            const newQuaternion = new THREE.Quaternion();
+            newQuaternion.setFromEuler(uprightEuler);
+            // Lift the vehicle slightly to avoid collision issues
+            currentPosition.y += 2;
+            // Apply the new transform
+            rootComponent.setWorldPosition(currentPosition);
+            rootComponent.setWorldQuaternion(newQuaternion);
+            // Reset physics velocity to prevent tumbling
+            const physicsEngine = this.getPhysicsEngine();
+            if (physicsEngine && rootComponent instanceof PrimitiveComponent) {
+                physicsEngine.setVectorParam(rootComponent, PhysicsVectorParam.LinearVelocity, [0, 0, 0]);
+                physicsEngine.setVectorParam(rootComponent, PhysicsVectorParam.AngularVelocity, [0, 0, 0]);
+            }
+            return true;
+        }
+        return false;
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Vehicle';
+    }
+};
+VehicleMovementComponent = __decorate([
+    EngineClass('VehicleMovementComponent'),
+    __metadata("design:paramtypes", [Object])
+], VehicleMovementComponent);
+export { VehicleMovementComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VehicleMovementComponent.js","sourceRoot":"","sources":["../../../../src/components/movement/VehicleMovementComponent.ts"],"names":[],"mappings":";;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAmD3E;;GAEG;AAEI,IAAM,wBAAwB,GAA9B,MAAM,wBAA2F,SAAQ,yBAAmC;IAQjJ,MAAM,KAAc,eAAe;QACjC,MAAM,cAAc,GAAG,GAAG,CAAC;QAC3B,MAAM,eAAe,GAAG,GAAG,CAAC;QAC5B,MAAM,eAAe,GAAG,CAAC,CAAC;QAC1B,MAAM,oBAAoB,GAAG,GAAG,CAAC;QACjC,MAAM,WAAW,GAAG,GAAG,CAAC;QACxB,MAAM,UAAU,GAAG,GAAG,CAAC;QACvB,MAAM,mBAAmB,GAAG,EAAE,CAAC;QAC/B,MAAM,qBAAqB,GAAG,IAAI,CAAC;QACnC,MAAM,oBAAoB,GAAG,IAAI,CAAC;QAClC,MAAM,kBAAkB,GAAG,MAAM,CAAC;QAClC,MAAM,mBAAmB,GAAG,GAAG,CAAC;QAChC,MAAM,qBAAqB,GAAG,CAAC,CAAC;QAChC,MAAM,YAAY,GAAG,IAAI,CAAC;QAE1B,OAAO;YACL,GAAG,yBAAyB,CAAC,eAAe;YAC5C,cAAc,EAAE,EAAE;YAClB,gBAAgB,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,aAAa;YAC5C,aAAa,EAAE,CAAC;YAChB,kBAAkB,EAAE,GAAG;YACvB,oBAAoB,EAAE,IAAI;YAC1B,iBAAiB,EAAE,IAAI;YACvB,iBAAiB,EAAE,IAAI;YACvB,kBAAkB,EAAE,QAAQ;YAC5B,yBAAyB,EAAE,CAAC;YAC5B,aAAa,EAAE,GAAG;YAClB,MAAM,EAAE;gBACN,gCAAgC;gBAChC;oBACE,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,cAAc,GAAG,CAAC,EAAE,eAAe,EAAE,CAAC,eAAe,GAAG,CAAC,CAAC,EAAE,aAAa;oBACtG,MAAM,EAAE,WAAW;oBACnB,KAAK,EAAE,UAAU;oBACjB,QAAQ,EAAE,IAAI;oBACd,SAAS,EAAE,KAAK;oBAChB,QAAQ,EAAE,IAAI;oBACd,oBAAoB;oBACpB,mBAAmB;oBACnB,qBAAqB;oBACrB,oBAAoB;oBACpB,kBAAkB;oBAClB,mBAAmB;oBACnB,qBAAqB;oBACrB,YAAY;iBACb;gBACD;oBACE,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,cAAc,GAAG,CAAC,EAAE,eAAe,EAAE,CAAC,eAAe,GAAG,CAAC,CAAC,EAAE,cAAc;oBACtG,MAAM,EAAE,WAAW;oBACnB,KAAK,EAAE,UAAU;oBACjB,QAAQ,EAAE,IAAI;oBACd,SAAS,EAAE,KAAK;oBAChB,QAAQ,EAAE,IAAI;oBACd,oBAAoB;oBACpB,mBAAmB;oBACnB,qBAAqB;oBACrB,oBAAoB;oBACpB,kBAAkB;oBAClB,mBAAmB;oBACnB,qBAAqB;oBACrB,YAAY;iBACb;gBACD;oBACE,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,cAAc,GAAG,CAAC,EAAE,eAAe,EAAE,eAAe,GAAG,CAAC,CAAC,EAAE,YAAY;oBACpG,MAAM,EAAE,WAAW;oBACnB,KAAK,EAAE,UAAU;oBACjB,QAAQ,EAAE,KAAK;oBACf,SAAS,EAAE,IAAI;oBACf,QAAQ,EAAE,IAAI;oBACd,oBAAoB;oBACpB,mBAAmB;oBACnB,qBAAqB;oBACrB,oBAAoB;oBACpB,kBAAkB;oBAClB,mBAAmB;oBACnB,qBAAqB;oBACrB,YAAY;iBACb;gBACD;oBACE,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,cAAc,GAAG,CAAC,EAAE,eAAe,EAAE,eAAe,GAAG,CAAC,CAAC,EAAE,aAAa;oBACpG,MAAM,EAAE,WAAW;oBACnB,KAAK,EAAE,UAAU;oBACjB,QAAQ,EAAE,KAAK;oBACf,SAAS,EAAE,IAAI;oBACf,QAAQ,EAAE,IAAI;oBACd,oBAAoB;oBACpB,mBAAmB;oBACnB,qBAAqB;oBACrB,oBAAoB;oBACpB,kBAAkB;oBAClB,mBAAmB;oBACnB,qBAAqB;oBACrB,YAAY;iBACb;aACF;SACF,CAAC;IACJ,CAAC;IAWD,YAAY,OAAiB;QAC3B,KAAK,CAAC,OAAO,CAAC,CAAC;QAjHD;;;;mBAAsC,IAAI,QAAQ,EAExD;WAAC;QAEH;;;;mBAAqB,CAAC;WAAC;QAmG/B,kCAAkC;QAC1B;;;;mBAA6B,CAAC;WAAC;QAC/B;;;;mBAA4B,CAAC;WAAC;QAC9B;;;;mBAA0B,CAAC;WAAC;QAEpC,sBAAsB;QACd;;;;mBAAyC,IAAI;WAAC;QAC9C;;;;mBAA2C,IAAI,GAAG,EAAE;WAAC;IAI7D,CAAC;IAED;;;OAGG;IACa,aAAa;QAC3B,OAAO;YACL,GAAG,KAAK,CAAC,aAAa,EAAE;YACxB,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,CAAC;IACJ,CAAC;IAEe,OAAO;QACrB,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC;IAEM,iBAAiB;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED;;OAEG;IACI,uBAAuB;QAC5B,OAAO,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC;IAC9D,CAAC;IAEe,cAAc,CAAC,SAAiB;QAC9C,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAChC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;IAEe,eAAe,CAAC,SAAiB;QAC/C,KAAK,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QACjC,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAEe,IAAI,CAAC,WAAmB,CAAC;QACvC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;IACtB,CAAC;IAEe,QAAQ;QACtB,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;IACtB,CAAC;IAED;;OAEG;IACO,oBAAoB;QAC5B,IAAI,IAAI,CAAC,cAAc;YAAE,OAAO;QAEhC,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC9C,IAAI,CAAC,aAAa;YAAE,OAAO;QAE3B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAG,CAAC;QAC/B,+FAA+F;QAC/F,MAAM,gBAAgB,GAAG,KAAK,CAAC,aAAa,CAAC;QAC7C,IAAI,CAAC,CAAC,gBAAgB,YAAY,kBAAkB,CAAC,IAAI,gBAAgB,CAAC,aAAa,EAAE,KAAK,iBAAiB,CAAC,OAAO;YAAE,OAAO;QAEhI,mDAAmD;QACnD,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC,aAAa,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;QAC1E,IAAI,CAAC,IAAI,CAAC,cAAc;YAAE,OAAO;QAEjC,eAAe;QACf,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QAEzB,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;QAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;YACnC,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAE3C,kCAAkC;YAClC,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YAE7D,IAAI,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;gBACnC,oBAAoB;gBACpB,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,gBAAgB,CACzC,WAAW,CAAC,MAAM,EAClB,WAAW,CAAC,MAAM,EAClB,WAAW,CAAC,KAAK,EACjB,EAAE,CACH,CAAC;gBACF,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,yBAAyB;gBAE1D,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,oBAAoB,CAAC;oBAC9C,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB;iBACvC,CAAC,CAAC;gBAEH,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;gBACrD,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC;gBAC5B,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;gBAC9C,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBAE7B,4BAA4B;gBAC5B,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;gBAChC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,qCAAqC,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;IAC7F,CAAC;IAED;;OAEG;IACO,qBAAqB,CAAC,SAAiB;QAC/C,IAAI,CAAC,IAAI,CAAC,cAAc;YAAE,OAAO;QAEjC,MAAM,iBAAiB,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;QACnD,IAAI,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACjC,MAAM,aAAa,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;QAE7C,IAAI,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;YAC9B,IAAI,iBAAiB,KAAK,CAAC,IAAI,UAAU,KAAK,CAAC,IAAI,aAAa,KAAK,CAAC,EAAE,CAAC;gBACvE,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,GAAG,CAAC,EAAE,CAAC;oBACnC,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC;gBAC3C,CAAC;YACH,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,IAAI,CAAC,OAAO,CAAC,yBAAyB,GAAG,CAAC,EAAE,CAAC;gBAC/C,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,yBAAyB,CAAC;YACvD,CAAC;QACH,CAAC;QAED,sBAAsB;QACtB,MAAM,iBAAiB,GAAG,iBAAiB,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC;QAC/F,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,CAC5C,IAAI,CAAC,kBAAkB,EACvB,iBAAiB,EACjB,IAAI,CAAC,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAC5C,CAAC;QAEF,qBAAqB;QACrB,MAAM,gBAAgB,GAAG,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACtF,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,CAC3C,IAAI,CAAC,iBAAiB,EACtB,gBAAgB,EAChB,IAAI,CAAC,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAC3C,CAAC;QAEF,kBAAkB;QAClB,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,CACzC,IAAI,CAAC,eAAe,EACpB,aAAa,EACb,IAAI,CAAC,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAC9C,CAAC;QAEF,IAAI,CAAC;YACH,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;YAC5D,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YAC1D,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;QACxF,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IAED;;OAEG;IACO,YAAY;QACpB,IAAI,CAAC,IAAI,CAAC,cAAc;YAAE,OAAO;QAEjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;YACzD,MAAM,UAAU,GAAG,IAAI,CAAC,cAAe,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;YACzD,IAAI,CAAC,UAAU;gBAAE,SAAS;YAE1B,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC;YAEhD,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAC1C,IAAI,SAAS,EAAE,CAAC;gBACd,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;gBACrD,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACO,qBAAqB;QAC7B,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC9C,IAAI,CAAC,aAAa;YAAE,OAAO;QAE3B,6BAA6B;QAC7B,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;YAC9B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QAEzB,OAAO,CAAC,GAAG,CAAC,8CAA8C,CAAC,CAAC;IAC9D,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,YAAqB,KAAK;QAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,CAAC,KAAK;YAAE,OAAO,KAAK,CAAC;QAEzB,MAAM,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAC1C,IAAI,CAAC,aAAa;YAAE,OAAO,KAAK,CAAC;QAEjC,sCAAsC;QACtC,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7C,MAAM,eAAe,GAAG,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;QAC/C,aAAa,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAC;QAClD,SAAS,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;QAE3C,mEAAmE;QACnE,MAAM,OAAO,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAErC,6BAA6B;QAC7B,kCAAkC;QAClC,iEAAiE;QACjE,MAAM,SAAS,GAAG,KAAK,GAAG,GAAG,CAAC;QAE9B,IAAI,SAAS,IAAI,SAAS,EAAE,CAAC;YAC3B,oCAAoC;YACpC,MAAM,eAAe,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAC5C,MAAM,iBAAiB,GAAG,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACjD,aAAa,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC;YAChD,aAAa,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;YAEpD,sEAAsE;YACtE,MAAM,YAAY,GAAG,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YACvC,YAAY,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;YAEzD,4DAA4D;YAC5D,MAAM,YAAY,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;YAClE,MAAM,aAAa,GAAG,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YAC7C,aAAa,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAEzC,sDAAsD;YACtD,eAAe,CAAC,CAAC,IAAI,CAAC,CAAC;YAEvB,0BAA0B;YAC1B,aAAa,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC;YAChD,aAAa,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;YAEhD,6CAA6C;YAC7C,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC9C,IAAI,aAAa,IAAI,aAAa,YAAY,kBAAkB,EAAE,CAAC;gBACjE,aAAa,CAAC,cAAc,CAAC,aAAa,EAAE,kBAAkB,CAAC,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC1F,aAAa,CAAC,cAAc,CAAC,aAAa,EAAE,kBAAkB,CAAC,eAAe,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC7F,CAAC;YAED,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,sGAAsG;IACtG,mBAAmB;IACnB,sGAAsG;IAEtF,kBAAkB;QAChC,OAAO,cAAc,CAAC;IACxB,CAAC;CACF,CAAA;AA9XY,wBAAwB;IADpC,WAAW,CAAC,0BAA0B,CAAC;;GAC3B,wBAAwB,CA8XpC"}

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

@@ -0,0 +1,19 @@
+/**
+ * Movement components aggregate export.
+ *
+ * This barrel file exposes all movement-related components used by the Genesys
+ * engine. Importing from this module grants access to base pawn movement along
+ * with specialized implementations like character and airplane controllers.
+ * Keeping these exports centralized simplifies dependency management and helps
+ * AI assistants discover available movement behaviors.
+ */
+export * from './BasePawnMovementComponent.js';
+export * from './CharacterMovementComponent.js';
+export * from './TopDownMovementComponent.js';
+export * from './AirplaneMovementComponent.js';
+export * from './AerialMovementComponent.js';
+export * from './NpcMovementComponent.js';
+export * from './PathMovementComponent.js';
+export * from './DirectionalCharacterMovementComponent.js';
+export * from './VehicleMovementComponent.js';
+export * from './TweenMovementComponent.js';

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

@@ -0,0 +1,20 @@
+/**
+ * Movement components aggregate export.
+ *
+ * This barrel file exposes all movement-related components used by the Genesys
+ * engine. Importing from this module grants access to base pawn movement along
+ * with specialized implementations like character and airplane controllers.
+ * Keeping these exports centralized simplifies dependency management and helps
+ * AI assistants discover available movement behaviors.
+ */
+export * from './BasePawnMovementComponent.js';
+export * from './CharacterMovementComponent.js';
+export * from './TopDownMovementComponent.js';
+export * from './AirplaneMovementComponent.js';
+export * from './AerialMovementComponent.js';
+export * from './NpcMovementComponent.js';
+export * from './PathMovementComponent.js';
+export * from './DirectionalCharacterMovementComponent.js';
+export * from './VehicleMovementComponent.js';
+export * from './TweenMovementComponent.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9tb3ZlbWVudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7R0FRRztBQUNILGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsNkJBQTZCLENBQUMifQ==

package/dist/src/components/physics/RagdollComponent.d.ts

@@ -0,0 +1,118 @@
+/**
+ * RagdollComponent manages physics-based character ragdoll simulation.
+ *
+ * This component creates individual physics bodies for major body parts (head, torso, limbs)
+ * and connects them with spherical joints. It integrates with the existing GLTFMeshComponent
+ * to drive skeletal animation from physics simulation.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Attach to actors that have a GLTFMeshComponent with a humanoid skeleton
+ * - Call activateRagdoll() to transition from animation to physics simulation
+ * - Use deactivateRagdoll() to return to normal animation
+ * - Configure bone mapping and physics properties via options
+ */
+import * as THREE from 'three';
+import { SceneComponent } from '../SceneComponent.js';
+import type { SceneComponentOptions } from '../SceneComponent.js';
+export interface RagdollBoneConfig {
+    boneName: string;
+    size: THREE.Vector3;
+    mass: number;
+    offset?: THREE.Vector3;
+}
+export interface RagdollJointConfig {
+    parentLimb: string;
+    childLimb: string;
+    localAnchor1: THREE.Vector3;
+    localAnchor2: THREE.Vector3;
+}
+export interface RagdollComponentOptions extends SceneComponentOptions {
+    /** Whether ragdoll is initially active */
+    initiallyActive?: boolean;
+    /** Bone mapping configuration */
+    boneMapping?: {
+        [limbName: string]: string;
+    };
+    /** Physics configuration for each limb */
+    limbConfigs?: {
+        [limbName: string]: RagdollBoneConfig;
+    };
+    /** Joint configuration */
+    joints?: RagdollJointConfig[];
+    /** Default mass for limbs */
+    defaultMass?: number;
+    /** Overall scale factor for physics bodies */
+    physicsScale?: number;
+    /** Whether to show debug spheres at physics body locations */
+    debugSpheres?: boolean;
+}
+type RagdollLimbs = 'hips' | 'head' | 'torso' | 'armUpperRight' | 'armLowerRight' | 'armUpperLeft' | 'armLowerLeft' | 'thighRight' | 'shinRight' | 'thighLeft' | 'shinLeft';
+export declare class RagdollComponent extends SceneComponent<RagdollComponentOptions> {
+    static get DEFAULT_OPTIONS(): RagdollComponentOptions;
+    private gltfComponent;
+    private physicsEngine;
+    private isActive;
+    private ragdollBodies;
+    private joints;
+    private initialBoneWorldQuaternions;
+    private initialBoneLocalTransforms;
+    private boneMapping;
+    private animationMixer;
+    private debugSpheres;
+    private debugSphereMaterial;
+    constructor(options?: RagdollComponentOptions);
+    beginPlay(): void;
+    endPlay(): void;
+    tickPostPhysics(deltaTime: number): void;
+    /**
+     * Activates the ragdoll physics simulation
+     */
+    activateRagdoll(): void;
+    /**
+     * Deactivates the ragdoll physics simulation
+     */
+    deactivateRagdoll(): void;
+    /**
+     * Applies an impulse to a specific limb
+     */
+    applyImpulseToLimb(limbName: RagdollLimbs, impulse: THREE.Vector3): void;
+    /**
+     * Gets whether the ragdoll is currently active
+     */
+    isRagdollActive(): boolean;
+    private storeInitialBoneOrientations;
+    private createRagdollBodies;
+    private getDefaultBodyConfigs;
+    private createJoints;
+    private updateBoneTransforms;
+    private cleanup;
+    /**
+     * Creates debug spheres to visualize physics body positions
+     */
+    private createDebugSpheres;
+    /**
+     * Updates debug sphere positions to match physics bodies
+     */
+    private updateDebugSpheres;
+    /**
+     * Destroys all debug spheres and cleans up resources
+     */
+    private destroyDebugSpheres;
+    /**
+     * Forces a complete skeleton update after bone transforms have been modified
+     */
+    private forceSkeletonUpdate;
+    /**
+     * Updates the skeleton after bone transforms have been modified (legacy method)
+     */
+    private updateSkeleton;
+    /**
+     * Restores all bones to their original poses when deactivating ragdoll
+     */
+    private restoreOriginalPose;
+    /**
+     * Gets the parent limb name for kinematic chain calculations
+     */
+    private getParentLimbName;
+}
+export {};