@gnsx/genesys.sdk 4.2.9

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

@@ -0,0 +1,102 @@
+import * as ENGINE from '@gnsx/genesys.js';
+import * as THREE from 'three';
+import './auto-imports.js';
+import { SideScrollerLevelGenerator } from './level-generator.js';
+import { SideScrollerPlayer } from './player.js';
+// ============================================================================
+// SIDE SCROLLER GAME
+// ============================================================================
+// A side-scroller game with animated character and infinite level generation
+class SideScrollerGame extends ENGINE.BaseGameLoop {
+    player = null;
+    playerController = null;
+    levelGenerator = null;
+    createLoadingScreen() {
+        // enable the default loading screen
+        return new ENGINE.DefaultLoadingScreen();
+    }
+    async preStart() {
+        this.createLevel();
+        this.createPlayer();
+    }
+    tick(tickTime) {
+        super.tick(tickTime);
+        // Update level generation based on player position
+        if (this.player && this.levelGenerator) {
+            const playerPosition = this.player.getWorldPosition();
+            this.levelGenerator.updateLevel(playerPosition.x);
+        }
+    }
+    createPlayer() {
+        const spawnX = 1;
+        // Create the side-scroller player with animated character
+        const position = new THREE.Vector3(spawnX, ENGINE.CHARACTER_HEIGHT / 2, 0);
+        this.player = SideScrollerPlayer.create({ position });
+        // Create the controller and possess the player
+        this.playerController = ENGINE.PlayerController.create();
+        this.playerController.possess(this.player);
+        // Add both to the world
+        this.world.addActors(this.player, this.playerController);
+        this.setInitialPlayerPosition(spawnX);
+    }
+    /**
+     * Sets the initial position of the player.
+     * @param spawnX - The X coordinate to spawn the player at.
+     */
+    setInitialPlayerPosition(spawnX) {
+        const groundHeight = this.findGroundHeightAtX(spawnX);
+        if (groundHeight !== null) {
+            this.player?.setWorldPosition(new THREE.Vector3(spawnX, groundHeight + ENGINE.CHARACTER_HEIGHT / 2, 0));
+        }
+        else {
+            this.world.runInNextTick(() => {
+                this.setInitialPlayerPosition(spawnX);
+            });
+        }
+    }
+    /**
+     * Performs a hit test to find the ground height at a given X coordinate
+     * @param x - The X coordinate to test
+     * @returns The Y coordinate of the ground surface, or 0 if no ground is found
+     */
+    findGroundHeightAtX(x) {
+        // Start from a high position and cast downward
+        const rayOrigin = new THREE.Vector3(x, 50, 0);
+        const rayDirection = new THREE.Vector3(0, -1, 0); // Downward
+        const hitResults = this.world.getPhysicsEngine()?.performHitTest({
+            origin: rayOrigin,
+            direction: rayDirection,
+            maxDistance: 100, // Cast ray down 100 units
+            stopOnFirstHit: true,
+        });
+        if (hitResults && hitResults.length > 0) {
+            // Return the Y coordinate of the hit location (top surface of ground)
+            return hitResults[0].hitLocation.y;
+        }
+        return null;
+    }
+    createLevel() {
+        // Create the level generator
+        this.levelGenerator = new SideScrollerLevelGenerator(this.world, {
+            enableDebugVisualization: false,
+            createGroundMesh: true
+        });
+        // Generate initial level chunks
+        this.levelGenerator.updateLevel(0);
+    }
+    destroy() {
+        // Clean up level generator
+        if (this.levelGenerator) {
+            this.levelGenerator.cleanup();
+            this.levelGenerator = null;
+        }
+        super.destroy();
+    }
+}
+export function main(container, gameId) {
+    const game = new SideScrollerGame(container, {
+        ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+        gameId
+    });
+    return game;
+}

package/dist/src/templates/src/templates/sideScroller/src/level-generator.js

@@ -0,0 +1,249 @@
+import * as ENGINE from '@gnsx/genesys.js';
+import * as THREE from 'three';
+import { COLORS, LEVEL_CONFIG } from './const.js';
+// Simple level generator for infinite side-scrolling levels
+export class SideScrollerLevelGenerator {
+    world;
+    // Map of chunk index to chunk
+    levelChunks = new Map();
+    // Configuration
+    chunkSize;
+    chunksAhead;
+    chunksBehind;
+    platformHeightRange;
+    platformWidthRange;
+    obstacleHeightRange;
+    chunkMargin;
+    minSpacing;
+    debugVisualizationEnabled = false;
+    createGroundMesh = false;
+    constructor(world, options = {}) {
+        this.world = world;
+        // Apply defaults
+        this.chunkSize = options.chunkSize ?? LEVEL_CONFIG.CHUNK_SIZE;
+        this.chunksAhead = options.chunksAhead ?? LEVEL_CONFIG.CHUNKS_AHEAD;
+        this.chunksBehind = options.chunksBehind ?? LEVEL_CONFIG.CHUNKS_BEHIND;
+        this.platformHeightRange = options.platformHeightRange ?? LEVEL_CONFIG.PLATFORM_HEIGHT_RANGE;
+        this.platformWidthRange = options.platformWidthRange ?? LEVEL_CONFIG.PLATFORM_WIDTH_RANGE;
+        this.obstacleHeightRange = options.obstacleHeightRange ?? LEVEL_CONFIG.OBSTACLE_HEIGHT_RANGE;
+        this.chunkMargin = options.chunkMargin ?? LEVEL_CONFIG.CHUNK_MARGIN;
+        this.minSpacing = options.minSpacing ?? LEVEL_CONFIG.MIN_SPACING;
+        this.debugVisualizationEnabled = options.enableDebugVisualization ?? false;
+        this.createGroundMesh = options.createGroundMesh ?? false;
+    }
+    updateLevel(playerX) {
+        const playerChunkIndex = this.getChunkIndex(playerX);
+        const validChunkIndices = [];
+        for (let i = playerChunkIndex - this.chunksBehind; i <= playerChunkIndex + this.chunksAhead; i++) {
+            this.generateChunk(i);
+            validChunkIndices.push(i);
+        }
+        for (const index of this.levelChunks.keys()) {
+            if (!validChunkIndices.includes(index)) {
+                this.removeChunk(index);
+            }
+        }
+    }
+    getChunkIndex(x) {
+        return Math.floor(x / this.chunkSize);
+    }
+    removeChunk(index) {
+        const chunk = this.levelChunks.get(index);
+        if (chunk) {
+            this.world.removeActors(...chunk.actors);
+            this.levelChunks.delete(index);
+            console.log(`[LevelGenerator] Removed chunk at index ${index}`);
+        }
+    }
+    generateChunk(index) {
+        if (this.levelChunks.has(index)) {
+            return;
+        }
+        const startX = index * this.chunkSize;
+        const endX = startX + this.chunkSize;
+        const actors = [];
+        // Generate positioned elements for this chunk
+        const elements = this.generatePositionedElements(startX);
+        // Create actors for each element
+        for (const element of elements) {
+            const actor = this.createElementActor(element);
+            actors.push(actor);
+        }
+        // Add ground mesh if enabled
+        if (this.createGroundMesh) {
+            const groundActor = this.createGroundMeshActor(startX);
+            actors.push(groundActor);
+        }
+        // Add debug visualization if enabled
+        if (this.debugVisualizationEnabled) {
+            const debugActor = this.createChunkDebugVisualization(startX);
+            actors.push(debugActor);
+        }
+        // Add all actors to the world
+        this.world.addActors(...actors);
+        // Track this chunk
+        const chunk = {
+            startX,
+            endX,
+            actors,
+        };
+        console.log(`[LevelGenerator] Generated chunk at index ${index}`);
+        this.levelChunks.set(index, chunk);
+    }
+    generatePositionedElements(startX) {
+        const elements = [];
+        const usableWidth = this.chunkSize - (this.chunkMargin * 2); // Leave margin on each side
+        const usableStartX = startX + this.chunkMargin;
+        // Simple alternating generation: platform -> obstacle -> platform -> obstacle...
+        const totalElements = Math.floor(usableWidth / this.minSpacing); // How many elements can fit
+        let currentX = usableStartX;
+        let isPlatform = true; // Start with platform
+        for (let i = 0; i < totalElements && currentX < (startX + this.chunkSize - this.chunkMargin); i++) {
+            if (isPlatform) {
+                // Generate platform with random dimensions
+                const width = this.platformWidthRange.min +
+                    Math.random() * (this.platformWidthRange.max - this.platformWidthRange.min);
+                const height = this.platformHeightRange.min +
+                    Math.random() * (this.platformHeightRange.max - this.platformHeightRange.min);
+                elements.push({
+                    x: currentX + width / 2, // Center position
+                    width: width,
+                    height: height,
+                    type: 'platform'
+                });
+                currentX += width + this.minSpacing; // Move past this platform plus spacing
+            }
+            else {
+                // Generate obstacle with random dimensions
+                const width = LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.min +
+                    Math.random() * (LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.max - LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.min);
+                const height = this.obstacleHeightRange.min +
+                    Math.random() * (this.obstacleHeightRange.max - this.obstacleHeightRange.min);
+                elements.push({
+                    x: currentX + width / 2, // Center position
+                    width: width,
+                    height: height,
+                    type: 'obstacle'
+                });
+                currentX += width + this.minSpacing; // Move past this obstacle plus spacing
+            }
+            // Alternate between platform and obstacle
+            isPlatform = !isPlatform;
+        }
+        return elements;
+    }
+    createElementActor(element) {
+        const geometry = new THREE.BoxGeometry(element.width, element.height, LEVEL_CONFIG.DEPTH);
+        const material = new THREE.MeshStandardMaterial({ color: element.type === 'platform' ? COLORS.PLATFORM : COLORS.OBSTACLE });
+        const meshComponent = ENGINE.MeshComponent.create({
+            geometry: geometry,
+            material: material,
+            position: new THREE.Vector3(element.x, element.height / 2, 0), // Position at ground level
+            physicsOptions: {
+                enabled: true,
+                motionType: ENGINE.PhysicsMotionType.Static,
+                collisionProfile: ENGINE.DefaultCollisionProfile.BlockAll,
+            },
+        });
+        // Enable shadow casting and receiving
+        meshComponent.castShadow = true;
+        meshComponent.receiveShadow = true;
+        const actor = ENGINE.Actor.create();
+        actor.setRootComponent(meshComponent, false);
+        return actor;
+    }
+    createChunkDebugVisualization(startX) {
+        // Create a wireframe box to visualize chunk boundaries
+        const chunkGeometry = new THREE.BoxGeometry(this.chunkSize, LEVEL_CONFIG.DEBUG_VISUALIZATION_HEIGHT, LEVEL_CONFIG.DEPTH);
+        const chunkMaterial = new THREE.MeshBasicMaterial({
+            color: LEVEL_CONFIG.DEBUG_VISUALIZATION_COLOR,
+            opacity: LEVEL_CONFIG.DEBUG_VISUALIZATION_OPACITY,
+            wireframe: true,
+            transparent: true,
+        });
+        const meshComponent = ENGINE.MeshComponent.create({
+            geometry: chunkGeometry,
+            material: chunkMaterial,
+            position: new THREE.Vector3(startX + this.chunkSize / 2, LEVEL_CONFIG.DEBUG_VISUALIZATION_HEIGHT / 2, 0),
+            physicsOptions: {
+                enabled: false,
+            },
+        });
+        const chunkBoundary = ENGINE.Actor.create();
+        chunkBoundary.setRootComponent(meshComponent, false);
+        return chunkBoundary;
+    }
+    createGroundMeshActor(startX) {
+        // Create a ground mesh that spans the entire chunk width
+        const groundGeometry = new THREE.BoxGeometry(this.chunkSize, LEVEL_CONFIG.GROUND_HEIGHT, LEVEL_CONFIG.DEPTH);
+        const groundMaterial = new THREE.MeshStandardMaterial({
+            color: COLORS.GROUND,
+        });
+        const groundMeshComponent = ENGINE.MeshComponent.create({
+            geometry: groundGeometry,
+            material: groundMaterial,
+            position: new THREE.Vector3(startX + this.chunkSize / 2, LEVEL_CONFIG.GROUND_Y_POSITION, 0),
+            physicsOptions: {
+                enabled: true,
+                motionType: ENGINE.PhysicsMotionType.Static,
+                collisionProfile: ENGINE.DefaultCollisionProfile.BlockAll,
+            },
+        });
+        // Enable shadow receiving
+        groundMeshComponent.receiveShadow = true;
+        const actor = ENGINE.Actor.create();
+        actor.setRootComponent(groundMeshComponent, false);
+        return actor;
+    }
+    /**
+     * Gets detailed geometry information at a given x location.
+     * @param x - The x coordinate to query
+     * @returns An array of geometry info objects at the given x location
+     */
+    getGeometryInfoAtX(x) {
+        const chunkIndex = this.getChunkIndex(x);
+        const chunk = this.levelChunks.get(chunkIndex);
+        if (!chunk) {
+            return [];
+        }
+        const geometries = [];
+        // Add ground mesh if enabled
+        if (this.createGroundMesh) {
+            const groundCenterY = LEVEL_CONFIG.GROUND_Y_POSITION;
+            const groundHalfHeight = LEVEL_CONFIG.GROUND_HEIGHT / 2;
+            geometries.push({
+                type: 'ground',
+                topY: groundCenterY + groundHalfHeight,
+                bottomY: groundCenterY - groundHalfHeight,
+                width: this.chunkSize,
+                centerX: chunk.startX + this.chunkSize / 2
+            });
+        }
+        // Add positioned elements (platforms and obstacles)
+        const elements = this.generatePositionedElements(chunk.startX);
+        for (const element of elements) {
+            const elementLeft = element.x - element.width / 2;
+            const elementRight = element.x + element.width / 2;
+            // Check if the x coordinate falls within this element's bounds
+            if (x >= elementLeft && x <= elementRight) {
+                geometries.push({
+                    type: element.type,
+                    topY: element.height,
+                    bottomY: 0, // Elements are positioned at ground level (y=0 bottom)
+                    width: element.width,
+                    centerX: element.x
+                });
+            }
+        }
+        // Sort by top height (highest first)
+        geometries.sort((a, b) => b.topY - a.topY);
+        return geometries;
+    }
+    cleanup() {
+        for (const index of this.levelChunks.keys()) {
+            this.removeChunk(index);
+        }
+        this.levelChunks.clear();
+        console.log('[LevelGenerator] Cleaned up');
+    }
+}

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

@@ -0,0 +1,100 @@
+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 '@gnsx/genesys.js';
+import * as THREE from 'three';
+import { CAMERA_SETTINGS, PLAYER_MOVEMENT } from './const.js';
+// ============================================================================
+// PLAYER PAWN
+// ============================================================================
+// The side-scroller player pawn class using animated character.
+let SideScrollerPlayer = class SideScrollerPlayer extends ENGINE.ThirdPersonCharacterPawn {
+    camera;
+    characterMesh = null;
+    smoothedCameraHeight = null;
+    smoothedLookAtHeight = null;
+    constructor() {
+        super();
+        // Create directional movement component for side-scrolling
+        const movementComponent = ENGINE.DirectionalCharacterMovementComponent.create({
+            direction: ENGINE.CharacterMovementDirection.LeftRight, // Move left and right
+            autoMove: false, // Player controls movement manually
+            jumpSpeed: PLAYER_MOVEMENT.JUMP_SPEED,
+            maxSpeed: PLAYER_MOVEMENT.MAX_SPEED,
+            maxMidAirJumps: PLAYER_MOVEMENT.MAX_MID_AIR_JUMPS, // Allow double jump
+            // Physics and movement settings for platformer feel
+            accelerationLambda: PLAYER_MOVEMENT.ACCELERATION_LAMBDA,
+            decelerationLambda: PLAYER_MOVEMENT.DECELERATION_LAMBDA,
+            midAirAccelerationLambda: PLAYER_MOVEMENT.MID_AIR_ACCELERATION_LAMBDA,
+            midAirDecelerationLambda: PLAYER_MOVEMENT.MID_AIR_DECELERATION_LAMBDA,
+        });
+        // Physics options for the player
+        const physicsOptions = {
+            enabled: true,
+            motionType: ENGINE.PhysicsMotionType.KinematicVelocityBased,
+            collisionProfile: ENGINE.DefaultCollisionProfile.Character,
+            generateCollisionEvents: true,
+        };
+        // Create root component with physics (invisible capsule for collision)
+        const rootComponent = ENGINE.MeshComponent.create({
+            geometry: new THREE.CapsuleGeometry(ENGINE.CHARACTER_WIDTH / 2, ENGINE.CHARACTER_HEIGHT - ENGINE.CHARACTER_WIDTH),
+            material: new THREE.MeshStandardMaterial({
+                color: 0xffff00,
+                visible: false, // Make invisible since we'll have the animated character mesh
+                transparent: true,
+                opacity: 0.5
+            }),
+            physicsOptions,
+        });
+        this.setRootComponent(rootComponent, true);
+        this.movementComponent = movementComponent;
+        // Use default character model from engine assets
+        this.configUrl = '@engine/assets/character/config/mannequin-anim.json';
+        this.meshComponent.position.copy(new THREE.Vector3(0, -ENGINE.CHARACTER_HEIGHT / 2, 0));
+        this.meshComponent.rotation.copy(new THREE.Euler(0, Math.PI, 0)); // Face right initially
+        rootComponent.add(this.meshComponent);
+        // Enable shadow casting for the character
+        this.rootComponent.castShadow = true;
+        this.camera = new THREE.PerspectiveCamera(CAMERA_SETTINGS.FOV, 1, CAMERA_SETTINGS.NEAR, CAMERA_SETTINGS.FAR);
+        this.enableDirectionalLightFollowing = true;
+    }
+    doBeginPlay() {
+        super.doBeginPlay();
+        this.getWorld()?.setOverrideCamera(this.camera);
+    }
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        // manually update the camera position
+        const desiredCameraPosition = this.rootComponent.localToWorld(new THREE.Vector3(CAMERA_SETTINGS.POSITION.x, CAMERA_SETTINGS.POSITION.y, CAMERA_SETTINGS.POSITION.z));
+        const desiredCameraLookAt = this.rootComponent.localToWorld(new THREE.Vector3(CAMERA_SETTINGS.LOOK_AT.x, CAMERA_SETTINGS.LOOK_AT.y, CAMERA_SETTINGS.LOOK_AT.z));
+        this.smoothedCameraHeight ??= desiredCameraPosition.y;
+        this.smoothedLookAtHeight ??= desiredCameraLookAt.y;
+        this.smoothedCameraHeight = THREE.MathUtils.damp(this.smoothedCameraHeight, desiredCameraPosition.y, CAMERA_SETTINGS.DAMP_FACTOR, deltaTime);
+        this.smoothedLookAtHeight = THREE.MathUtils.damp(this.smoothedLookAtHeight, desiredCameraLookAt.y, CAMERA_SETTINGS.DAMP_FACTOR, deltaTime);
+        this.camera.position.x = desiredCameraPosition.x;
+        this.camera.position.y = this.smoothedCameraHeight;
+        this.camera.position.z = desiredCameraPosition.z;
+        this.camera.lookAt(new THREE.Vector3(desiredCameraLookAt.x, this.smoothedLookAtHeight, desiredCameraLookAt.z));
+        // change the direction of the character mesh based on the movement direction
+        this.characterMesh ??= this.getComponent(ENGINE.GLTFMeshComponent);
+        if (this.characterMesh && this.movementComponent) {
+            const movementComponent = this.movementComponent;
+            const velocity = movementComponent.getVelocities();
+            if (velocity.right > 0.1) {
+                // Moving right - face right (90 degrees)
+                this.characterMesh.rotation.set(0, Math.PI / 2, 0);
+            }
+            else if (velocity.right < -0.1) {
+                // Moving left - face left (-90 degrees)
+                this.characterMesh.rotation.set(0, -Math.PI / 2, 0);
+            }
+        }
+    }
+};
+SideScrollerPlayer = __decorate([
+    ENGINE.GameClass()
+], SideScrollerPlayer);
+export { SideScrollerPlayer };

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

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

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

@@ -0,0 +1,30 @@
+import * as ENGINE from '@gnsx/genesys.js';
+import * as THREE from 'three';
+import { ThirdPersonPlayer } from './player.js';
+import './auto-imports.js';
+class ThirdPersonGame 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 = ThirdPersonPlayer.create({ position });
+        // create the controller and possess the pawn
+        this.controller = ENGINE.PlayerController.create();
+        this.controller.possess(this.pawn);
+        // add both to the world
+        this.world.addActors(this.pawn, this.controller);
+    }
+}
+export function main(container, gameId) {
+    const game = new ThirdPersonGame(container, {
+        ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+        gameId
+    });
+    return game;
+}

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

@@ -0,0 +1,58 @@
+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 '@gnsx/genesys.js';
+import * as THREE from 'three';
+/**
+ * A third person 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 ThirdPersonPlayer = class ThirdPersonPlayer extends ENGINE.ThirdPersonCharacterPawn {
+    // Omit all the options that are created internally
+    constructor() {
+        super();
+        // 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 = ENGINE.MeshComponent.create({
+            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,
+            },
+        });
+        this.setRootComponent(rootComponent, true);
+        // use third person movement mechanics
+        const movementComponent = ENGINE.CharacterMovementComponent.create({
+            movementType: ENGINE.CharacterMovementType.ThirdPerson,
+        });
+        this.movementComponent = movementComponent;
+        rootComponent.add(camera);
+        this.enableDirectionalLightFollowing = true;
+        // Character model settings
+        this.configUrl = '@engine/assets/character/config/mannequin-anim.json';
+        this.meshComponent.position.copy(new THREE.Vector3(0, -ENGINE.CHARACTER_HEIGHT / 2, 0));
+        this.meshComponent.rotation.copy(new THREE.Euler(0, Math.PI, 0));
+        rootComponent.add(this.meshComponent);
+        // set the pawn to be transient so it's never saved in the level
+        this.setTransient(true);
+    }
+};
+ThirdPersonPlayer = __decorate([
+    ENGINE.GameClass()
+], ThirdPersonPlayer);
+export { ThirdPersonPlayer };

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 '@gnsx/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 = ENGINE.FollowComponent.create({
+            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);
+    }
+}