@gnsx/genesys.sdk 4.2.9

package/src/templates/scripts/genesys/remove-engine-comments.ts

@@ -0,0 +1,135 @@
+#!/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: string): Promise<string[]> {
+  const files: string[] = [];
+
+  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: string): { cleaned: string; hadComments: boolean } {
+  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: string): Promise<boolean> {
+  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/src/templates/scripts/genesys/run-mcp-inspector.bat

@@ -0,0 +1,5 @@
+pushd %~dp0
+cd ..
+set DANGEROUSLY_OMIT_AUTH=1
+pnpm dlx @modelcontextprotocol/inspector pnpm dlx tsx ./scripts/genesys/genesys-mcp.ts
+popd

package/src/templates/scripts/genesys/storageProvider.ts

@@ -0,0 +1,182 @@
+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 implements ENGINE.IStorageProvider {
+  public async resolvePath(assetPath: AssetPath, expiry?: number): Promise<AssetPath> {
+    if (assetPath.isResolved()) {
+      return assetPath;
+    }
+
+    assetPath.resolvePath(this.getFullPath(assetPath.initialPath), AssetPathEncodeState.Decoded);
+    return assetPath;
+  }
+
+  public getFullPath(filePath: string): string {
+    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;
+  }
+
+  public async downloadFileAsBuffer(
+    assetPath: AssetPath,
+  ): Promise<ArrayBuffer> {
+    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;
+  }
+
+  public async downloadFileAsJson<T>(assetPath: AssetPath): Promise<T> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    if (!fs.existsSync(fullPath)) {
+      return {} as T;
+    }
+    return JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+  }
+
+  public async downloadFileAsText(assetPath: AssetPath): Promise<string> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    if (!fs.existsSync(fullPath)) {
+      return '';
+    }
+    return fs.readFileSync(fullPath, 'utf8');
+  }
+
+  public async exists(assetPath: AssetPath): Promise<boolean> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    return fs.existsSync(fullPath);
+  }
+
+  public async buildCurrentProject(runTsc: boolean): Promise<boolean> {
+    throw new Error('Not implemented');
+  }
+
+  public async uploadFile(assetPath: AssetPath, content: Blob | File | string | ArrayBuffer, options?: ENGINE.FileUploadOptions): Promise<{
+        path: string;
+        name: string;
+    }>
+  {
+    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)
+    };
+  }
+
+  public async deleteFile(assetPath: AssetPath): Promise<void> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    if (fs.existsSync(fullPath)) {
+      fs.unlinkSync(fullPath);
+    }
+  }
+
+  public async listFiles(assetPath: AssetPath, recursive?: boolean, includeHiddenFiles?: boolean): Promise<ENGINE.FileListResult> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+
+    if (!fs.existsSync(fullPath)) {
+      return { files: [], directories: [] };
+    }
+
+    const files: ENGINE.FileItem[] = [];
+    const directories: ENGINE.FileItem[] = [];
+
+    const processDirectory = (dirPath: string, basePath: string = '') => {
+      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: ENGINE.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: ENGINE.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: ENGINE.AssetPath): string {
+  return assetPath.getResolvedPath(false);
+}

package/src/templates/scripts/genesys/validate-prefabs.ts

@@ -0,0 +1,138 @@
+import fs from 'fs';
+import path from 'path';
+
+import Ajv, { type ErrorObject } from 'ajv';
+
+import { getProjectRoot } from './common.js';
+
+interface ValidationError {
+  file: string;
+  errors: string[];
+}
+
+function findPrefabFiles(dir: string, prefabFiles: string[] = []): string[] {
+  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: any;
+  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 as any)({
+    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: ValidationError[] = [];
+  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: ErrorObject) => {
+          const path = (err as any).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/src/templates/src/index.ts

@@ -0,0 +1,22 @@
+// which items will be copied to the new project, includes files and folders
+export const sharedTemplateItems: string[] = [
+  '.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: string[] = [
+  '.cursorrules'
+];
+
+export * as ENGINE from '@gnsx/genesys.js';

package/src/templates/src/templates/firstPerson/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": "f7e33ae7d5ac74f9",
+              "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/firstPerson/src/game.ts

@@ -0,0 +1,39 @@
+
+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 {
+  private pawn: FirstPersonPlayer | 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);
+
+    // 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: HTMLElement, gameId: string): ENGINE.IGameLoop {
+  const game = new FirstPersonGame(container, {
+    ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+    gameId
+  });
+  return game;
+}