@directivegames/genesys.sdk 4.0.2 → 4.1.0

package/dist/src/core/tools/new-project.js

@@ -27,6 +27,7 @@ export const projectFiles = {
             'remove-engine-comments': 'pnpm exec tsx ./scripts/genesys/remove-engine-comments.ts',
             'dev': 'pnpm exec tsx ./scripts/genesys/dev/generate-manifest.ts && vite',
             'validate-prefabs': 'pnpm exec tsx ./scripts/genesys/validate-prefabs.ts',
+            'migrate-scenes-and-prefabs': 'pnpm exec tsx ./scripts/genesys/migrate-scenes-and-prefabs.ts'
         },
         keywords: [],
         type: 'module',

package/dist/src/dependencies.js

@@ -9,7 +9,7 @@
  * Includes dependencies from the main package.
  */
 export const DEPENDENCIES = {
-    '@directivegames/genesys.js': '4.0.2',
+    '@directivegames/genesys.js': '4.1.0',
     '@electron/rebuild': '4.0.1',
     '@emotion/react': '11.14.0',
     '@emotion/styled': '11.14.1',

package/dist/src/templates/scripts/genesys/migrate-scenes-and-prefabs.js

@@ -0,0 +1,179 @@
+import fs from 'fs';
+import path from 'path';
+import * as ENGINE from '@directivegames/genesys.js';
+import { getProjectRoot } from './common.js';
+import { mockBrowserEnvironment } from './mock.js';
+import { StorageProvider } from './storageProvider.js';
+// Import game module to register game classes (tsx compiles TypeScript on the fly)
+import '../../src/game.js';
+// Set up browser environment for Node.js (provides document, window, etc.)
+mockBrowserEnvironment();
+// Set up storage provider for file operations
+const storageProvider = new StorageProvider();
+ENGINE.projectContext({ project: 'local-project', storageProvider: storageProvider });
+const defaultWorldOptions = {
+    rendererDomElement: document.createElement('div'),
+    gameContainer: document.createElement('div'),
+    backgroundColor: 0x2E2E2E,
+    physicsOptions: {
+        engine: ENGINE.PhysicsEngine.Rapier,
+        gravity: ENGINE.MathHelpers.makeVector({ up: -9.81 }),
+    },
+    navigationOptions: {
+        engine: ENGINE.NavigationEngine.RecastNavigation,
+    },
+    useManifold: true
+};
+function findScenesAndPrefabs(dir, files = []) {
+    const entries = fs.readdirSync(dir);
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            // Skip common directories that shouldn't be processed
+            if (entry === 'node_modules' || entry === 'dist' || entry === '.git' || entry === '.engine') {
+                continue;
+            }
+            findScenesAndPrefabs(fullPath, files);
+        }
+        else if (entry.endsWith('.genesys-scene')) {
+            files.push({ path: fullPath, type: 'scene' });
+        }
+        else if (entry.endsWith('.prefab.json')) {
+            files.push({ path: fullPath, type: 'prefab' });
+        }
+    }
+    return files;
+}
+async function migrateSceneFile(filePath, relativePath) {
+    // Read the file content
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(content);
+    // Create a world and load into it
+    const world = new ENGINE.World(defaultWorldOptions);
+    if (ENGINE.isLegacyData(data)) {
+        // Use WorldSerializer for legacy data
+        await ENGINE.WorldSerializer.loadWorld(world, data);
+    }
+    else {
+        // Use Loader for new format
+        const loader = new ENGINE.Loader();
+        await loader.loadToInstanceAsync(data, world);
+    }
+    // Dump the world
+    const dumper = new ENGINE.Dumper();
+    const newData = dumper.dump(world);
+    // Write back to file
+    const newContent = JSON.stringify(newData, null, 2);
+    fs.writeFileSync(filePath, newContent, 'utf-8');
+    console.log(`✅ ${relativePath}`);
+    return true;
+}
+async function migratePrefabFile(filePath, relativePath) {
+    // Read the file content
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(content);
+    let instance;
+    if (ENGINE.isLegacyData(data)) {
+        // Use WorldSerializer for legacy data
+        console.log(`🔍 Migrating legacy prefab: ${relativePath}`);
+        instance = await ENGINE.WorldSerializer.loadActor(data);
+        console.log(`✅ ${relativePath}`);
+    }
+    else {
+        // Use Loader for new format
+        const loader = new ENGINE.Loader();
+        instance = await loader.loadAsync(data);
+    }
+    if (!instance) {
+        console.log(`⚠️  ${relativePath}: Loaded instance is null, skipping`);
+        return false;
+    }
+    // Dump using Dumper
+    const dumper = new ENGINE.Dumper();
+    const newData = dumper.dump(instance);
+    // Write back to file
+    const newContent = JSON.stringify(newData, null, 2);
+    fs.writeFileSync(filePath, newContent, 'utf-8');
+    console.log(`✅ ${relativePath}`);
+    return true;
+}
+async function migrateFile(fileInfo) {
+    const { path: filePath, type } = fileInfo;
+    const relativePath = path.relative(getProjectRoot(), filePath);
+    try {
+        if (type === 'scene') {
+            return await migrateSceneFile(filePath, relativePath);
+        }
+        else {
+            return await migratePrefabFile(filePath, relativePath);
+        }
+    }
+    catch (error) {
+        console.error(`❌ ${relativePath}: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+    finally {
+        console.log('');
+    }
+}
+async function main() {
+    // Game classes are registered via the top-level import of dist/src/game.js
+    // Make sure to run `pnpm build` first!
+    const projectRoot = getProjectRoot();
+    const assetsFolder = path.join(projectRoot, 'assets');
+    console.log(`📁 Scanning for scene and prefab files in: ${assetsFolder}\n`);
+    // Find all scene and prefab files in the assets folder
+    const files = findScenesAndPrefabs(assetsFolder);
+    if (files.length === 0) {
+        console.log('⚠️  No scene or prefab files found.');
+        return;
+    }
+    const prefabFiles = files.filter(f => f.type === 'prefab');
+    const sceneFiles = files.filter(f => f.type === 'scene');
+    console.log(`Found ${files.length} files to migrate:`);
+    console.log(`  - ${prefabFiles.length} prefab file(s)`);
+    console.log(`  - ${sceneFiles.length} scene file(s)\n`);
+    let successCount = 0;
+    let failCount = 0;
+    // Migrate prefabs first
+    if (prefabFiles.length > 0) {
+        console.log('📦 Migrating prefabs...\n');
+        for (const fileInfo of prefabFiles) {
+            const success = await migrateFile(fileInfo);
+            if (success) {
+                successCount++;
+            }
+            else {
+                failCount++;
+            }
+        }
+    }
+    // Then migrate scenes
+    if (sceneFiles.length > 0) {
+        console.log('\n🌍 Migrating scenes...\n');
+        for (const fileInfo of sceneFiles) {
+            const success = await migrateFile(fileInfo);
+            if (success) {
+                successCount++;
+            }
+            else {
+                failCount++;
+            }
+        }
+    }
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('Migration Summary:');
+    console.log(`  Total files: ${files.length}`);
+    console.log(`  Successful: ${successCount}`);
+    console.log(`  Failed: ${failCount}`);
+    console.log(`${'='.repeat(60)}`);
+    if (failCount > 0) {
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error('Unexpected error:', error);
+    console.error('Stack trace:', error.stack);
+    process.exit(1);
+});

package/dist/src/templates/scripts/genesys/post-install.js

@@ -13,13 +13,21 @@ async function main() {
     fs.mkdirSync(copiedEngineFolder, { recursive: true });
     const foldersToCopy = [
         'games/examples',
-        'src',
-        'docs',
+        'src'
     ];
     for (const folder of foldersToCopy) {
         const engineFolderPath = path.join(engineInstallFolder, folder);
         const localFolderPath = path.join(copiedEngineFolder, folder);
         fs.cpSync(engineFolderPath, localFolderPath, { recursive: true });
     }
+    // copy all *.md files
+    const files = fs.readdirSync(engineInstallFolder);
+    for (const file of files) {
+        if (file.endsWith('.md')) {
+            const engineFilePath = path.join(engineInstallFolder, file);
+            const localFilePath = path.join(copiedEngineFolder, file);
+            fs.copyFileSync(engineFilePath, localFilePath);
+        }
+    }
 }
 main();

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

@@ -13,7 +13,7 @@ class FirstPersonGame extends ENGINE.BaseGameLoop {
         // default spawn location
         const position = new THREE.Vector3(0, ENGINE.CHARACTER_HEIGHT / 2, 0);
         // now create the pawn
-        this.pawn = new FirstPersonPlayer({ position });
+        this.pawn = FirstPersonPlayer.create({ position });
         // create the controller and possess the pawn
         this.controller = new ENGINE.PlayerController();
         this.controller.possess(this.pawn);

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

@@ -17,13 +17,14 @@ import * as THREE from 'three';
  */
 let FirstPersonPlayer = class FirstPersonPlayer extends ENGINE.Pawn {
     // No need to provide rootComponent, movementComponent and camera, they are created internally
-    constructor(options) {
+    constructor() {
+        super();
         // simple camera component - contains a perspective camera by default
         const camera = new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR);
         // set proper camera height for first person view
         camera.position.set(0, ENGINE.CHARACTER_HEIGHT * 0.4, 0);
         // use a simple capsule geometry as the root component
-        const rootComponent = new ENGINE.MeshComponent({
+        const rootComponent = ENGINE.MeshComponent.create({
             geometry: ENGINE.GameBuilder.createDefaultPawnCapsuleGeometry(),
             material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW }),
             physicsOptions: {
@@ -36,20 +37,14 @@ let FirstPersonPlayer = class FirstPersonPlayer extends ENGINE.Pawn {
         });
         // hide the mesh in first person view
         rootComponent.getMesh().visible = false;
+        this.setRootComponent(rootComponent, true);
+        this.rootComponent.add(camera);
         // create the movement component
-        const movementComponent = new ENGINE.CharacterMovementComponent({
-            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+        const movementComponent = ENGINE.CharacterMovementComponent.create({
             movementType: ENGINE.CharacterMovementType.FirstPerson,
         });
-        // construct the pawn
-        super({
-            ...options,
-            rootComponent,
-            movementComponent,
-            // make sure the directional light follows the player for consistent shadows
-            enableDirectionalLightFollowing: true,
-            camera,
-        });
+        this.movementComponent = movementComponent;
+        this.enableDirectionalLightFollowing = true;
         // set the pawn to be transient so it's never saved in the level
         this.setTransient(true);
     }

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

@@ -13,7 +13,7 @@ class MyGame extends ENGINE.BaseGameLoop {
         // default spawn location
         const position = new THREE.Vector3(0, ENGINE.CHARACTER_HEIGHT / 2, 0);
         // now create the pawn
-        this.pawn = new FPSPlayer({ position });
+        this.pawn = FPSPlayer.create({ position });
         // create the controller and possess the pawn
         this.controller = new ENGINE.PlayerController();
         this.controller.possess(this.pawn);

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

@@ -19,7 +19,8 @@ import { DefaultWeapon } from './weapon.js';
  */
 let FPSPlayer = class FPSPlayer extends ENGINE.Pawn {
     // No need to provide rootComponent, movementComponent and camera, they are created internally
-    constructor(options) {
+    constructor() {
+        super();
         // simple camera component - contains a perspective camera by default
         const camera = new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR);
         // set proper camera height for first person view
@@ -28,7 +29,7 @@ let FPSPlayer = class FPSPlayer extends ENGINE.Pawn {
         const weapon = new DefaultWeapon();
         camera.add(weapon);
         // use a simple capsule geometry as the root component
-        const rootComponent = new ENGINE.MeshComponent({
+        const rootComponent = ENGINE.MeshComponent.create({
             geometry: ENGINE.GameBuilder.createDefaultPawnCapsuleGeometry(),
             material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW }),
             physicsOptions: {
@@ -41,19 +42,14 @@ let FPSPlayer = class FPSPlayer extends ENGINE.Pawn {
         });
         // hide the mesh in first person view
         rootComponent.getMesh().visible = false;
+        this.setRootComponent(rootComponent, true);
+        this.rootComponent.add(camera);
         // create the movement component
-        const movementComponent = new ENGINE.CharacterMovementComponent({
-            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+        const movementComponent = ENGINE.CharacterMovementComponent.create({
             movementType: ENGINE.CharacterMovementType.FirstPerson,
         });
-        super({
-            ...options,
-            rootComponent,
-            movementComponent,
-            // make sure the directional light follows the player for consistent shadows
-            enableDirectionalLightFollowing: true,
-            camera
-        });
+        this.movementComponent = movementComponent;
+        this.enableDirectionalLightFollowing = true;
         // set the pawn to be transient so it's never saved in the level
         this.setTransient(true);
     }

package/dist/src/templates/src/templates/fps/src/weapon.js

@@ -15,44 +15,36 @@ import * as THREE from 'three';
  */
 let DefaultWeapon = class DefaultWeapon extends ENGINE.ProjectileWeaponComponent {
     constructor() {
-        super({
-            // firing params
-            fireInterval: 0.1,
-            isSingleFire: false,
-            // configure the weapon model
-            modelPath: '@project/assets/models/SM_Rifle.glb',
-            modelTransform: {
-                position: new THREE.Vector3(0.1, -0.1, -0.25),
-                rotation: new THREE.Euler(0, THREE.MathUtils.degToRad(-90), 0),
-            },
-            // tweak the projectile spawn offset so it matches the muzzle position
-            projectileSpawnOffset: new THREE.Vector3(0.8, -0.6, -2),
-            // add a crosshair
-            crosshairOptions: {
-                size: 10,
-                color: 'white',
-                style: 'dot'
-            },
-            // add weapon sounds
-            fireSoundUrl: '@engine/assets/sounds/game-gun-short.mp3',
-            // enable recoil
-            recoilOptions: {
-                weaponRecoilDistance: 0.05,
-                weaponRecoilDuration: 0.05,
-                weaponRecoilRotation: 0,
-            },
-            // configure the projectile
-            projectileOptions: {
-                velocity: 100,
-                range: 500,
-                lifeSpan: 3,
-                useOverlapCheck: false,
-                destroyOnHit: false,
-                gravityScale: 0,
-                geometry: new THREE.SphereGeometry(0.1),
-                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW })
-            }
-        });
+        super();
+        this.fireInterval = 0.1;
+        this.isSingleFire = false;
+        this.modelPath = '@project/assets/models/SM_Rifle.glb';
+        this.modelTransform = {
+            position: new THREE.Vector3(0.1, -0.1, -0.25),
+            rotation: new THREE.Euler(0, THREE.MathUtils.degToRad(-90), 0),
+        };
+        this.projectileSpawnOffset = new THREE.Vector3(0.8, -0.6, -2);
+        this.crosshairOptions = {
+            size: 10,
+            color: 'white',
+            style: 'dot'
+        };
+        this.fireSoundUrl = '@engine/assets/sounds/game-gun-short.mp3';
+        this.recoilOptions = {
+            weaponRecoilDistance: 0.05,
+            weaponRecoilDuration: 0.05,
+            weaponRecoilRotation: 0,
+        };
+        this.projectileOptions = {
+            velocity: 100,
+            range: 500,
+            lifeSpan: 3,
+            useOverlapCheck: false,
+            destroyOnHit: false,
+            gravityScale: 0,
+            geometry: new THREE.SphereGeometry(0.1),
+            material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW })
+        };
         this.setTransient(true);
     }
 };

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

@@ -13,7 +13,7 @@ class MyGame extends ENGINE.BaseGameLoop {
         // 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 });
+        this.pawn = FreeCameraPlayer.create({ position });
         // create the controller and possess the pawn
         this.controller = new ENGINE.PlayerController();
         this.controller.possess(this.pawn);

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

@@ -16,23 +16,18 @@ import * as THREE from 'three';
  *
  */
 let FreeCameraPlayer = class FreeCameraPlayer extends ENGINE.Pawn {
-    constructor(options) {
+    constructor() {
+        super();
         // simple perspective camera
         const camera = new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR);
+        this.rootComponent.add(camera);
         // simple movement component, do not use the character controller
-        const movementComponent = new ENGINE.CharacterMovementComponent({
-            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+        const movementComponent = ENGINE.CharacterMovementComponent.create({
             // 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,
-        });
+        this.movementComponent = movementComponent;
+        this.enableDirectionalLightFollowing = true;
         // set the pawn to be transient so it's never saved in the level
         this.setTransient(true);
     }

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

@@ -30,9 +30,8 @@ class SideScrollerGame extends ENGINE.BaseGameLoop {
     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),
-        });
+        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 = new ENGINE.PlayerController();
         this.playerController.possess(this.player);

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

@@ -135,7 +135,7 @@ export class SideScrollerLevelGenerator {
     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({
+        const meshComponent = ENGINE.MeshComponent.create({
             geometry: geometry,
             material: material,
             position: new THREE.Vector3(element.x, element.height / 2, 0), // Position at ground level
@@ -148,9 +148,9 @@ export class SideScrollerLevelGenerator {
         // Enable shadow casting and receiving
         meshComponent.castShadow = true;
         meshComponent.receiveShadow = true;
-        return new ENGINE.Actor({
-            rootComponent: meshComponent,
-        });
+        const actor = new ENGINE.Actor();
+        actor.setRootComponent(meshComponent, false);
+        return actor;
     }
     createChunkDebugVisualization(startX) {
         // Create a wireframe box to visualize chunk boundaries
@@ -161,16 +161,16 @@ export class SideScrollerLevelGenerator {
             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,
-                },
-            }),
+        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 = new ENGINE.Actor();
+        chunkBoundary.setRootComponent(meshComponent, false);
         return chunkBoundary;
     }
     createGroundMeshActor(startX) {
@@ -179,7 +179,7 @@ export class SideScrollerLevelGenerator {
         const groundMaterial = new THREE.MeshStandardMaterial({
             color: COLORS.GROUND,
         });
-        const groundMeshComponent = new ENGINE.MeshComponent({
+        const groundMeshComponent = ENGINE.MeshComponent.create({
             geometry: groundGeometry,
             material: groundMaterial,
             position: new THREE.Vector3(startX + this.chunkSize / 2, LEVEL_CONFIG.GROUND_Y_POSITION, 0),
@@ -191,9 +191,9 @@ export class SideScrollerLevelGenerator {
         });
         // Enable shadow receiving
         groundMeshComponent.receiveShadow = true;
-        return new ENGINE.Actor({
-            rootComponent: groundMeshComponent,
-        });
+        const actor = new ENGINE.Actor();
+        actor.setRootComponent(groundMeshComponent, false);
+        return actor;
     }
     /**
      * Gets detailed geometry information at a given x location.

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

@@ -16,10 +16,10 @@ let SideScrollerPlayer = class SideScrollerPlayer extends ENGINE.ThirdPersonChar
     characterMesh = null;
     smoothedCameraHeight = null;
     smoothedLookAtHeight = null;
-    constructor(options) {
+    constructor() {
+        super();
         // Create directional movement component for side-scrolling
-        const movementComponent = new ENGINE.DirectionalCharacterMovementComponent({
-            ...ENGINE.DirectionalCharacterMovementComponent.DEFAULT_OPTIONS,
+        const movementComponent = ENGINE.DirectionalCharacterMovementComponent.create({
             direction: ENGINE.CharacterMovementDirection.LeftRight, // Move left and right
             autoMove: false, // Player controls movement manually
             jumpSpeed: PLAYER_MOVEMENT.JUMP_SPEED,
@@ -39,7 +39,7 @@ let SideScrollerPlayer = class SideScrollerPlayer extends ENGINE.ThirdPersonChar
             generateCollisionEvents: true,
         };
         // Create root component with physics (invisible capsule for collision)
-        const rootComponent = new ENGINE.MeshComponent({
+        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,
@@ -49,22 +49,17 @@ let SideScrollerPlayer = class SideScrollerPlayer extends ENGINE.ThirdPersonChar
             }),
             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,
-        });
+        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;
     }
     async doBeginPlay() {
         await super.doBeginPlay();

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

@@ -13,7 +13,7 @@ class ThirdPersonGame extends ENGINE.BaseGameLoop {
         // default spawn location
         const position = new THREE.Vector3(0, ENGINE.CHARACTER_HEIGHT / 2, 0);
         // create the pawn
-        this.pawn = new ThirdPersonPlayer({ position });
+        this.pawn = ThirdPersonPlayer.create({ position });
         // create the controller and possess the pawn
         this.controller = new ENGINE.PlayerController();
         this.controller.possess(this.pawn);

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

@@ -17,14 +17,15 @@ import * as THREE from 'three';
  */
 let ThirdPersonPlayer = class ThirdPersonPlayer extends ENGINE.ThirdPersonCharacterPawn {
     // Omit all the options that are created internally
-    constructor(options) {
+    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 = new ENGINE.MeshComponent({
+        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: {
@@ -34,25 +35,19 @@ let ThirdPersonPlayer = class ThirdPersonPlayer extends ENGINE.ThirdPersonCharac
                 collisionProfile: ENGINE.DefaultCollisionProfile.Character,
             },
         });
+        this.setRootComponent(rootComponent, true);
         // use third person movement mechanics
-        const movementComponent = new ENGINE.CharacterMovementComponent({
-            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+        const movementComponent = ENGINE.CharacterMovementComponent.create({
             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),
-        });
+        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);
     }