@directivegames/genesys.sdk 3.2.2

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

@@ -0,0 +1,30 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { FreeCameraPlayer } from './player.js';
+import './auto-imports.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, 0);
+        // create the pawn with simple movement mechanics
+        this.pawn = new FreeCameraPlayer({ position });
+        // create the controller and possess the pawn
+        this.controller = new ENGINE.PlayerController();
+        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 MyGame(container, {
+        ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+        gameId
+    });
+    return game;
+}

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

@@ -0,0 +1,43 @@
+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';
+/**
+ * A free camera 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 FreeCameraPlayer = class FreeCameraPlayer extends ENGINE.Pawn {
+    constructor(options) {
+        // simple perspective camera
+        const camera = new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR);
+        // simple movement component, do not use the character controller
+        const movementComponent = new ENGINE.CharacterMovementComponent({
+            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+            // disable the character controller
+            characterControllerOptions: null,
+        });
+        // construct the pawn
+        super({
+            ...options,
+            camera,
+            movementComponent,
+            // make sure the directional light follows the player for consistent shadows
+            enableDirectionalLightFollowing: true,
+        });
+        // set the pawn to be transient so it's never saved in the level
+        this.setTransient(true);
+    }
+};
+FreeCameraPlayer = __decorate([
+    ENGINE.GameClass()
+], FreeCameraPlayer);
+export { FreeCameraPlayer };

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

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

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

@@ -0,0 +1,43 @@
+// Player Movement Configuration
+export const PLAYER_MOVEMENT = {
+    JUMP_SPEED: 20,
+    MAX_SPEED: 8,
+    MAX_MID_AIR_JUMPS: 1,
+    ACCELERATION_LAMBDA: 15,
+    DECELERATION_LAMBDA: 10,
+    MID_AIR_ACCELERATION_LAMBDA: 8,
+    MID_AIR_DECELERATION_LAMBDA: 2,
+};
+// Camera Settings
+export const CAMERA_SETTINGS = {
+    FOV: 60,
+    NEAR: 0.1,
+    FAR: 1000,
+    DAMP_FACTOR: 10,
+    POSITION: { x: 0, y: 1, z: 8 },
+    LOOK_AT: { x: 0, y: 0, z: 0 },
+};
+// Level Generation Configuration
+export const LEVEL_CONFIG = {
+    DEPTH: 3,
+    CHUNK_SIZE: 50,
+    CHUNKS_AHEAD: 2,
+    CHUNKS_BEHIND: 2,
+    PLATFORM_HEIGHT_RANGE: { min: 1, max: 2 },
+    PLATFORM_WIDTH_RANGE: { min: 3, max: 6 },
+    OBSTACLE_HEIGHT_RANGE: { min: 3, max: 6 },
+    OBSTACLE_WIDTH_RANGE: { min: 1.5, max: 3.0 },
+    CHUNK_MARGIN: 0,
+    MIN_SPACING: 4,
+    DEBUG_VISUALIZATION_HEIGHT: 6,
+    DEBUG_VISUALIZATION_OPACITY: 0.3,
+    DEBUG_VISUALIZATION_COLOR: 0x00ff00,
+    GROUND_HEIGHT: 0.1,
+    GROUND_Y_POSITION: -0.05,
+};
+// Material colors
+export const COLORS = {
+    PLATFORM: 0x90ee90, // Light green
+    OBSTACLE: 0xff4444, // Red
+    GROUND: 0x8b4513, // Brown
+};

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

@@ -0,0 +1,103 @@
+import * as ENGINE from '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
+        this.player = new SideScrollerPlayer({
+            position: new THREE.Vector3(spawnX, ENGINE.CHARACTER_HEIGHT / 2, 0),
+        });
+        // Create the controller and possess the player
+        this.playerController = new ENGINE.PlayerController();
+        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 '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 = new ENGINE.MeshComponent({
+            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;
+        return new ENGINE.Actor({
+            rootComponent: meshComponent,
+        });
+    }
+    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 chunkBoundary = new ENGINE.Actor({
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: chunkGeometry,
+                material: chunkMaterial,
+                position: new THREE.Vector3(startX + this.chunkSize / 2, LEVEL_CONFIG.DEBUG_VISUALIZATION_HEIGHT / 2, 0),
+                physicsOptions: {
+                    enabled: 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 = new ENGINE.MeshComponent({
+            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;
+        return new ENGINE.Actor({
+            rootComponent: groundMeshComponent,
+        });
+    }
+    /**
+     * 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,105 @@
+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 { 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(options) {
+        // Create directional movement component for side-scrolling
+        const movementComponent = new ENGINE.DirectionalCharacterMovementComponent({
+            ...ENGINE.DirectionalCharacterMovementComponent.DEFAULT_OPTIONS,
+            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 = new ENGINE.MeshComponent({
+            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,
+        });
+        super({
+            ...options,
+            // Use default character model from engine assets
+            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), // Face right initially
+            meshScale: new THREE.Vector3(1, 1, 1),
+            movementComponent,
+            camera: null, // Do not attach the camera to the player directly
+            rootComponent,
+            enableDirectionalLightFollowing: true,
+        });
+        // 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);
+    }
+    async doBeginPlay() {
+        await 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 '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 = new ThirdPersonPlayer({ position });
+        // create the controller and possess the pawn
+        this.controller = new ENGINE.PlayerController();
+        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,63 @@
+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';
+/**
+ * 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(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);
+    }
+};
+ThirdPersonPlayer = __decorate([
+    ENGINE.GameClass()
+], ThirdPersonPlayer);
+export { ThirdPersonPlayer };