@directivegames/genesys.sdk 3.2.2

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

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import path from 'path';
+import { getProjectRoot } from './common.js';
+async function main() {
+    const engineInstallFolder = path.join(getProjectRoot(), 'node_modules/genesys.js');
+    if (!fs.existsSync(engineInstallFolder)) {
+        return;
+    }
+    const copiedEngineFolder = path.join(getProjectRoot(), '.engine');
+    if (fs.existsSync(copiedEngineFolder)) {
+        fs.rmdirSync(copiedEngineFolder, { recursive: true });
+    }
+    fs.mkdirSync(copiedEngineFolder, { recursive: true });
+    const foldersToCopy = [
+        'games/examples',
+        'src',
+        'docs',
+    ];
+    for (const folder of foldersToCopy) {
+        const engineFolderPath = path.join(engineInstallFolder, folder);
+        const localFolderPath = path.join(copiedEngineFolder, folder);
+        fs.cpSync(engineFolderPath, localFolderPath, { recursive: true });
+    }
+}
+main();

package/dist/src/templates/scripts/genesys/remove-engine-comments.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env tsx
+import { readdir, readFile, stat, writeFile } from 'fs/promises';
+import { join } from 'path';
+/**
+ * Recursively finds all TypeScript files in a directory
+ */
+async function findTsFiles(dir) {
+    const files = [];
+    try {
+        const entries = await readdir(dir);
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const stats = await stat(fullPath);
+            if (stats.isDirectory()) {
+                const subFiles = await findTsFiles(fullPath);
+                files.push(...subFiles);
+            }
+            else if (entry.endsWith('.ts') || entry.endsWith('.tsx')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Warning: Could not read directory ${dir}:`, error);
+    }
+    return files;
+}
+/**
+ * Removes comments from TypeScript code using regex
+ */
+function removeComments(code) {
+    const originalLength = code.length;
+    // Remove single-line comments (// comments)
+    // This regex handles // comments but preserves URLs and string literals
+    let cleaned = code.replace(/^(\s*)\/\/.*$/gm, '$1');
+    // Remove multi-line comments (/* ... */ and /** ... */)
+    // This regex handles nested quotes and preserves strings
+    cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, '');
+    // Clean up multiple consecutive empty lines (replace with single empty line)
+    cleaned = cleaned.replace(/\n\s*\n\s*\n/g, '\n\n');
+    // Trim trailing whitespace on each line
+    cleaned = cleaned.replace(/[ \t]+$/gm, '');
+    const hadComments = cleaned.length !== originalLength || cleaned !== code;
+    return { cleaned, hadComments };
+}
+/**
+ * Removes comments from a TypeScript file
+ */
+async function removeCommentsFromFile(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const { cleaned, hadComments } = removeComments(content);
+        if (!hadComments) {
+            return false; // No comments to remove
+        }
+        await writeFile(filePath, cleaned, 'utf8');
+        return true;
+    }
+    catch (error) {
+        console.error(`Error processing file ${filePath}:`, error);
+        return false;
+    }
+}
+async function main() {
+    const engineDir = '.engine';
+    console.log(`Searching for TypeScript files in ${engineDir}...`);
+    console.log(`Current working directory: ${process.cwd()}`);
+    try {
+        const tsFiles = await findTsFiles(engineDir);
+        console.log(`Found ${tsFiles.length} TypeScript files.`);
+        if (tsFiles.length > 0) {
+            console.log('First few files:');
+            tsFiles.slice(0, 5).forEach(file => console.log(`  - ${file}`));
+        }
+        if (tsFiles.length === 0) {
+            console.log('No TypeScript files found in .engine folder.');
+            return;
+        }
+        let processedCount = 0;
+        let modifiedCount = 0;
+        for (const filePath of tsFiles) {
+            console.log(`Processing: ${filePath}`);
+            try {
+                const wasModified = await removeCommentsFromFile(filePath);
+                processedCount++;
+                if (wasModified) {
+                    modifiedCount++;
+                    console.log('  ✓ Comments removed');
+                }
+                else {
+                    console.log('  - No comments found');
+                }
+            }
+            catch (error) {
+                console.error(`  ✗ Error: ${error}`);
+            }
+        }
+        console.log('\nCompleted:');
+        console.log(`- Files processed: ${processedCount}`);
+        console.log(`- Files modified: ${modifiedCount}`);
+        console.log(`- Files skipped: ${processedCount - modifiedCount}`);
+    }
+    catch (error) {
+        console.error('Error:', error);
+        process.exit(1);
+    }
+}
+// Always run main if this file is executed directly
+main().catch((error) => {
+    console.error('Unexpected error:', error);
+    console.error('Stack trace:', error.stack);
+    process.exit(1);
+});

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

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

package/dist/src/templates/src/templates/firstPerson/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 '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(options) {
+        // 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({
+            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;
+        // create the movement component
+        const movementComponent = new ENGINE.CharacterMovementComponent({
+            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+            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,
+        });
+        // 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 '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 = new FPSPlayer({ position });
+        // create the controller and possess the pawn
+        this.controller = new ENGINE.PlayerController();
+        this.controller.possess(this.pawn);
+        // add both to the world
+        this.world.addActors(this.pawn, this.controller);
+    }
+}
+export function main(container, gameId) {
+    const game = new MyGame(container, {
+        ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+        gameId
+    });
+    return game;
+}

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

@@ -0,0 +1,64 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { 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(options) {
+        // 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 = new DefaultWeapon();
+        camera.add(weapon);
+        // use a simple capsule geometry as the root component
+        const rootComponent = new ENGINE.MeshComponent({
+            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;
+        // create the movement component
+        const movementComponent = new ENGINE.CharacterMovementComponent({
+            ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+            movementType: ENGINE.CharacterMovementType.FirstPerson,
+        });
+        super({
+            ...options,
+            rootComponent,
+            movementComponent,
+            // make sure the directional light follows the player for consistent shadows
+            enableDirectionalLightFollowing: true,
+            camera
+        });
+        // 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,62 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+/**
+ * A 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({
+            // 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 })
+            }
+        });
+        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 {};