@directivegames/genesys.sdk 3.2.2

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

@@ -0,0 +1,6 @@
+import { mockBrowserEnvironment as engineMock } from 'genesys.js';
+import { JSDOM } from 'jsdom';
+
+export function mockBrowserEnvironment() {
+  engineMock(JSDOM);
+}

package/src/templates/scripts/genesys/place-actors.ts

@@ -0,0 +1,179 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+
+import { ThreeEulerSchema, ThreeVector3Schema } from './mcp/search-actors.js';
+import { loadWorld, registerGameClassesIfAnyNotRegistered } from './mcp/utils.js';
+import { mockBrowserEnvironment } from './mock.js';
+
+import '../src/game.js';
+
+
+mockBrowserEnvironment();
+
+function convertConstructorParams(value: any): any {
+  // If not an object, return as is
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  // Check if it's a Vector3
+  const vector3Result = ThreeVector3Schema.safeParse(value);
+  if (vector3Result.success) {
+    return new THREE.Vector3(
+      vector3Result.data.x,
+      vector3Result.data.y,
+      vector3Result.data.z
+    );
+  }
+
+  // Check if it's an Euler
+  const eulerResult = ThreeEulerSchema.safeParse(value);
+  if (eulerResult.success) {
+    return new THREE.Euler(
+      eulerResult.data.x,
+      eulerResult.data.y,
+      eulerResult.data.z
+    );
+  }
+
+  // Handle arrays
+  if (Array.isArray(value)) {
+    return value.map(convertConstructorParams);
+  }
+
+  // Handle objects
+  const result: Record<string, any> = {};
+  for (const [key, val] of Object.entries(value)) {
+    result[key] = convertConstructorParams(val);
+  }
+  return result;
+}
+
+
+export async function placePrimitive(args: {
+  sceneName: string;
+  primitiveActors: ENGINE.WorldCommands.PrimitiveActorArgs[];
+}): Promise<string[]> {
+
+  using worldResource = await loadWorld(args.sceneName, { skipLoadingGLTF: true });
+
+  const actors = ENGINE.WorldCommands.placePrimitives({
+    world: worldResource.world,
+    primitiveActors: args.primitiveActors,
+  });
+
+  return actors.map(actor => actor.uuid);
+}
+
+
+export async function removeActors(args: {
+  sceneName: string;
+  actorIds: string[];
+}) {
+  using worldResource = await loadWorld(args.sceneName, { skipLoadingGLTF: true });
+
+  ENGINE.WorldCommands.removeActorsByUuids({
+    world: worldResource.world,
+    actorIds: args.actorIds,
+  });
+}
+
+export async function addGltf(args: {
+  sceneName: string;
+  gltfs: ENGINE.WorldCommands.GltfArgs[];
+}) {
+  using worldResource = await loadWorld(args.sceneName, { skipLoadingGLTF: true });
+
+  const actors = await ENGINE.WorldCommands.placeGltfs({
+    world: worldResource.world,
+    gltfs: args.gltfs
+  });
+
+  return actors.map(actor => actor.uuid);
+}
+
+export async function placePrefab(args: {
+  sceneName: string;
+  prefabs: ENGINE.WorldCommands.PrefabArgs[];
+}) {
+  using worldResource = await loadWorld(args.sceneName, { skipLoadingGLTF: true });
+
+  const actors = await ENGINE.WorldCommands.placePrefabs({
+    world: worldResource.world,
+    prefabs: args.prefabs
+  });
+
+  return actors.map(actor => actor.uuid);
+}
+
+export async function placeJsClassActor(args: {
+  sceneName: string;
+  jsClasses: {
+    className: string;
+    constructorParams?: Record<string, any>[]
+    actorInfo?: ENGINE.WorldCommands.ActorMiscInfo;
+  }[]
+}): Promise<string[]> {
+  await registerGameClassesIfAnyNotRegistered(
+    args.jsClasses.map(jsClass => jsClass.className)
+  );
+  using worldResource = await loadWorld(args.sceneName, { skipLoadingGLTF: true });
+
+  const actors: ENGINE.Actor[] = [];
+
+  for (const { className, constructorParams, actorInfo } of args.jsClasses) {
+    try {
+      // Convert constructor parameters if they exist
+      const convertedParams = constructorParams ? convertConstructorParams(constructorParams) : [];
+
+      const actor = ENGINE.ClassRegistry.constructObject(className, false, ...convertedParams);
+      if (actorInfo) {
+        Object.assign(actor.editorData, actorInfo);
+      }
+      actors.push(actor);
+    } catch (e) {
+      console.error(`Error constructing object ${className}`, e);
+    }
+  }
+
+  worldResource.world.addActors(...actors);
+  return actors.map(actor => actor.uuid);
+}
+
+
+export async function updateActors(args: {
+  sceneName: string;
+  actorsToUpdate: {
+    uuid: string;
+    transform?: ENGINE.WorldCommands.Transform;
+    actorInfo?: ENGINE.WorldCommands.ActorMiscInfo;
+  }[];
+}): Promise<number> {
+  const readonly = args.actorsToUpdate.length == 0;
+  using worldResource = await loadWorld(args.sceneName, { readonly, skipLoadingGLTF: true });
+  let count = 0;
+
+  for (const { uuid, transform, actorInfo } of args.actorsToUpdate) {
+    const actor = worldResource.world.getActorByUuid(uuid);
+    if (!actor) {
+      continue;
+    }
+    if (transform) {
+      if (transform.position) {
+        actor.setWorldPosition(transform.position);
+      }
+      if (transform.rotation) {
+        actor.setWorldRotation(transform.rotation);
+      }
+      if (transform.scale) {
+        actor.setWorldScale(transform.scale);
+      }
+      if (actorInfo) {
+        Object.assign(actor.editorData, actorInfo);
+      }
+    }
+    count += 1;
+  }
+  return count;
+}
+

package/src/templates/scripts/genesys/post-install.ts

@@ -0,0 +1,30 @@
+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: string[] = [
+    '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/src/templates/scripts/genesys/prefab.schema.json

@@ -0,0 +1,85 @@
+{
+    "$schema": "https://json-schema.org/draft-07/schema",
+    "$id": "genesys.js.prefab.schema.json",
+    "type": "object",
+    "properties": {
+        "$version": {
+            "type": "integer"
+        },
+        "class": {
+            "$ref": "class_string"
+        },
+        "ctor": {
+            "$ref": "actor_ctor"
+        },
+        "properties": {
+            "$ref": "actor_properties"
+        }
+    },
+    "definitions": {
+        "actor_ctor": {
+            "type": "object",
+            "properties": {
+                "rootComponent": {
+                    "$ref": "component"
+                }
+            }
+        },
+        "actor_properties": {
+            "type": "object"
+        },
+        "component_ctor": {
+            "type": "object"
+        },
+        "component_properties": {
+            "type": "object",
+            "properties": {
+                "position": {
+                    "$ref": "type_vector3"
+                },
+                "rotation": {
+                    "$ref": "type_euler"
+                },
+                "scale": {
+                    "$ref": "type_euler"
+                }
+            }
+        },
+        "type_vector3": {
+            "type": "array",
+            "minItems": 4,
+            "maxItems": 4,
+            "examples": [[0, 0, 0, "v"]]
+        },
+        "type_euler": {
+            "type": "array",
+            "minItems": 4,
+            "maxItems": 4,
+            "examples": [[0, 0, 0, "e"]]
+        },
+        "component": {
+            "type": "object",
+            "properties": {
+                "class": {
+                    "$ref": "class_string"
+                },
+                "ctor": {
+                    "$ref": "component_ctor"
+                },
+                "properties": {
+                    "$ref": "component_properties"
+                },
+                "children": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "component"
+                    }
+                }
+            }
+        },
+        "class_string": {
+            "type": "string",
+            "pattern": "(GAME|ENGINE)\\..*"
+        }
+    }
+}

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 'genesys.js';
+import { AssetPath, AssetPathEncodeState } from '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);
+}