@directivegames/genesys.sdk 3.2.2

package/dist/src/templates/scripts/genesys/mcp/search-assets.js

@@ -0,0 +1,296 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ENGINE from 'genesys.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { BoundingBoxSchema, fetchBoundingBoxData } from '../calc-bounding-box.js';
+import { ENGINE_PREFIX, JS_CLASSES_DIR_NAME, PROJECT_PREFIX, SCENE_EXTENSION } from '../const.js';
+import { StorageProvider } from '../storageProvider.js';
+import { populateClassesInfo } from './search-actors.js';
+import { conditionallyRegisterGameClasses } from './utils.js';
+import { isSubclass } from './utils.js';
+// TODO: make it consistent to AssetType in genesys.ai
+export var AssetType;
+(function (AssetType) {
+    AssetType["Model"] = "model";
+    AssetType["Texture"] = "texture";
+    AssetType["HDRI"] = "hdri";
+    AssetType["Video"] = "video";
+    AssetType["Audio"] = "audio";
+    AssetType["Json"] = "json";
+    AssetType["Scene"] = "scene";
+    AssetType["Prefab"] = "prefab";
+    AssetType["Material"] = "material";
+    AssetType["SourceCode"] = "sourcecode";
+    AssetType["JsClass"] = "jsclass";
+})(AssetType || (AssetType = {}));
+const modelTypes = ['.glb', '.gltf'];
+export const assetDescriptions = {
+    [AssetType.Model]: '3D model files',
+    [AssetType.Texture]: 'Texture files',
+    [AssetType.HDRI]: 'HDRI files',
+    [AssetType.Video]: 'Video files',
+    [AssetType.Audio]: 'Audio files',
+    [AssetType.Scene]: 'Scenes, also known as levels, are generally used to represent distinct, playable areas in the game.',
+    [AssetType.Prefab]: 'Prefabs are actors that are prebuilt with components and can be placed in the scene directly. They generally extend Javascript classes to achieve more visual complex behavior.',
+    [AssetType.Material]: 'Material files',
+    [AssetType.SourceCode]: 'Source code files, including TypeScript and JavaScript files.',
+    [AssetType.JsClass]: 'JavaScript classes, which are actors that are implemented in code (Javascript). They contain visual and audio components, logics, or anything as they are implemented in code. They are often used directly in the scene, they also be used as a prefab base. Always consider this when placing things in the scene.',
+    [AssetType.Json]: 'JSON files, which are used to store data in a structured format.',
+};
+const assetTypeToExtensions = {
+    [AssetType.Model]: modelTypes,
+    [AssetType.Texture]: ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff', '.ico', '.webp'],
+    [AssetType.HDRI]: ['.hdr', '.exr'],
+    [AssetType.Video]: ['.mp4', '.webm', '.mov', '.avi', '.mkv'],
+    [AssetType.Audio]: ['.mp3', '.wav', '.ogg', '.m4a', '.aac'],
+    [AssetType.Scene]: [SCENE_EXTENSION],
+    [AssetType.Prefab]: ['.prefab.json'],
+    [AssetType.Material]: ['.material.json'],
+    [AssetType.SourceCode]: ['.ts', '.js', '.tsx', '.jsx'],
+    [AssetType.JsClass]: [],
+    [AssetType.Json]: ['.json'],
+};
+const findAssetType = (filePath) => {
+    if (filePath.includes(JS_CLASSES_DIR_NAME)) {
+        return AssetType.JsClass;
+    }
+    const extension = path.extname(filePath).toLowerCase();
+    for (const [assetType, extensions] of Object.entries(assetTypeToExtensions)) {
+        // make sure .json is checked last
+        if (assetType === AssetType.Json) {
+            continue;
+        }
+        if (extensions.includes(extension)) {
+            return assetType;
+        }
+    }
+    if (assetTypeToExtensions[AssetType.Json].includes(extension)) {
+        return AssetType.Json;
+    }
+    return undefined;
+};
+/**
+ * Recursively iterates a given directory and returns an array of all file paths
+ * that match the accepted types.
+ * @param dir The directory to iterate.
+ * @param acceptedTypes Array of accepted types.
+ * @returns An array of file paths.
+ */
+export async function searchForAssets(dirs, acceptedTypes = [], searchKeywords = []) {
+    for (const dir of dirs) {
+        if (!dir.startsWith(ENGINE.PROJECT_PATH_PREFIX) && !dir.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
+            throw new Error(`Directory ${dir} is not a valid project or engine directory`);
+        }
+    }
+    // make sure the game is built and classes are registered
+    await conditionallyRegisterGameClasses();
+    const acceptedExtensions = acceptedTypes.map(type => assetTypeToExtensions[type]).flat();
+    const getAll = acceptedTypes.length === 0;
+    const files = dirs.map(dir => collectFiles(dir, { getAll, acceptedExtensions })).flat();
+    // handle js classes in a special way.
+    if (getAll || acceptedTypes.includes(AssetType.JsClass)) {
+        const jsClasses = dirs.map(dir => {
+            const prefix = dir.includes(PROJECT_PREFIX) ? ENGINE.Prefix.GAME : (dir.includes(ENGINE_PREFIX) ? ENGINE.Prefix.ENGINE : '');
+            const registeredClasses = ENGINE.ClassRegistry.getRegistry();
+            const actorClasses = Array.from(registeredClasses.entries()).filter(([className, classCtor]) => className.startsWith(prefix) && isSubclass(classCtor, ENGINE.Actor) && !isSubclass(classCtor, ENGINE.BaseGameLoop));
+            return actorClasses.map(([key]) => `${JS_CLASSES_DIR_NAME}/${key}`);
+        });
+        files.push(...jsClasses.flat());
+    }
+    // convert file paths to unix paths
+    const assetPaths = files.map(filePath => filePath.replace(/\\/g, '/'));
+    // only peeking for basic metadata when searching assets to reduce the amount of data transferred
+    const result = await populateAssets(assetPaths, { peek: true });
+    // filter assets as we rely on not only names, but the metadata as well, to filter them
+    filterAssets(result, searchKeywords);
+    return result;
+}
+/**
+ * Gets the assets info with metadata for the given asset paths.
+ * @param assetPaths The paths of the assets to populate. It must be retrieved from `searchForAssets` function.
+ * @param options population options, such as `peek` to only populate basic metadata.
+ * @returns A promise that resolves to the assets info with metadata.
+ */
+export async function populateAssets(assetPaths, options) {
+    const result = {
+        metadataDescription: {},
+        assets: assetPaths.reduce((acc, assetPath) => {
+            acc[assetPath] = { type: findAssetType(assetPath) };
+            return acc;
+        }, {})
+    };
+    await populateModels(result, options);
+    await populateJsClasses(result, options);
+    return result;
+}
+function collectFiles(dir, options) {
+    let results = [];
+    const storageProvider = new StorageProvider();
+    const actualDir = storageProvider.getFullPath(dir);
+    const list = fs.readdirSync(actualDir);
+    // Normalize accepted extensions to lower case for case-insensitive comparison
+    const normalizedExtensions = options.acceptedExtensions.map(ext => ext.toLowerCase());
+    list.forEach((file) => {
+        const filePath = path.join(dir, file);
+        const actualFilePath = storageProvider.getFullPath(filePath);
+        const stat = fs.statSync(actualFilePath);
+        if (stat && stat.isDirectory()) {
+            results = results.concat(collectFiles(filePath, options));
+        }
+        else {
+            let shouldKeep = false;
+            if (options.getAll) {
+                shouldKeep = true;
+            }
+            else {
+                const fileName = path.basename(filePath).toLowerCase();
+                if (normalizedExtensions.some((ext) => fileName.endsWith(ext))) {
+                    shouldKeep = true;
+                }
+            }
+            if (shouldKeep) {
+                results.push(filePath);
+            }
+        }
+    });
+    return results;
+}
+function filterAssets(assets, searchKeywords = []) {
+    // if searchKeywords is not empty, filter the result
+    if (searchKeywords.length > 0) {
+        const rule = (filePath, metadata) => {
+            for (const keyword of searchKeywords) {
+                const kw = keyword.toLowerCase();
+                // if the file path contains any of the search keywords, return true
+                if (filePath.toLowerCase().includes(kw)) {
+                    return true;
+                }
+                // if the file metadata values contains any of the search keywords, return true
+                if (Object.values(metadata).some((metadataValue) => {
+                    return JSON.stringify(metadataValue).toLowerCase().includes(kw);
+                })) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        assets.assets = Object.fromEntries(Object.entries(assets.assets).filter(([filePath, metadata]) => rule(filePath, metadata)));
+    }
+}
+async function populateModels(assets, options) {
+    if (Object.values(assets.assets).some(asset => asset.type === AssetType.Model)) {
+        await populateModelsMetadata(assets);
+        if (!options?.peek) {
+            await populateBoundingBoxes(assets);
+        }
+    }
+}
+async function populateModelsMetadata(assets) {
+    // read manifest.json, and populate the result with the file details
+    const manifest = {};
+    const storageProvider = new StorageProvider();
+    for (const dir of [ENGINE.PROJECT_PATH_PREFIX, ENGINE.ENGINE_PATH_PREFIX]) {
+        const assetsManifest = path.join(dir, 'assets', 'manifest.json');
+        Object.assign(manifest, await storageProvider.downloadFileAsJson(ENGINE.AssetPath.fromString(assetsManifest)));
+    }
+    let metadataDescription = {};
+    if (manifest) {
+        // populate metadata description if it exists
+        metadataDescription = manifest['$metadata_description'] ?? {};
+        // populate the result with the file details
+        for (const [filePath, targetMetadata] of Object.entries(assets.assets)) {
+            const metadata = manifest[filePath];
+            if (metadata !== undefined && metadata !== null && metadata.constructor == Object) {
+                Object.assign(targetMetadata, metadata);
+            }
+        }
+    }
+    assets.metadataDescription[AssetType.Model] = {
+        ...assets.metadataDescription[AssetType.Model],
+        ...metadataDescription,
+    };
+}
+async function populateBoundingBoxes(assets) {
+    const modelFiles = Object.keys(assets.assets).filter(filePath => modelTypes.includes(path.extname(filePath).toLowerCase()));
+    // split model files into two groups - engine and project
+    const engineModelFiles = modelFiles.filter(filePath => filePath.startsWith(ENGINE.ENGINE_PATH_PREFIX));
+    const projectModelFiles = modelFiles.filter(filePath => filePath.startsWith(ENGINE.PROJECT_PATH_PREFIX));
+    const update = async (root, modelFiles) => {
+        const manifestFile = path.join(root, 'assets', 'bounding_box.json');
+        const storageProvider = new StorageProvider();
+        const gltfPaths = {};
+        for (const filePath of modelFiles) {
+            gltfPaths[filePath] = storageProvider.getFullPath(filePath);
+        }
+        const boundingBoxes = await fetchBoundingBoxData(storageProvider.getFullPath(manifestFile), gltfPaths);
+        for (const [filePath, boundingBox] of Object.entries(boundingBoxes)) {
+            assets.assets[filePath]['boundingBox'] = boundingBox;
+        }
+    };
+    if (engineModelFiles.length > 0) {
+        await update(ENGINE.ENGINE_PATH_PREFIX, engineModelFiles);
+    }
+    if (projectModelFiles.length > 0) {
+        await update(ENGINE.PROJECT_PATH_PREFIX, projectModelFiles);
+    }
+    if (engineModelFiles.length > 0 || projectModelFiles.length > 0) {
+        // also populate the metadata description for bounding box
+        const boundingBoxSchema = zodToJsonSchema(BoundingBoxSchema, 'BoundingBoxSchema');
+        const properties = boundingBoxSchema.definitions.BoundingBoxSchema.properties;
+        const boundingBoxDescription = {};
+        for (const key in properties) {
+            if (properties[key].description) {
+                boundingBoxDescription[key] = properties[key].description;
+            }
+        }
+        const metadataDescription = {
+            boundingBox: {
+                description: 'The bounding box info of model assets',
+                properties: boundingBoxDescription,
+            }
+        };
+        assets.metadataDescription[AssetType.Model] = {
+            ...assets.metadataDescription[AssetType.Model],
+            ...metadataDescription
+        };
+    }
+}
+async function populateJsClasses(assets, options) {
+    const jsClassNames = {};
+    for (const [filePath, metadata] of Object.entries(assets.assets)) {
+        if (filePath.includes(JS_CLASSES_DIR_NAME)) {
+            jsClassNames[filePath] = path.basename(filePath);
+        }
+    }
+    if (Object.keys(jsClassNames).length === 0) {
+        return;
+    }
+    const result = await populateClassesInfo({
+        classesToSearch: Object.values(jsClassNames),
+        includeConstructorParams: !options?.peek
+    });
+    if (result.actors
+        && Object.keys(result.actors).length > 0
+        && result.metadataDescription
+        && Object.keys(result.metadataDescription).length > 0) {
+        assets.metadataDescription[AssetType.JsClass] = result.metadataDescription;
+    }
+    for (const [filePath, metadata] of Object.entries(assets.assets)) {
+        if (filePath in jsClassNames) {
+            const className = jsClassNames[filePath];
+            const actorInfo = result.actors[className];
+            if (actorInfo) {
+                metadata.jsClassName = actorInfo.className;
+                if (!options?.peek) {
+                    metadata.jsClassFilePath = actorInfo.filePath;
+                    metadata.jsClassConstructorParams = actorInfo.constructorParams ?? [];
+                    metadata.jsClassCanPopulateFromJson = actorInfo.canPopulateFromJson ?? false;
+                }
+                metadata.jsClassDescription = actorInfo.description ?? '';
+            }
+            else {
+                console.warn(`Actor class ${className} not found in classes info for file ${filePath}`);
+            }
+        }
+    }
+}

package/dist/src/templates/scripts/genesys/mcp/utils.js

@@ -0,0 +1,234 @@
+import fs from 'fs';
+import path from 'path';
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { isDev } from '../common.js';
+import { mockBrowserEnvironment } from '../mock.js';
+import { getResolvedPath, StorageProvider } from '../storageProvider.js';
+const fileServerPort = !isDev ? 4000 : 4001;
+mockBrowserEnvironment();
+class ResourceManagerSkippingLoadingGLTF extends ENGINE.ResourceManager {
+    async loadModel(path) {
+        return null;
+    }
+}
+export const fixUpClassName = (className) => {
+    const allClasses = ENGINE.ClassRegistry.getRegistry();
+    if (allClasses.has(className)) {
+        return className;
+    }
+    const gameClassName = ENGINE.Prefix.GAME + className;
+    if (allClasses.has(gameClassName)) {
+        return gameClassName;
+    }
+    const engineClassName = ENGINE.Prefix.ENGINE + className;
+    if (allClasses.has(engineClassName)) {
+        return engineClassName;
+    }
+    throw new Error(`Class ${className} not found`);
+};
+export async function loadWorld(scenePath, options = {}) {
+    const storageProvider = new StorageProvider();
+    const cleanUp = ENGINE.projectContext({ project: 'local-project', storageProvider: storageProvider });
+    const sceneFile = scenePath;
+    let world = null;
+    let originalResourceManager = null;
+    if (!options.skipLoadingGLTF) {
+        originalResourceManager = ENGINE.resourceManager;
+        ENGINE.setResourceManager(new ResourceManagerSkippingLoadingGLTF());
+    }
+    try {
+        world = new ENGINE.World(defaultWorldOptions);
+        const worldData = await storageProvider.downloadFileAsJson(ENGINE.AssetPath.fromString(sceneFile));
+        // wait for all gltf mesh components to load, should probably move this into engine.
+        const actors = world.getActors(ENGINE.Actor);
+        const promises = actors.map(actor => actor.waitForComponentsToLoad());
+        await Promise.all(promises);
+        await ENGINE.WorldSerializer.loadWorld(world, worldData);
+    }
+    catch (error) {
+        cleanUp();
+        throw new Error(`Failed to load world from ${sceneFile}: ${error instanceof Error ? error.message : error}`);
+    }
+    finally {
+        if (originalResourceManager) {
+            ENGINE.setResourceManager(originalResourceManager);
+        }
+    }
+    return {
+        world: world,
+        [Symbol.dispose]() {
+            if (!options.readonly && world) {
+                const worldData = world.asExportedObject();
+                fs.writeFileSync(storageProvider.getFullPath(sceneFile), JSON.stringify(worldData, null, 2));
+            }
+            cleanUp();
+        }
+    };
+}
+export const defaultWorldOptions = {
+    rendererDomElement: document.createElement('div'),
+    gameContainer: document.createElement('div'),
+    backgroundColor: 0x2E2E2E,
+    physicsOptions: {
+        engine: ENGINE.PhysicsEngine.Rapier,
+        gravity: ENGINE.MathHelpers.makeVector({ up: -9.81 }),
+    },
+    navigationOptions: {
+        engine: ENGINE.NavigationEngine.RecastNavigation,
+    },
+    useManifold: true
+};
+export function mcpLogger(server) {
+    const originalConsoleLog = console.log;
+    const originalConsoleWarn = console.warn;
+    const originalConsoleError = console.error;
+    // it seems sendLoggingMessage isn't picked up by cursor as of 2025 July 17th,
+    // The log can't be found in any of the output channels, or in cursor logs
+    // for now we log to stderr, which is supported by MCP
+    // https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging
+    const sendLogToClient = false;
+    console.log = (...args) => {
+        originalConsoleError('[MCP Info]: ', ...args);
+        if (sendLogToClient) {
+            server.server.sendLoggingMessage({ level: 'info', data: args.join(' ') });
+        }
+    };
+    console.warn = (...args) => {
+        originalConsoleError('[MCP Warning]: ', ...args);
+        if (sendLogToClient) {
+            server.server.sendLoggingMessage({ level: 'warning', data: args.join(' ') });
+        }
+    };
+    console.error = (...args) => {
+        originalConsoleError('[MCP Error]: ', ...args);
+        if (sendLogToClient) {
+            server.server.sendLoggingMessage({ level: 'error', data: args.join(' ') });
+        }
+    };
+    return {
+        [Symbol.dispose]() {
+            console.log = originalConsoleLog;
+            console.warn = originalConsoleWarn;
+            console.error = originalConsoleError;
+        }
+    };
+}
+export function isSubclass(child, parent) {
+    if (typeof child !== 'function' || typeof parent !== 'function')
+        return false;
+    let proto = child;
+    while (proto) {
+        if (proto === parent)
+            return true;
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+}
+async function buildProject() {
+    const url = `http://localhost:${fileServerPort}/api/build-project`;
+    const options = {
+        method: 'POST'
+    };
+    const response = await fetch(url, options);
+    if (!response.ok) {
+        throw new Error(`Failed to rebuild game.js: ${response.statusText}`);
+    }
+    const result = await response.json();
+    return result;
+}
+export async function registerGameClasses() {
+    const bundlePath = ENGINE.AssetPath.fromString(ENGINE.AssetPath.join(ENGINE.PROJECT_PATH_PREFIX, '.dist', 'game.js'));
+    const storageProvider = new StorageProvider();
+    storageProvider.resolvePath(bundlePath);
+    try {
+        const buildProjectResult = await buildProject();
+        const bundleFullPath = getResolvedPath(bundlePath);
+        if (!fs.existsSync(bundleFullPath)) {
+            throw new Error(`bundle file not found at ${bundleFullPath}, please make sure build project is successful, buildProject result: ${JSON.stringify(buildProjectResult)}`);
+        }
+        const bundleText = fs.readFileSync(bundleFullPath, 'utf8');
+        const injectedDependencies = (mod) => {
+            if (mod === 'genesys.js')
+                return ENGINE;
+            if (mod === 'three')
+                return THREE;
+            throw new Error(`Unknown module: ${mod}`);
+        };
+        ENGINE.ClassRegistry.clearGameClasses();
+        // Create a module-like object to simulate CommonJS environment
+        const moduleObj = { exports: {} };
+        const run = new Function('require', 'module', bundleText);
+        run(injectedDependencies, moduleObj);
+        // Apply any exports to the global scope if needed
+        if (moduleObj.exports && typeof moduleObj.exports === 'object') {
+            Object.assign(window, moduleObj.exports);
+        }
+    }
+    catch (error) {
+        console.error('Error registering game classes', error);
+    }
+}
+export function isClassRegistered(className) {
+    return ENGINE.ClassRegistry.getRegistry().has(className);
+}
+export async function registerGameClassesIfAnyNotRegistered(classNamesToCheck) {
+    const validNames = classNamesToCheck.filter((className) => className.startsWith(ENGINE.Prefix.GAME) || className.startsWith(ENGINE.Prefix.ENGINE));
+    if (validNames.some(className => !isClassRegistered(className))) {
+        await registerGameClasses();
+    }
+}
+export async function conditionallyRegisterGameClasses() {
+    const storageProvider = new StorageProvider();
+    const bundlePath = ENGINE.AssetPath.fromString(ENGINE.AssetPath.join(ENGINE.PROJECT_PATH_PREFIX, '.dist', 'game.js'));
+    storageProvider.resolvePath(bundlePath);
+    const srcDir = ENGINE.AssetPath.fromString(ENGINE.AssetPath.join(ENGINE.PROJECT_PATH_PREFIX, 'src'));
+    storageProvider.resolvePath(srcDir);
+    // Check if .dist/game.js exists
+    if (!fs.existsSync(bundlePath.getResolvedPath())) {
+        // If game.js doesn't exist, we need to register classes
+        await registerGameClasses();
+        return;
+    }
+    const bundleFileStats = fs.statSync(getResolvedPath(bundlePath));
+    const bundleFileTimestamp = bundleFileStats.mtime.getTime();
+    console.log('bundleFileTimestamp:', new Date(bundleFileTimestamp));
+    // Check if src directory exists
+    if (!fs.existsSync(getResolvedPath(srcDir))) {
+        console.log('No src directory, no need to register classes');
+        return; // No src directory, nothing to check
+    }
+    // Recursively find all js, jsx, ts, tsx files in src directory
+    const sourceFiles = findSourceFiles(getResolvedPath(srcDir));
+    // Check if any source file is newer than game.js
+    for (const sourceFile of sourceFiles) {
+        const sourceStats = fs.statSync(sourceFile);
+        const sourceTime = sourceStats.mtime.getTime();
+        if (sourceTime > bundleFileTimestamp) {
+            // Found a newer source file, register classes and return
+            console.log(`Found a newer source file, ${sourceFile}, timestamp ${new Date(sourceTime)}, registering classes`);
+            await registerGameClasses();
+            return;
+        }
+    }
+    console.log('No newer source files found, no need to register classes');
+}
+function findSourceFiles(dir) {
+    const sourceFiles = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // Recursively search subdirectories
+            sourceFiles.push(...findSourceFiles(fullPath));
+        }
+        else if (entry.isFile()) {
+            // Check if file has one of the target extensions
+            const ext = path.extname(entry.name).toLowerCase();
+            if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
+                sourceFiles.push(fullPath);
+            }
+        }
+    }
+    return sourceFiles;
+}

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

@@ -0,0 +1,32 @@
+import path from 'path';
+import * as ENGINE from 'genesys.js';
+import { getProjectRoot } from './common.js';
+import { isSubclass } from './mcp/utils.js';
+import { fixUpClassName, registerGameClasses } from './mcp/utils.js';
+import { StorageProvider } from './storageProvider.js';
+export async function generateCode(className, filePath, baseClassName) {
+    try {
+        baseClassName = fixUpClassName(baseClassName);
+    }
+    catch (error) {
+        // if the base class name is not found, register all game classes and try again
+        await registerGameClasses();
+        baseClassName = fixUpClassName(baseClassName);
+    }
+    using context = ENGINE.scopedProjectContext({ project: 'mcp-project', storageProvider: new StorageProvider() });
+    const testIsSubclass = (childName, parent) => {
+        const child = ENGINE.ClassRegistry.getRegistry().get(childName);
+        if (!child) {
+            return false;
+        }
+        return isSubclass(child, parent);
+    };
+    const fullFilePath = path.isAbsolute(filePath) ? filePath : path.join(getProjectRoot(), filePath);
+    let fileGenerated = false;
+    const isSubclassOfActor = testIsSubclass(baseClassName, ENGINE.Actor);
+    if (isSubclassOfActor) {
+        await ENGINE.WorldCommands.generateActorTemplateFile(className, fullFilePath, baseClassName);
+        fileGenerated = true;
+    }
+    return fileGenerated;
+}

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

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

package/dist/src/templates/scripts/genesys/place-actors.js

@@ -0,0 +1,112 @@
+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) {
+    // 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 = {};
+    for (const [key, val] of Object.entries(value)) {
+        result[key] = convertConstructorParams(val);
+    }
+    return result;
+}
+export async function placePrimitive(args) {
+    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) {
+    using worldResource = await loadWorld(args.sceneName, { skipLoadingGLTF: true });
+    ENGINE.WorldCommands.removeActorsByUuids({
+        world: worldResource.world,
+        actorIds: args.actorIds,
+    });
+}
+export async function addGltf(args) {
+    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) {
+    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) {
+    await registerGameClassesIfAnyNotRegistered(args.jsClasses.map(jsClass => jsClass.className));
+    using worldResource = await loadWorld(args.sceneName, { skipLoadingGLTF: true });
+    const actors = [];
+    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) {
+    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;
+}