@directivegames/genesys.sdk 3.2.2

package/src/templates/src/templates/thirdPerson/assets/default.genesys-scene

@@ -0,0 +1,166 @@
+{
+  "$version": 0,
+  "class": "ENGINE.World",
+  "uuid": "c0ae85792bc3b946",
+  "ctor": {
+    "backgroundColor": 3026478,
+    "navigationOptions": {
+      "engine": "recast-navigation",
+      "debug": false,
+      "generateOnStartUp": false
+    },
+    "physicsOptions": {
+      "gravity": [
+        0,
+        -9.81,
+        0,
+        "v"
+      ],
+      "engine": "rapier"
+    },
+    "useManifold": true
+  },
+  "actors": [
+    {
+      "uuid": "9a86d389088b361c",
+      "class": "ENGINE.Actor",
+      "properties": {
+        "editorData": {
+          "displayName": "Directional Light",
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "rootComponent": {
+          "class": "ENGINE.DirectionalLightComponent",
+          "uuid": "cfe05433-9edc-4dfe-a535-c71f33e92d78",
+          "ctor": {
+            "color": 16777215,
+            "intensity": 1,
+            "castShadow": true,
+            "shadowMapSize": 2048,
+            "shadowBias": 0,
+            "shadowNormalBias": 0,
+            "shadowNear": 0.1,
+            "shadowFar": 100
+          },
+          "properties": {
+            "position": [
+              10,
+              50,
+              -10,
+              "v"
+            ],
+            "castShadow": true
+          }
+        }
+      }
+    },
+    {
+      "uuid": "9d428f2a16e5374a",
+      "class": "ENGINE.Actor",
+      "properties": {
+        "editorData": {
+          "displayName": "Ground",
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "rootComponent": {
+          "class": "ENGINE.MeshComponent",
+          "uuid": "71caea24-62d7-4e45-a76e-4c7519de2c3c",
+          "ctor": {
+            "geometry": {
+              "class": "THREE.BoxGeometry",
+              "ctor": [
+                500,
+                0.1,
+                500
+              ]
+            },
+            "material": {
+              "@external": "DefaultMaterial"
+            },
+            "uvScaleTilesPerUnit": 0.2,
+            "physicsOptions": {
+              "enabled": true,
+              "motionType": "static",
+              "collisionProfile": "BlockAll"
+            }
+          },
+          "properties": {
+            "position": [
+              0,
+              -0.9,
+              0,
+              "v"
+            ],
+            "receiveShadow": true
+          }
+        }
+      }
+    },
+    {
+      "uuid": "b87cbc5e60a2e54c",
+      "class": "ENGINE.PlayerStart",
+      "properties": {
+        "editorData": {
+          "displayName": "Player Start",
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "rootComponent": {
+          "class": "ENGINE.SceneComponent",
+          "uuid": "b4d5f8f7-2512-45e1-9157-c7ff6772402d",
+          "ctor": {},
+          "properties": {
+            "position": [
+              0,
+              0.9,
+              0,
+              "v"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "uuid": "0ba1f4677e8370d1",
+      "class": "ENGINE.Actor",
+      "properties": {
+        "editorData": {
+          "displayName": "Skybox",
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "rootComponent": {
+          "class": "ENGINE.SceneComponent",
+          "uuid": "195e88df-73ff-4f4b-82ae-7fb58671463d",
+          "ctor": {},
+          "properties": {},
+          "children": [
+            {
+              "class": "ENGINE.SkyboxComponent",
+              "uuid": "a6cea5af-a972-4031-97b4-cd9218198a2f",
+              "ctor": {
+                "textureUrl": "@engine/assets/textures/skybox/citrus_orchard_road_puresky_2k.hdr",
+                "width": 2048,
+                "height": 1024,
+                "bottomColor": "#E6F3FF",
+                "middleColor": "#4A90E2",
+                "topColor": "#0F1B3C",
+                "envMapIntensity": 1
+              },
+              "properties": {}
+            }
+          ]
+        }
+      }
+    }
+  ],
+  "properties": {
+    "editorData": {}
+  }
+}

package/src/templates/src/templates/thirdPerson/src/game.ts

@@ -0,0 +1,39 @@
+
+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 {
+  private pawn: ThirdPersonPlayer | null = null;
+  private controller: ENGINE.PlayerController | null = null;
+
+  protected override createLoadingScreen(): ENGINE.ILoadingScreen | null {
+    // enable the default loading screen
+    return new ENGINE.DefaultLoadingScreen();
+  }
+
+  protected override async preStart(): Promise<void> {
+    // 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: HTMLElement, gameId: string): ENGINE.IGameLoop {
+  const game = new ThirdPersonGame(container, {
+    ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+    gameId
+  });
+  return game;
+}

package/src/templates/src/templates/thirdPerson/src/player.ts

@@ -0,0 +1,61 @@
+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
+ *
+ */
+@ENGINE.GameClass()
+export class ThirdPersonPlayer extends ENGINE.ThirdPersonCharacterPawn {
+  // Omit all the options that are created internally
+  constructor(options: Omit<ENGINE.ThirdPersonCharacterPawnOptions,
+    'rootComponent' | 'movementComponent' | 'camera' | 'modelUrl' | 'configUrl' | 'meshPosition' | 'meshRotation' | 'meshScale'>) {
+    // 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);
+  }
+}

package/src/templates/src/templates/vehicle/assets/default.genesys-scene

@@ -0,0 +1,226 @@
+{
+  "$version": 0,
+  "class": "ENGINE.World",
+  "uuid": "c0ae85792bc3b946",
+  "ctor": {
+    "backgroundColor": 3026478,
+    "navigationOptions": {
+      "engine": "recast-navigation",
+      "debug": false,
+      "generateOnStartUp": false
+    },
+    "physicsOptions": {
+      "gravity": [
+        0,
+        -9.81,
+        0,
+        "v"
+      ],
+      "engine": "rapier"
+    },
+    "useManifold": true
+  },
+  "actors": [
+    {
+      "uuid": "9a86d389088b361c",
+      "class": "ENGINE.Actor",
+      "properties": {
+        "editorData": {
+          "displayName": "Directional Light",
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "rootComponent": {
+          "class": "ENGINE.DirectionalLightComponent",
+          "uuid": "cfe05433-9edc-4dfe-a535-c71f33e92d78",
+          "ctor": {
+            "color": 16777215,
+            "intensity": 1,
+            "castShadow": true,
+            "shadowMapSize": 2048,
+            "shadowBias": 0,
+            "shadowNormalBias": 0,
+            "shadowNear": 0.1,
+            "shadowFar": 100
+          },
+          "properties": {
+            "position": [
+              10,
+              50,
+              -10,
+              "v"
+            ],
+            "castShadow": true
+          }
+        }
+      }
+    },
+    {
+      "uuid": "9d428f2a16e5374a",
+      "class": "ENGINE.Actor",
+      "properties": {
+        "editorData": {
+          "displayName": "Ground",
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "rootComponent": {
+          "class": "ENGINE.MeshComponent",
+          "uuid": "71caea24-62d7-4e45-a76e-4c7519de2c3c",
+          "ctor": {
+            "geometry": {
+              "class": "THREE.BoxGeometry",
+              "ctor": [
+                500,
+                0.1,
+                500
+              ]
+            },
+            "material": {
+              "@external": "DefaultMaterial"
+            },
+            "uvScaleTilesPerUnit": 0.2,
+            "physicsOptions": {
+              "enabled": true,
+              "motionType": "static",
+              "collisionProfile": "BlockAll"
+            }
+          },
+          "properties": {
+            "position": [
+              0,
+              -0.9,
+              0,
+              "v"
+            ],
+            "receiveShadow": true
+          }
+        }
+      }
+    },
+    {
+      "uuid": "b87cbc5e60a2e54c",
+      "class": "ENGINE.PlayerStart",
+      "properties": {
+        "editorData": {
+          "displayName": "Player Start",
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "rootComponent": {
+          "class": "ENGINE.SceneComponent",
+          "uuid": "b4d5f8f7-2512-45e1-9157-c7ff6772402d",
+          "ctor": {},
+          "properties": {
+            "position": [
+              0,
+              0.9,
+              0,
+              "v"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "uuid": "0ba1f4677e8370d1",
+      "class": "ENGINE.Actor",
+      "properties": {
+        "editorData": {
+          "displayName": "Skybox",
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "rootComponent": {
+          "class": "ENGINE.SceneComponent",
+          "uuid": "195e88df-73ff-4f4b-82ae-7fb58671463d",
+          "ctor": {},
+          "properties": {},
+          "children": [
+            {
+              "class": "ENGINE.SkyboxComponent",
+              "uuid": "15d8d439-a7dd-49a1-800e-f1f893812293",
+              "ctor": {
+                "textureUrl": "@engine/assets/textures/skybox/citrus_orchard_road_puresky_2k.hdr",
+                "width": 2048,
+                "height": 1024,
+                "bottomColor": "#E6F3FF",
+                "middleColor": "#4A90E2",
+                "topColor": "#0F1B3C",
+                "envMapIntensity": 1
+              },
+              "properties": {}
+            }
+          ]
+        }
+      }
+    },
+    {
+      "uuid": "f527684a997f6384",
+      "class": "GAME.MeshVehicle",
+      "properties": {
+        "editorData": {
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "enableDirectionalLightFollowing": true,
+        "position": [
+          -4.2,
+          2.5,
+          -8.2,
+          "v"
+        ],
+        "rotation": [
+          0,
+          0,
+          0,
+          "e"
+        ],
+        "scale": [
+          1,
+          1,
+          1,
+          "v"
+        ]
+      }
+    },
+    {
+      "uuid": "2aa7b313363fa7b2",
+      "class": "GAME.PrimitiveVehicle",
+      "properties": {
+        "editorData": {
+          "hidden": false
+        }
+      },
+      "ctor": {
+        "enableDirectionalLightFollowing": true,
+        "position": [
+          3.1,
+          2.3,
+          -7.7,
+          "v"
+        ],
+        "rotation": [
+          0,
+          0,
+          0,
+          "e"
+        ],
+        "scale": [
+          1,
+          1,
+          1,
+          "v"
+        ]
+      }
+    }
+  ],
+  "properties": {
+    "editorData": {}
+  }
+}

package/src/templates/src/templates/vehicle/src/base-vehicle.ts

@@ -0,0 +1,145 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+
+import { VehiclePlayer } from './player.js';
+
+/**
+ * Base vehicle class that provides common vehicle functionality
+ *
+ * Key points:
+ * - Handles camera setup with follow component for smooth third-person view
+ * - Manages player interaction (enter/exit vehicle with proximity detection)
+ * - Provides E key input handler for vehicle exit
+ * - Calculates safe exit position when player leaves vehicle
+ * - Automatically switches possession between player and vehicle
+ *
+ */
+export abstract class BaseVehicle extends ENGINE.Pawn {
+  protected readonly interactionDistance = 5;
+  protected nearbyPlayer: ENGINE.Pawn | null = null;
+  protected enteredPlayer: ENGINE.Pawn | null = null;
+
+  protected override doBeginPlay(): void {
+    super.doBeginPlay();
+    this.setupCamera();
+    this.setupVicinityCheck();
+    this.setupExitHandler();
+  }
+
+  protected setupCamera(): void {
+    // create a follow component for smooth camera movement
+    const followComponent = new ENGINE.FollowComponent({
+      positionOffset: new THREE.Vector3(0, 4, 10),
+      positionDamping: 0.02,
+      lookAtOffset: new THREE.Vector3(0, 0, 0),
+      target: this.rootComponent,
+      useCameraLookAtConvention: true,
+    });
+    this.rootComponent.add(followComponent);
+
+    // create a camera and add it to the follow component
+    const camera = new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR);
+    followComponent.add(camera);
+  }
+
+  protected setupVicinityCheck(): void {
+    // Check every frame for nearby players using tick delegate
+    this.onTickPostPhysics.add(() => {
+      this.checkForNearbyPlayer();
+    });
+  }
+
+  protected checkForNearbyPlayer(): void {
+    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;
+    }
+  }
+
+  public canBeEntered(): boolean {
+    return this.nearbyPlayer !== null;
+  }
+
+  public getNearbyPlayer(): ENGINE.Pawn | null {
+    return this.nearbyPlayer;
+  }
+
+  protected setupExitHandler(): void {
+    // Add E key input handler for vehicle exit
+    this.onKeyDown.add((e: KeyboardEvent) => {
+      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;
+    });
+  }
+
+  public setEnteredPlayer(player: ENGINE.Pawn | null): void {
+    this.enteredPlayer = player;
+  }
+
+  protected exitVehicle(): void {
+    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;
+    }
+  }
+
+  protected calculateExitPosition(): THREE.Vector3 {
+    // Calculate a position to the right side of the vehicle
+    const vehiclePosition = this.rootComponent.position.clone();
+    const vehicleRotation = this.rootComponent.rotation;
+
+    // Create a vector pointing to the right of the vehicle
+    const rightVector = new THREE.Vector3(1, 0, 0);
+    rightVector.applyEuler(vehicleRotation);
+
+    // Position the player 2 units to the right and slightly forward
+    const exitOffset = rightVector.multiplyScalar(2);
+    exitOffset.y = 1; // Raise slightly above ground
+
+    return vehiclePosition.add(exitOffset);
+  }
+}

package/src/templates/src/templates/vehicle/src/game.ts

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