@directivegames/genesys.sdk 4.0.2 → 4.1.0

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

@@ -24,7 +24,7 @@ export class BaseVehicle extends ENGINE.Pawn {
     }
     setupCamera() {
         // create a follow component for smooth camera movement
-        const followComponent = new ENGINE.FollowComponent({
+        const followComponent = ENGINE.FollowComponent.create({
             positionOffset: new THREE.Vector3(0, 4, 10),
             positionDamping: 0.02,
             lookAtOffset: new THREE.Vector3(0, 0, 0),

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

@@ -14,12 +14,12 @@ class MyGame extends ENGINE.BaseGameLoop {
         // default spawn location
         const position = new THREE.Vector3(0, ENGINE.CHARACTER_HEIGHT / 2, 0);
         // create the pawn
-        this.pawn = new VehiclePlayer({ position });
+        this.pawn = VehiclePlayer.create({ 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();
+        const uiHints = UIHints.create();
         // add all actors to the world
         this.world.addActors(this.pawn, this.controller, uiHints);
     }

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

@@ -22,9 +22,10 @@ import { BaseVehicle } from './base-vehicle.js';
  *
  */
 let MeshVehicle = MeshVehicle_1 = class MeshVehicle extends BaseVehicle {
-    constructor(options) {
+    constructor() {
+        super();
         // the root component is only used for collision and physics simulation
-        const rootComponent = new ENGINE.MeshComponent({
+        const rootComponent = ENGINE.MeshComponent.create({
             geometry: new THREE.BoxGeometry(2.77, 1.79, 5.75),
             material: new THREE.MeshStandardMaterial({
                 color: 0x4444FF,
@@ -41,10 +42,10 @@ let MeshVehicle = MeshVehicle_1 = class MeshVehicle extends BaseVehicle {
             },
         });
         rootComponent.name = 'root';
-        options.rootComponent = rootComponent;
+        this.setRootComponent(rootComponent, true);
         // 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({
+        const chassisComponent = ENGINE.GLTFMeshComponent.create({
             modelUrl: '@project/assets/models/cyberTruck/chassis.glb',
             position: new THREE.Vector3(0, 0, -0.75),
             material: new THREE.MeshStandardMaterial({
@@ -61,7 +62,7 @@ let MeshVehicle = MeshVehicle_1 = class MeshVehicle extends BaseVehicle {
         rootComponent.add(chassisComponent);
         const wheelMeshes = [];
         for (let i = 0; i < 4; i++) {
-            const wheelComponent = new ENGINE.GLTFMeshComponent({
+            const wheelComponent = ENGINE.GLTFMeshComponent.create({
                 modelUrl: '@project/assets/models/cyberTruck/wheel.glb',
                 material: new THREE.MeshStandardMaterial({
                     color: 0x44FF44,
@@ -78,8 +79,7 @@ let MeshVehicle = MeshVehicle_1 = class MeshVehicle extends BaseVehicle {
         }
         rootComponent.add(...wheelMeshes);
         const vehicleMovementComponent = MeshVehicle_1.createVehicleMovementComponent();
-        options.movementComponent = vehicleMovementComponent;
-        super(options);
+        this.movementComponent = vehicleMovementComponent;
         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
@@ -108,8 +108,7 @@ let MeshVehicle = MeshVehicle_1 = class MeshVehicle extends BaseVehicle {
         const sideFrictionStiffness = 2;
         const frictionSlip = 50;
         // Create vehicle movement component
-        const vehicleMovement = new ENGINE.VehicleMovementComponent({
-            ...ENGINE.BasePawnMovementComponent.DEFAULT_OPTIONS,
+        const vehicleMovement = ENGINE.VehicleMovementComponent.create({
             createWheelMeshes: false,
             maxEnginePower: 100,
             maxBrakeForce: 1.5,

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

@@ -18,14 +18,15 @@ import { BaseVehicle } from './base-vehicle.js';
  */
 let VehiclePlayer = class VehiclePlayer 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: {
@@ -35,25 +36,19 @@ let VehiclePlayer = class VehiclePlayer extends ENGINE.ThirdPersonCharacterPawn
                 collisionProfile: ENGINE.DefaultCollisionProfile.Character,
             },
         });
+        this.setRootComponent(rootComponent, true);
+        this.rootComponent.add(camera);
         // 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;
+        // Character model settings
+        this.enableDirectionalLightFollowing = true;
+        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);
     }

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

@@ -21,9 +21,10 @@ import { BaseVehicle } from './base-vehicle.js';
  */
 let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseVehicle {
     tailLightComponents = [];
-    constructor(options) {
+    constructor() {
+        super();
         // Create chassis mesh
-        const rootComponent = new ENGINE.MeshComponent({
+        const rootComponent = ENGINE.MeshComponent.create({
             geometry: new THREE.BoxGeometry(2, 1, 4),
             material: new THREE.MeshStandardMaterial({
                 color: 0x4444FF,
@@ -40,11 +41,10 @@ let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseV
         rootComponent.name = 'chassis';
         // mark the component as transient, this prevents all the components from being saved since we're recreating them in code
         rootComponent.setTransient(true);
-        options.rootComponent = rootComponent;
+        this.setRootComponent(rootComponent, true);
         // create decorative meshes
         PrimitiveVehicle_1.createDecorativeMeshes(rootComponent);
-        options.movementComponent = PrimitiveVehicle_1.createVehicleMovementComponent();
-        super(options);
+        this.movementComponent = PrimitiveVehicle_1.createVehicleMovementComponent();
         this.tailLightComponents = this.getComponents(ENGINE.MeshComponent)
             .filter((component) => component.name.includes('_taillight'));
     }
@@ -72,7 +72,7 @@ let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseV
     }
     static createDecorativeMeshes(rootComponent) {
         // Add windshield
-        const windshieldComponent = new ENGINE.MeshComponent({
+        const windshieldComponent = ENGINE.MeshComponent.create({
             geometry: new THREE.BoxGeometry(1.8, 1.8, 0.1),
             material: new THREE.MeshStandardMaterial({
                 color: 0x87CEEB,
@@ -90,7 +90,7 @@ let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseV
         windshieldComponent.name = 'windshield';
         rootComponent.add(windshieldComponent);
         // Add left headlight
-        const leftHeadlightComponent = new ENGINE.MeshComponent({
+        const leftHeadlightComponent = ENGINE.MeshComponent.create({
             geometry: new THREE.CylinderGeometry(0.15, 0.15, 0.1, 8),
             material: new THREE.MeshStandardMaterial({
                 color: 0xFFFFFF,
@@ -106,7 +106,7 @@ let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseV
         leftHeadlightComponent.name = 'left_headlight';
         rootComponent.add(leftHeadlightComponent);
         // Add right headlight
-        const rightHeadlightComponent = new ENGINE.MeshComponent({
+        const rightHeadlightComponent = ENGINE.MeshComponent.create({
             geometry: new THREE.CylinderGeometry(0.15, 0.15, 0.1, 8),
             material: new THREE.MeshStandardMaterial({
                 color: 0xFFFFFF,
@@ -127,7 +127,7 @@ let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseV
             emissive: 0x440000,
             emissiveIntensity: 0.2,
         });
-        const leftTaillightComponent = new ENGINE.MeshComponent({
+        const leftTaillightComponent = ENGINE.MeshComponent.create({
             geometry: new THREE.CylinderGeometry(0.1, 0.1, 0.1, 8),
             material: leftTaillightMaterial,
             physicsOptions: {
@@ -144,7 +144,7 @@ let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseV
             emissive: 0x440000,
             emissiveIntensity: 0.2,
         });
-        const rightTaillightComponent = new ENGINE.MeshComponent({
+        const rightTaillightComponent = ENGINE.MeshComponent.create({
             geometry: new THREE.CylinderGeometry(0.1, 0.1, 0.1, 8),
             material: rightTaillightMaterial,
             physicsOptions: {
@@ -171,7 +171,6 @@ let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseV
         const sideFrictionStiffness = 2;
         const frictionSlip = 8;
         const options = {
-            ...ENGINE.BasePawnMovementComponent.DEFAULT_OPTIONS,
             maxEnginePower: 35,
             maxSteeringAngle: Math.PI / 6, // 30 degrees
             maxBrakeForce: 1,
@@ -250,7 +249,7 @@ let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseV
                 },
             ],
         };
-        return new ENGINE.VehicleMovementComponent(options);
+        return ENGINE.VehicleMovementComponent.create(options);
     }
 };
 PrimitiveVehicle = PrimitiveVehicle_1 = __decorate([

package/dist/src/templates/src/templates/vehicle/src/ui-hints.js

@@ -10,8 +10,8 @@ import * as ENGINE from '@directivegames/genesys.js';
  */
 let UIHints = class UIHints extends ENGINE.Actor {
     uiElement = null;
-    constructor(options = {}) {
-        super(options);
+    constructor() {
+        super();
         this.setTransient(true); // Don't save this UI element to the level
     }
     async doBeginPlay() {

package/dist/src/templates/src/templates/vr-game/src/game.js

@@ -22,7 +22,7 @@ class MyGame extends ENGINE.BaseGameLoop {
         // Disable tone mapping for VR because it breaks VR
         this.world.postProcessManager.disablePasses(ENGINE.PostProcessPass.ToneMapping);
         // create the vr pawn
-        this.pawn = new ENGINE.VRPawn({
+        this.pawn = ENGINE.VRPawn.create({
             position: new THREE.Vector3(0, 0, 0),
             movementComponent: null,
             camera: new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR),
@@ -38,10 +38,10 @@ class MyGame extends ENGINE.BaseGameLoop {
         // create the controller and possess the pawn
         this.controller = new ENGINE.PlayerController();
         this.controller.possess(this.pawn);
-        this.pawn.addComponent(new ENGINE.VRGrabComponent({}));
-        this.pawn.addComponent(new ENGINE.VRSnapTurnComponent({ angleDeg: this.pawn.getSnapTurnAngleDegrees() }));
-        this.pawn.addComponent(new ENGINE.VRInteractComponent({ button: ENGINE.XRButton.Trigger }));
-        this.pawn.addComponent(new ENGINE.VRTeleportComponent({ maxDistance: 15 }));
+        this.pawn.addComponent(ENGINE.VRGrabComponent.create());
+        this.pawn.addComponent(ENGINE.VRSnapTurnComponent.create({ angleDeg: this.pawn.getSnapTurnAngleDegrees() }));
+        this.pawn.addComponent(ENGINE.VRInteractComponent.create({ button: ENGINE.XRButton.Trigger }));
+        this.pawn.addComponent(ENGINE.VRTeleportComponent.create({ maxDistance: 15 }));
         // add both to the world
         this.world.addActors(this.pawn, this.controller);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directivegames/genesys.sdk",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "description": "Genesys SDK - A development toolkit for game development",
   "author": "Directive Games",
   "main": "index.js",
@@ -109,7 +109,7 @@
     }
   },
   "dependencies": {
-    "@directivegames/genesys.js": "^4.0.2",
+    "@directivegames/genesys.js": "^4.0.3",
     "@electron/rebuild": "^4.0.1",
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.0",

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

@@ -0,0 +1,212 @@
+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 });
+
+
+interface FileInfo {
+  path: string;
+  type: 'scene' | 'prefab';
+}
+
+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: string, files: FileInfo[] = []): FileInfo[] {
+  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: string, relativePath: string): Promise<boolean> {
+  // 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: string, relativePath: string): Promise<boolean> {
+  // Read the file content
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const data = JSON.parse(content);
+
+  let instance: any;
+
+  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: FileInfo): Promise<boolean> {
+  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/src/templates/scripts/genesys/post-install.ts

@@ -17,14 +17,23 @@ async function main() {
 
   const foldersToCopy: string[] = [
     '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/src/templates/src/templates/firstPerson/src/game.ts

@@ -19,7 +19,7 @@ class FirstPersonGame extends ENGINE.BaseGameLoop {
     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();

package/src/templates/src/templates/firstPerson/src/player.ts

@@ -18,16 +18,17 @@ export interface FirstPersonPlayerOptions extends ENGINE.PawnOptions {
  *
  */
 @ENGINE.GameClass()
-export class FirstPersonPlayer extends ENGINE.Pawn<FirstPersonPlayerOptions> {
+export class FirstPersonPlayer extends ENGINE.Pawn {
   // No need to provide rootComponent, movementComponent and camera, they are created internally
-  constructor(options: Omit<FirstPersonPlayerOptions, 'rootComponent' | 'movementComponent' | 'camera'>) {
+  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: {
@@ -40,22 +41,17 @@ export class FirstPersonPlayer extends ENGINE.Pawn<FirstPersonPlayerOptions> {
     });
     // 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,
     });
+    this.movementComponent = movementComponent;
 
-    // construct the pawn
-    super({
-      ...options,
-      rootComponent,
-      movementComponent,
-      // make sure the directional light follows the player for consistent shadows
-      enableDirectionalLightFollowing: true,
-      camera,
-    });
+    this.enableDirectionalLightFollowing = true;
 
     // set the pawn to be transient so it's never saved in the level
     this.setTransient(true);

package/src/templates/src/templates/fps/src/game.ts

@@ -19,7 +19,7 @@ class MyGame extends ENGINE.BaseGameLoop {
     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();

package/src/templates/src/templates/fps/src/player.ts

@@ -21,9 +21,10 @@ export interface FPSPlayerOptions extends ENGINE.PawnOptions {
  *
  */
 @ENGINE.GameClass()
-export class FPSPlayer extends ENGINE.Pawn<FPSPlayerOptions> {
+export class FPSPlayer extends ENGINE.Pawn {
   // No need to provide rootComponent, movementComponent and camera, they are created internally
-  constructor(options: Omit<FPSPlayerOptions, 'rootComponent' | 'movementComponent' | 'camera'>) {
+  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
@@ -34,7 +35,7 @@ export class FPSPlayer extends ENGINE.Pawn<FPSPlayerOptions> {
     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: {
@@ -47,21 +48,17 @@ export class FPSPlayer extends ENGINE.Pawn<FPSPlayerOptions> {
     });
     // 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);