@directivegames/genesys.sdk 3.2.2

package/dist/src/templates/src/templates/vehicle/src/auto-imports.js

@@ -0,0 +1 @@
+export {};

package/dist/src/templates/src/templates/vehicle/src/base-vehicle.js

@@ -0,0 +1,122 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { VehiclePlayer } 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 {
+    interactionDistance = 5;
+    nearbyPlayer = null;
+    enteredPlayer = 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(VehiclePlayer);
+        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;
+    }
+    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)
+            this.enteredPlayer.rootComponent.rotation.x = 0;
+            this.enteredPlayer.rootComponent.rotation.z = 0;
+            this.enteredPlayer.rootComponent.rotation.y = this.rootComponent.rotation.y;
+            // 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);
+    }
+}

package/dist/src/templates/src/templates/vehicle/src/game.js

@@ -0,0 +1,33 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import './auto-imports.js';
+import { VehiclePlayer } from './player.js';
+import { UIHints } from './ui-hints.js';
+class MyGame extends ENGINE.BaseGameLoop {
+    pawn = null;
+    controller = null;
+    createLoadingScreen() {
+        // enable the default loading screen
+        return new ENGINE.DefaultLoadingScreen();
+    }
+    async preStart() {
+        // default spawn location
+        const position = new THREE.Vector3(0, ENGINE.CHARACTER_HEIGHT / 2, 0);
+        // create the pawn
+        this.pawn = new VehiclePlayer({ position });
+        // create the controller and possess the pawn
+        this.controller = new ENGINE.PlayerController();
+        this.controller.possess(this.pawn);
+        // create UI hints
+        const uiHints = new UIHints();
+        // add all actors to the world
+        this.world.addActors(this.pawn, this.controller, uiHints);
+    }
+}
+export function main(container, gameId) {
+    const game = new MyGame(container, {
+        ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+        gameId
+    });
+    return game;
+}

package/dist/src/templates/src/templates/vehicle/src/mesh-vehicle.js

@@ -0,0 +1,189 @@
+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 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: '@project/assets/models/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: '@project/assets/models/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()
+], MeshVehicle);
+export { MeshVehicle };

package/dist/src/templates/src/templates/vehicle/src/player.js

@@ -0,0 +1,102 @@
+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;
+};
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { BaseVehicle } from './base-vehicle.js';
+/**
+ * A vehicle player class.
+ *
+ * Key points:
+ * - No need to provide movementComponent and camera, they are created internally
+ * - The pawn is set to be transient so it's never saved in the level
+ * - The directional light follows the player for consistent shadows
+ *
+ */
+let VehiclePlayer = class VehiclePlayer extends ENGINE.ThirdPersonCharacterPawn {
+    // Omit all the options that are created internally
+    constructor(options) {
+        // simple camera component - contains a perspective camera by default
+        const camera = new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, 0.1, 1000);
+        // set camera position for third person view
+        camera.position.set(0, ENGINE.CHARACTER_HEIGHT * 1.3, ENGINE.CHARACTER_HEIGHT * 2);
+        camera.lookAt(0, 0, 0);
+        // use capsule root component for collision
+        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,
+                // KinematicVelocityBased is required to use the physics character controller
+                motionType: ENGINE.PhysicsMotionType.KinematicVelocityBased,
+                collisionProfile: ENGINE.DefaultCollisionProfile.Character,
+            },
+        });
+        // use third person movement mechanics
+        const movementComponent = new ENGINE.CharacterMovementComponent({
+            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+            movementType: ENGINE.CharacterMovementType.ThirdPerson,
+        });
+        // construct the pawn
+        super({
+            ...options,
+            rootComponent,
+            movementComponent,
+            camera,
+            // make sure the directional light follows the player for consistent shadows
+            enableDirectionalLightFollowing: true,
+            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),
+        });
+        // set the pawn to be transient so it's never saved in the level
+        this.setTransient(true);
+    }
+    async doBeginPlay() {
+        await 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;
+            this.rootComponent.setPhysicsEnabled(false);
+        }
+    }
+};
+VehiclePlayer = __decorate([
+    ENGINE.GameClass()
+], VehiclePlayer);
+export { VehiclePlayer };