@gnsx/genesys.sdk 4.2.9

package/dist/src/templates/scripts/genesys/storageProvider.js

@@ -0,0 +1,146 @@
+import fs from 'fs';
+import path from 'path';
+import * as ENGINE from '@gnsx/genesys.js';
+import { AssetPath, AssetPathEncodeState } from '@gnsx/genesys.js';
+import { getProjectRoot } from './common.js';
+export class StorageProvider {
+    async resolvePath(assetPath, expiry) {
+        if (assetPath.isResolved()) {
+            return assetPath;
+        }
+        assetPath.resolvePath(this.getFullPath(assetPath.initialPath), AssetPathEncodeState.Decoded);
+        return assetPath;
+    }
+    getFullPath(filePath) {
+        let fullPath = filePath;
+        let rootPath = undefined;
+        if (filePath.startsWith(ENGINE.PROJECT_PATH_PREFIX)) {
+            filePath = filePath.slice(ENGINE.PROJECT_PATH_PREFIX.length);
+            rootPath = getProjectRoot();
+        }
+        else if (filePath.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
+            filePath = filePath.slice(ENGINE.ENGINE_PATH_PREFIX.length);
+            rootPath = path.join(getProjectRoot(), 'node_modules', 'genesys.js');
+        }
+        if (rootPath !== undefined) {
+            fullPath = AssetPath.join(rootPath, filePath);
+        }
+        return fullPath;
+    }
+    async downloadFileAsBuffer(assetPath) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        if (!fs.existsSync(fullPath)) {
+            return new ArrayBuffer(0);
+        }
+        const data = fs.readFileSync(fullPath);
+        const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+        return arrayBuffer;
+    }
+    async downloadFileAsJson(assetPath) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        if (!fs.existsSync(fullPath)) {
+            return {};
+        }
+        return JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+    }
+    async downloadFileAsText(assetPath) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        if (!fs.existsSync(fullPath)) {
+            return '';
+        }
+        return fs.readFileSync(fullPath, 'utf8');
+    }
+    async exists(assetPath) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        return fs.existsSync(fullPath);
+    }
+    async buildCurrentProject(runTsc) {
+        throw new Error('Not implemented');
+    }
+    async uploadFile(assetPath, content, options) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        if (typeof content === 'string') {
+            fs.writeFileSync(fullPath, content);
+        }
+        else {
+            throw new Error(`Unsupported content type: ${typeof content}`);
+        }
+        return {
+            path: fullPath,
+            name: path.basename(fullPath)
+        };
+    }
+    async deleteFile(assetPath) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        if (fs.existsSync(fullPath)) {
+            fs.unlinkSync(fullPath);
+        }
+    }
+    async listFiles(assetPath, recursive, includeHiddenFiles) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        if (!fs.existsSync(fullPath)) {
+            return { files: [], directories: [] };
+        }
+        const files = [];
+        const directories = [];
+        const processDirectory = (dirPath, basePath = '') => {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                // Skip hidden files if not requested
+                if (!includeHiddenFiles && entry.name.startsWith('.')) {
+                    continue;
+                }
+                const fullEntryPath = path.join(dirPath, entry.name);
+                const relativePath = basePath ? path.join(basePath, entry.name) : entry.name;
+                const stats = fs.statSync(fullEntryPath);
+                const fileItem = {
+                    name: entry.name,
+                    path: relativePath,
+                    absolutePath: fullEntryPath,
+                    size: stats.size,
+                    modifiedTime: stats.mtime,
+                    isDirectory: entry.isDirectory()
+                };
+                if (entry.isDirectory()) {
+                    directories.push(fileItem);
+                    // Recursively process subdirectories if requested
+                    if (recursive) {
+                        processDirectory(fullEntryPath, relativePath);
+                    }
+                }
+                else {
+                    files.push(fileItem);
+                }
+            }
+        };
+        // Check if the path is a directory
+        const stats = fs.statSync(fullPath);
+        if (stats.isDirectory()) {
+            processDirectory(fullPath);
+        }
+        else {
+            // If it's a file, return just that file
+            const fileItem = {
+                name: path.basename(fullPath),
+                path: path.basename(fullPath),
+                absolutePath: fullPath,
+                size: stats.size,
+                modifiedTime: stats.mtime,
+                isDirectory: false
+            };
+            files.push(fileItem);
+        }
+        return { files, directories };
+    }
+}
+export function getResolvedPath(assetPath) {
+    return assetPath.getResolvedPath(false);
+}

package/dist/src/templates/scripts/genesys/validate-prefabs.js

@@ -0,0 +1,115 @@
+import fs from 'fs';
+import path from 'path';
+import Ajv from 'ajv';
+import { getProjectRoot } from './common.js';
+function findPrefabFiles(dir, prefabFiles = []) {
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            // Skip node_modules and other common directories that shouldn't contain prefabs
+            if (file === 'node_modules' || file === 'dist' || file === '.git') {
+                continue;
+            }
+            findPrefabFiles(filePath, prefabFiles);
+        }
+        else if (file.endsWith('.prefab.json')) {
+            prefabFiles.push(filePath);
+        }
+    }
+    return prefabFiles;
+}
+function validatePrefabs() {
+    const projectRoot = getProjectRoot();
+    const schemaPath = path.join(__dirname, 'prefab.schema.json');
+    // Load the schema
+    let schema;
+    try {
+        const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+        schema = JSON.parse(schemaContent);
+    }
+    catch (error) {
+        console.error(`❌ Failed to load schema from ${schemaPath}`);
+        console.error(error);
+        process.exit(1);
+    }
+    // Initialize Ajv
+    const ajv = new Ajv({
+        allErrors: true,
+        validateSchema: false // Don't validate the schema itself
+    });
+    // Process $ref in the schema to use proper format
+    const processedSchema = JSON.parse(JSON.stringify(schema), (key, value) => {
+        if (key === '$ref' && typeof value === 'string' && !value.startsWith('#')) {
+            return `#/definitions/${value}`;
+        }
+        return value;
+    });
+    const validate = ajv.compile(processedSchema);
+    // Find all prefab files
+    const prefabFiles = findPrefabFiles(projectRoot);
+    if (prefabFiles.length === 0) {
+        console.log('⚠️  No prefab files found in the project.');
+        return;
+    }
+    console.log(`Found ${prefabFiles.length} prefab file(s) to validate:\n`);
+    const validationErrors = [];
+    let validCount = 0;
+    // Validate each prefab file
+    for (const prefabPath of prefabFiles) {
+        const relativePath = path.relative(projectRoot, prefabPath);
+        try {
+            const prefabContent = fs.readFileSync(prefabPath, 'utf-8');
+            const prefabData = JSON.parse(prefabContent);
+            const valid = validate(prefabData);
+            if (valid) {
+                console.log(`✅ ${relativePath}`);
+                validCount++;
+            }
+            else {
+                console.log(`❌ ${relativePath}`);
+                const errors = validate.errors?.map((err) => {
+                    const path = err.instancePath ?? '/';
+                    const message = err.message ?? 'unknown error';
+                    return `  - ${path}: ${message}`;
+                }) ?? [];
+                validationErrors.push({
+                    file: relativePath,
+                    errors
+                });
+            }
+        }
+        catch (error) {
+            console.log(`❌ ${relativePath} (parse error)`);
+            validationErrors.push({
+                file: relativePath,
+                errors: [`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`]
+            });
+        }
+    }
+    // Print summary
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('Validation Summary:');
+    console.log(`  Total files: ${prefabFiles.length}`);
+    console.log(`  Valid: ${validCount}`);
+    console.log(`  Invalid: ${validationErrors.length}`);
+    console.log(`${'='.repeat(60)}\n`);
+    // Print detailed errors if any
+    if (validationErrors.length > 0) {
+        console.log('Validation Errors:\n');
+        for (const { file, errors } of validationErrors) {
+            console.log(`${file}:`);
+            for (const error of errors) {
+                console.log(error);
+            }
+            console.log('');
+        }
+        process.exit(1);
+    }
+    else {
+        console.log('🎉 All prefab files are valid!');
+    }
+}
+// Run validation
+validatePrefabs();

package/dist/src/templates/src/index.js

@@ -0,0 +1,20 @@
+// which items will be copied to the new project, includes files and folders
+export const sharedTemplateItems = [
+    '.cursor',
+    '.vscode',
+    'scripts/genesys',
+    'gitignore', // npm excludes .gitignore files from packages, so we rename it when copying
+    '.gitattributes',
+    '.cursorignore',
+    'eslint.config.js',
+    'tsconfig.json',
+    'AGENTS.md',
+    'CLAUDE.md',
+    'index.html',
+    'vite.config.ts',
+];
+// which items will be deleted from the project, if exists
+export const deletedTemplateItems = [
+    '.cursorrules'
+];
+export * as ENGINE from '@gnsx/genesys.js';

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

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

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

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

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

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ENGINE from '@gnsx/genesys.js';
+import * as THREE from 'three';
+/**
+ * A first 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 FirstPersonPlayer = class FirstPersonPlayer extends ENGINE.Pawn {
+    // No need to provide rootComponent, movementComponent and camera, they are created internally
+    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 = ENGINE.MeshComponent.create({
+            geometry: ENGINE.GameBuilder.createDefaultPawnCapsuleGeometry(),
+            material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW }),
+            physicsOptions: {
+                enabled: true,
+                // KinematicVelocityBased is required to use the physics character controller
+                motionType: ENGINE.PhysicsMotionType.KinematicVelocityBased,
+                collisionProfile: ENGINE.DefaultCollisionProfile.Pawn,
+                generateCollisionEvents: true,
+            }
+        });
+        // 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 = ENGINE.CharacterMovementComponent.create({
+            movementType: ENGINE.CharacterMovementType.FirstPerson,
+        });
+        this.movementComponent = movementComponent;
+        this.enableDirectionalLightFollowing = true;
+        // set the pawn to be transient so it's never saved in the level
+        this.setTransient(true);
+    }
+};
+FirstPersonPlayer = __decorate([
+    ENGINE.GameClass()
+], FirstPersonPlayer);
+export { FirstPersonPlayer };

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

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

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

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

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

@@ -0,0 +1,60 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ENGINE from '@gnsx/genesys.js';
+import * as THREE from 'three';
+import { DefaultWeapon } from './weapon.js';
+/**
+ * A FPS player class.
+ *
+ * Key points:
+ * - No need to provide rootComponent, 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
+ * - The weapon is created and attached to the camera
+ *
+ */
+let FPSPlayer = class FPSPlayer extends ENGINE.Pawn {
+    // No need to provide rootComponent, movementComponent and camera, they are created internally
+    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);
+        // create the weapon and attach it to the camera
+        const weapon = DefaultWeapon.create();
+        camera.add(weapon);
+        // use a simple capsule geometry as the root component
+        const rootComponent = ENGINE.MeshComponent.create({
+            geometry: ENGINE.GameBuilder.createDefaultPawnCapsuleGeometry(),
+            material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW }),
+            physicsOptions: {
+                enabled: true,
+                // KinematicVelocityBased is required to use the physics character controller
+                motionType: ENGINE.PhysicsMotionType.KinematicVelocityBased,
+                collisionProfile: ENGINE.DefaultCollisionProfile.Pawn,
+                generateCollisionEvents: true,
+            }
+        });
+        // 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 = ENGINE.CharacterMovementComponent.create({
+            movementType: ENGINE.CharacterMovementType.FirstPerson,
+        });
+        this.movementComponent = movementComponent;
+        this.enableDirectionalLightFollowing = true;
+        // set the pawn to be transient so it's never saved in the level
+        this.setTransient(true);
+    }
+};
+FPSPlayer = __decorate([
+    ENGINE.GameClass()
+], FPSPlayer);
+export { FPSPlayer };

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

@@ -0,0 +1,54 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ENGINE from '@gnsx/genesys.js';
+import * as THREE from 'three';
+/**
+ * A default weapon class.
+ *
+ * Key points:
+ * - Inherits from the ProjectileWeaponComponent class
+ * - All the weapon options are configured in the constructor so no need to configure by the user
+ */
+let DefaultWeapon = class DefaultWeapon extends ENGINE.ProjectileWeaponComponent {
+    constructor() {
+        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,
+            projectileLifespan: 3,
+            useOverlapCheck: false,
+            destroyOnHit: false,
+            gravityScale: 0,
+            geometry: new THREE.SphereGeometry(0.1),
+            material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW })
+        };
+        this.setTransient(true);
+    }
+};
+DefaultWeapon = __decorate([
+    ENGINE.GameClass()
+], DefaultWeapon);
+export { DefaultWeapon };

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

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

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

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

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

@@ -0,0 +1,38 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ENGINE from '@gnsx/genesys.js';
+import * as THREE from 'three';
+/**
+ * A 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() {
+        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 = ENGINE.CharacterMovementComponent.create({
+            // disable the character controller
+            characterControllerOptions: null,
+        });
+        this.movementComponent = movementComponent;
+        this.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
+};