@directivegames/genesys.js 3.1.24

package/dist/games/examples/vehicle/base-vehicle.js

@@ -0,0 +1,155 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { VehicleGamePlayer } from './player.js';
+/**
+ * Base vehicle class that provides common vehicle functionality
+ *
+ * Key points:
+ * - Handles camera setup with follow component for smooth third-person view
+ * - Manages player interaction (enter/exit vehicle with proximity detection)
+ * - Provides E key input handler for vehicle exit
+ * - Calculates safe exit position when player leaves vehicle
+ * - Automatically switches possession between player and vehicle
+ *
+ */
+export class BaseVehicle extends ENGINE.Pawn {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "interactionDistance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 5
+        });
+        Object.defineProperty(this, "nearbyPlayer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "enteredPlayer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    doBeginPlay() {
+        super.doBeginPlay();
+        this.setupCamera();
+        this.setupVicinityCheck();
+        this.setupExitHandler();
+    }
+    setupCamera() {
+        // create a follow component for smooth camera movement
+        const followComponent = new ENGINE.FollowComponent({
+            positionOffset: new THREE.Vector3(0, 4, 10),
+            positionDamping: 0.02,
+            lookAtOffset: new THREE.Vector3(0, 0, 0),
+            target: this.rootComponent,
+            useCameraLookAtConvention: true,
+        });
+        this.rootComponent.add(followComponent);
+        // create a camera and add it to the follow component
+        const camera = new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR);
+        followComponent.add(camera);
+    }
+    setupVicinityCheck() {
+        // Check every frame for nearby players using tick delegate
+        this.onTickPostPhysics.add(() => {
+            this.checkForNearbyPlayer();
+        });
+    }
+    checkForNearbyPlayer() {
+        const players = this.world.getActors(VehicleGamePlayer);
+        let foundNearbyPlayer = false;
+        for (const player of players) {
+            const distance = this.rootComponent.position.distanceTo(player.rootComponent.position);
+            if (distance <= this.interactionDistance) {
+                this.nearbyPlayer = player;
+                foundNearbyPlayer = true;
+                break;
+            }
+        }
+        if (!foundNearbyPlayer) {
+            this.nearbyPlayer = null;
+        }
+    }
+    canBeEntered() {
+        return this.nearbyPlayer !== null;
+    }
+    getNearbyPlayer() {
+        return this.nearbyPlayer;
+    }
+    setupExitHandler() {
+        // Add E key input handler for vehicle exit
+        this.onKeyDown.add((e) => {
+            if (e.key.toLowerCase() === 'e' && this.enteredPlayer) {
+                this.exitVehicle();
+                return true;
+            }
+            else if (e.key.toLowerCase() === 'f') {
+                if (this.movementComponent instanceof ENGINE.VehicleMovementComponent) {
+                    this.movementComponent.flipVehicle(false);
+                }
+                return true;
+            }
+            return false;
+        });
+    }
+    setEnteredPlayer(player) {
+        this.enteredPlayer = player;
+    }
+    onPlayerEntered() {
+        if (!this.enteredPlayer)
+            return;
+        // Only the root component has physics, do not propagate to children
+        this.enteredPlayer.rootComponent.setPhysicsEnabled(false, false);
+    }
+    exitVehicle() {
+        if (!this.enteredPlayer)
+            return;
+        // Calculate exit position (to the side of the vehicle)
+        const exitPosition = this.calculateExitPosition();
+        // Get the current player controller
+        const controller = this.getPlayerController();
+        if (controller) {
+            // Move player to exit position
+            this.enteredPlayer.rootComponent.position.copy(exitPosition);
+            // Make player face the same direction as the vehicle (yaw only)
+            // Get vehicle's forward direction vector (accounts for all rotations)
+            const vehicleForward = this.forwardDirection();
+            // Flatten to XZ plane to extract yaw only
+            vehicleForward.y = 0;
+            vehicleForward.normalize();
+            // Calculate yaw from forward direction, rotated 180 degrees
+            const yaw = Math.atan2(vehicleForward.x, vehicleForward.z) + Math.PI;
+            // Set player rotation to match vehicle's heading direction
+            this.enteredPlayer.rootComponent.rotation.x = 0;
+            this.enteredPlayer.rootComponent.rotation.z = 0;
+            this.enteredPlayer.rootComponent.rotation.y = yaw;
+            // Restore player visibility and physics
+            this.enteredPlayer.rootComponent.visible = true;
+            // Only the root component has physics, do not propagate to children
+            this.enteredPlayer.rootComponent.setPhysicsEnabled(true, false);
+            // Switch possession back to player
+            controller.unpossess();
+            controller.possess(this.enteredPlayer);
+            // Clear entered player reference
+            this.enteredPlayer = null;
+        }
+    }
+    calculateExitPosition() {
+        // Calculate a position to the right side of the vehicle
+        const vehiclePosition = this.rootComponent.position.clone();
+        const vehicleRotation = this.rootComponent.rotation;
+        // Create a vector pointing to the right of the vehicle
+        const rightVector = new THREE.Vector3(1, 0, 0);
+        rightVector.applyEuler(vehicleRotation);
+        // Position the player 2 units to the right and slightly forward
+        const exitOffset = rightVector.multiplyScalar(2);
+        exitOffset.y = 1; // Raise slightly above ground
+        return vehiclePosition.add(exitOffset);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/games/examples/vehicle/game.d.ts

@@ -0,0 +1,11 @@
+import * as ENGINE from 'genesys.js';
+export declare class VehicleGame extends ENGINE.BaseGameLoop {
+    private controlsUI;
+    constructor(container: HTMLElement);
+    protected preStart(): Promise<void>;
+    protected createLoadingScreen(): ENGINE.ILoadingScreen | null;
+    private createVehicle;
+    private showControlsUI;
+    private dismissControlsUI;
+    destroy(): void;
+}

package/dist/games/examples/vehicle/game.js

@@ -0,0 +1,140 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { MeshVehicle } from './mesh-vehicle.js';
+import { VehicleGamePlayer } from './player.js';
+import { PrimitiveVehicle } from './primitive-vehicle.js';
+export class VehicleGame extends ENGINE.BaseGameLoop {
+    constructor(container) {
+        super(container);
+        Object.defineProperty(this, "controlsUI", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    async preStart() {
+        // Setup lighting
+        ENGINE.GameBuilder.createDefaultLighting(this.world, false);
+        ENGINE.GameBuilder.createDefaultSkybox(this.world);
+        // Create ground
+        ENGINE.GameBuilder.createDefaultGround(this.world);
+        // Create vehicle
+        this.createVehicle();
+        // Show controls UI
+        this.showControlsUI();
+    }
+    createLoadingScreen() {
+        return new ENGINE.DefaultLoadingScreen();
+    }
+    createVehicle() {
+        const primitiveVehicle = new PrimitiveVehicle({
+            position: new THREE.Vector3(0, 0, -5),
+            camera: null,
+            // the movement component is set in the constructor of the vehicle class
+            movementComponent: null,
+        });
+        const meshVehicle = new MeshVehicle({
+            position: new THREE.Vector3(5, 0, -5),
+            camera: null,
+            // the movement component is set in the constructor of the vehicle class
+            movementComponent: null,
+        });
+        const player = new VehicleGamePlayer({
+            position: new THREE.Vector3(0, 2, 0),
+        });
+        const controller = new ENGINE.PlayerController();
+        controller.possess(player);
+        this.world.addActors(controller, player, primitiveVehicle, meshVehicle);
+    }
+    showControlsUI() {
+        // Create the controls overlay
+        this.controlsUI = document.createElement('div');
+        this.controlsUI.style.cssText = `
+      position: absolute;
+      top: 50%;
+      left: 50%;
+      transform: translate(-50%, -50%);
+      background: rgba(0, 0, 0, 0.9);
+      color: white;
+      padding: 30px;
+      border-radius: 15px;
+      font-family: Arial, sans-serif;
+      font-size: 16px;
+      max-width: 500px;
+      z-index: 1000;
+      box-shadow: 0 4px 20px rgba(0, 0, 0, 0.5);
+      border: 2px solid #00ff88;
+    `;
+        this.controlsUI.innerHTML = `
+      <h2 style="color: #00ff88; margin-top: 0; text-align: center;">Vehicle Demo Controls</h2>
+      
+      <div style="margin: 20px 0;">
+        <h3 style="color: #ffff88; margin-bottom: 10px;">Player Movement:</h3>
+        <ul style="margin: 0; padding-left: 20px;">
+          <li><strong>WASD</strong> - Move around</li>
+          <li><strong>Mouse</strong> - Look around</li>
+          <li><strong>Space</strong> - Jump</li>
+        </ul>
+      </div>
+
+      <div style="margin: 20px 0;">
+        <h3 style="color: #ffff88; margin-bottom: 10px;">Vehicle Interaction:</h3>
+        <ul style="margin: 0; padding-left: 20px;">
+          <li><strong>E</strong> - Enter vehicle (when close to one)</li>
+          <li><strong>E</strong> - Exit vehicle (when inside)</li>
+        </ul>
+      </div>
+
+      <div style="margin: 20px 0;">
+        <h3 style="color: #ffff88; margin-bottom: 10px;">Vehicle Controls:</h3>
+        <ul style="margin: 0; padding-left: 20px;">
+          <li><strong>W</strong> - Accelerate</li>
+          <li><strong>S</strong> - Reverse</li>
+          <li><strong>A/D</strong> - Steer left/right</li>
+          <li><strong>Space</strong> - Brake</li>
+          <li><strong>F</strong> - Flip vehicle upright</li>
+        </ul>
+      </div>
+
+      <button id="dismissControlsBtn" style="
+        display: block;
+        margin: 20px auto 0;
+        padding: 10px 20px;
+        background: #00ff88;
+        color: black;
+        border: none;
+        border-radius: 5px;
+        font-size: 16px;
+        font-weight: bold;
+        cursor: pointer;
+      ">Got it!</button>
+    `;
+        // Add to the game container
+        this.container.appendChild(this.controlsUI);
+        // Add dismiss functionality
+        const dismissBtn = this.controlsUI.querySelector('#dismissControlsBtn');
+        dismissBtn.addEventListener('click', () => {
+            this.dismissControlsUI();
+        });
+        // Also allow dismissing with Escape key
+        const handleKeyPress = (e) => {
+            if (e.key === 'Escape') {
+                this.dismissControlsUI();
+                document.removeEventListener('keydown', handleKeyPress);
+            }
+        };
+        document.addEventListener('keydown', handleKeyPress);
+    }
+    dismissControlsUI() {
+        if (this.controlsUI) {
+            this.controlsUI.remove();
+            this.controlsUI = null;
+        }
+    }
+    destroy() {
+        super.destroy();
+        this.dismissControlsUI();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/games/examples/vehicle/mesh-vehicle.d.ts

@@ -0,0 +1,19 @@
+import * as ENGINE from 'genesys.js';
+import { BaseVehicle } from './base-vehicle.js';
+/**
+ * A vehicle that uses a 3D mesh model for visual representation
+ *
+ * Key points:
+ * - Uses invisible collision box for physics simulation (separate from visual mesh)
+ * - Loads GLB model for visual representation via GLTFMeshComponent
+ * - Movement parameters configured in createVehicleMovementComponent
+ * - No component is persisted (root is transient) in order to support recreating all the components in code (which is desired)
+ * - Do not create the builtin wheel mesh since the GLB models are used instead (createWheelMeshes = false)
+ * - Visual mesh is positioned and scaled to match collision box
+ * - Wheel mesh transforms are updated using the onWheelUpdated delegate
+ *
+ */
+export declare class MeshVehicle extends BaseVehicle {
+    constructor(options: ENGINE.PawnOptions);
+    static createVehicleMovementComponent(): ENGINE.VehicleMovementComponent;
+}

package/dist/games/examples/vehicle/mesh-vehicle.js

@@ -0,0 +1,194 @@
+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 MeshVehicle_1;
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { BaseVehicle } from './base-vehicle.js';
+/**
+ * A vehicle that uses a 3D mesh model for visual representation
+ *
+ * Key points:
+ * - Uses invisible collision box for physics simulation (separate from visual mesh)
+ * - Loads GLB model for visual representation via GLTFMeshComponent
+ * - Movement parameters configured in createVehicleMovementComponent
+ * - No component is persisted (root is transient) in order to support recreating all the components in code (which is desired)
+ * - Do not create the builtin wheel mesh since the GLB models are used instead (createWheelMeshes = false)
+ * - Visual mesh is positioned and scaled to match collision box
+ * - Wheel mesh transforms are updated using the onWheelUpdated delegate
+ *
+ */
+let MeshVehicle = MeshVehicle_1 = class MeshVehicle extends BaseVehicle {
+    constructor(options) {
+        // the root component is only used for collision and physics simulation
+        const rootComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(2.77, 1.79, 5.75),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x4444FF,
+                roughness: 0.7,
+                metalness: 0.3,
+                visible: false,
+                transparent: true,
+                opacity: 0.5,
+            }),
+            physicsOptions: {
+                enabled: true,
+                motionType: ENGINE.PhysicsMotionType.Dynamic,
+                generateCollisionEvents: true,
+            },
+        });
+        rootComponent.name = 'root';
+        options.rootComponent = rootComponent;
+        // mark the component as transient, this prevents all the components from being saved since we're recreating them in code
+        rootComponent.setTransient(true);
+        const chassisComponent = new ENGINE.GLTFMeshComponent({
+            modelUrl: '@engine/assets/dev/models/Vehicles/cyberTruck/chassis.glb',
+            position: new THREE.Vector3(0, 0, -0.75),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x4444FF,
+                roughness: 0.7,
+                metalness: 0.3,
+            }),
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        chassisComponent.castShadow = true;
+        chassisComponent.name = 'chassis';
+        rootComponent.add(chassisComponent);
+        const wheelMeshes = [];
+        for (let i = 0; i < 4; i++) {
+            const wheelComponent = new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/dev/models/Vehicles/cyberTruck/wheel.glb',
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x44FF44,
+                    roughness: 0.7,
+                    metalness: 0.3,
+                }),
+                physicsOptions: {
+                    enabled: false,
+                }
+            });
+            wheelComponent.castShadow = true;
+            wheelComponent.name = `wheel_${i}`;
+            wheelMeshes.push(wheelComponent);
+        }
+        rootComponent.add(...wheelMeshes);
+        const vehicleMovementComponent = MeshVehicle_1.createVehicleMovementComponent();
+        options.movementComponent = vehicleMovementComponent;
+        super(options);
+        const wheelComponents = this.getComponents(ENGINE.GLTFMeshComponent).filter(component => component.name.startsWith('wheel_'));
+        vehicleMovementComponent.onWheelUpdated.add((component, wheelIndex, wheelState) => {
+            // The first mesh component is the chassis component, so we need to skip it
+            const wheelMesh = wheelComponents[wheelIndex];
+            // Apply the final transformation to the wheel mesh
+            wheelMesh.position.copy(wheelState.relativePosition);
+            wheelMesh.quaternion.copy(wheelState.relativeQuaternion);
+            // Apply additional 180-degree rotation around Y-axis for wheels 0 and 2
+            if (wheelIndex === 0 || wheelIndex === 2) {
+                const yRotation = new THREE.Quaternion();
+                yRotation.setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+                wheelMesh.quaternion.multiplyQuaternions(wheelMesh.quaternion, yRotation);
+            }
+        });
+    }
+    static createVehicleMovementComponent() {
+        const wheelBaseWidth = 3.2;
+        const wheelBaseLength = 3.8;
+        const wheelBaseHeight = -0.5;
+        const wheelRadius = 0.55;
+        const suspensionRestLength = 0.8;
+        const wheelWidth = 0.53;
+        const suspensionStiffness = 20;
+        const suspensionCompression = 1.83;
+        const suspensionRelaxation = 1.88;
+        const sideFrictionStiffness = 2;
+        const frictionSlip = 50;
+        // Create vehicle movement component
+        const vehicleMovement = new ENGINE.VehicleMovementComponent({
+            ...ENGINE.BasePawnMovementComponent.DEFAULT_OPTIONS,
+            createWheelMeshes: false,
+            maxEnginePower: 100,
+            maxBrakeForce: 1.5,
+            maxSteeringAngle: Math.PI / 6, // 30 degrees
+            engineResponseRate: 8.0,
+            steeringResponseRate: 12.0,
+            brakeResponseRate: 15.0,
+            wheelMaterialColor: 0x333333,
+            autoBreakWhenNotPossessed: 1,
+            autoStopBreak: 1,
+            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,
+                    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,
+                    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,
+                    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,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+            ],
+        });
+        return vehicleMovement;
+    }
+};
+MeshVehicle = MeshVehicle_1 = __decorate([
+    ENGINE.GameClass(),
+    __metadata("design:paramtypes", [Object])
+], MeshVehicle);
+export { MeshVehicle };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/games/examples/vehicle/player.d.ts

@@ -0,0 +1,9 @@
+import * as ENGINE from 'genesys.js';
+import { BaseVehicle } from './base-vehicle.js';
+export declare class VehicleGamePlayer extends ENGINE.ThirdPersonCharacterPawn {
+    constructor(options: ENGINE.ActorOptions);
+    protected doBeginPlay(): void;
+    protected setupVehicleInteraction(): void;
+    protected tryEnterVehicle(): void;
+    protected enterVehicle(vehicle: BaseVehicle): void;
+}

package/dist/games/examples/vehicle/player.js

@@ -0,0 +1,87 @@
+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);
+};
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { BaseVehicle } from './base-vehicle.js';
+let VehicleGamePlayer = class VehicleGamePlayer extends ENGINE.ThirdPersonCharacterPawn {
+    constructor(options) {
+        const camera = new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR);
+        camera.position.set(0, ENGINE.CHARACTER_HEIGHT * 1.3, ENGINE.CHARACTER_HEIGHT * 2);
+        camera.lookAt(0, 0, 0);
+        const rootComponent = new ENGINE.MeshComponent({
+            geometry: ENGINE.GameBuilder.createDefaultPawnCapsuleGeometry(),
+            material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW, visible: false, transparent: true, opacity: 0.5 }),
+            physicsOptions: {
+                enabled: true,
+                motionType: ENGINE.PhysicsMotionType.KinematicVelocityBased,
+                collisionProfile: ENGINE.DefaultCollisionProfile.Character,
+            },
+        });
+        const movementComponent = new ENGINE.CharacterMovementComponent({
+            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+            movementType: ENGINE.CharacterMovementType.ThirdPerson,
+        });
+        super({
+            ...options,
+            modelUrl: '@engine/assets/character/mannequinG.glb',
+            configUrl: '@engine/assets/character/config/mannequin-anim.json',
+            meshPosition: new THREE.Vector3(0, -ENGINE.CHARACTER_HEIGHT / 2, 0),
+            meshRotation: new THREE.Euler(0, Math.PI, 0),
+            meshScale: new THREE.Vector3(1, 1, 1),
+            movementComponent,
+            rootComponent,
+            camera,
+        });
+    }
+    doBeginPlay() {
+        super.doBeginPlay();
+        this.setupVehicleInteraction();
+    }
+    setupVehicleInteraction() {
+        // Add E key input handler for vehicle possession
+        this.onKeyDown.add((e) => {
+            if (e.key.toLowerCase() === 'e') {
+                this.tryEnterVehicle();
+                return true;
+            }
+            return false;
+        });
+    }
+    tryEnterVehicle() {
+        // Find nearby vehicles that can be entered
+        const vehicles = this.world.getActors(BaseVehicle);
+        for (const vehicle of vehicles) {
+            if (vehicle.canBeEntered() && vehicle.getNearbyPlayer() === this) {
+                this.enterVehicle(vehicle);
+                break;
+            }
+        }
+    }
+    enterVehicle(vehicle) {
+        // Get the current player controller
+        const controller = this.getPlayerController();
+        if (controller) {
+            // Set this player as the entered player in the vehicle
+            vehicle.setEnteredPlayer(this);
+            // Unpossess current pawn and possess the vehicle
+            controller.unpossess();
+            controller.possess(vehicle);
+            // Hide the player character
+            this.rootComponent.visible = false;
+            vehicle.onPlayerEntered();
+        }
+    }
+};
+VehicleGamePlayer = __decorate([
+    ENGINE.GameClass(),
+    __metadata("design:paramtypes", [Object])
+], VehicleGamePlayer);
+export { VehicleGamePlayer };
+//# sourceMappingURL=data:application/json;base64,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