@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/export/Construct3Exporter.js

@@ -0,0 +1,832 @@
+'use strict';
+
+var PlatformExporter = require('./PlatformExporter.js');
+
+/* ────────────────────────────────────────────────────────────────
+   Construct 3 Exporter — C3P Project Export
+   
+   Exports Nice2Dev projects to Construct 3 format:
+   - Project files (.c3proj)
+   - Layout files (.json)
+   - Event sheets (.json)
+   - JavaScript addons
+   - Object types
+──────────────────────────────────────────────────────────────── */
+/* ── UUID Generator ───────────────────────────────────────────── */
+function generateC3UID() {
+    return 'c3-' + Math.random().toString(36).substr(2, 9);
+}
+/* ── Construct 3 Component Mappings ───────────────────────────── */
+const C3_BEHAVIOR_MAP = {
+    rigidbody: {
+        behavior: 'Physics',
+        properties: {
+            mass: 'mass',
+            linearDamping: 'linearDamping',
+            angularDamping: 'angularDamping',
+        },
+    },
+    movement: {
+        behavior: 'EightDirection',
+        properties: {
+            speed: 'maxSpeed',
+            acceleration: 'acceleration',
+            deceleration: 'deceleration',
+        },
+    },
+    platformer: {
+        behavior: 'Platform',
+        properties: {
+            speed: 'maxSpeed',
+            jumpStrength: 'jumpStrength',
+            gravity: 'gravity',
+        },
+    },
+    bullet: {
+        behavior: 'Bullet',
+        properties: {
+            speed: 'speed',
+            acceleration: 'acceleration',
+        },
+    },
+    solid: {
+        behavior: 'Solid',
+        properties: {},
+    },
+    timer: {
+        behavior: 'Timer',
+        properties: {},
+    },
+    fade: {
+        behavior: 'Fade',
+        properties: {
+            fadeInTime: 'fadeInTime',
+            fadeOutTime: 'fadeOutTime',
+        },
+    },
+};
+/* ── Exporter Implementation ──────────────────────────────────── */
+class Construct3Exporter extends PlatformExporter.PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'construct3';
+        this.platformInfo = {
+            id: 'construct3',
+            name: 'Construct 3',
+            description: 'Construct 3 - visual game development environment with JavaScript scripting',
+            website: 'https://www.construct.net/',
+            features: [
+                '2d-rendering',
+                'physics-2d',
+                'audio',
+                'particles',
+                'ui-system',
+                'tilemaps',
+                'animation',
+            ],
+            supportedAssets: [
+                'texture',
+                'audio',
+                'tilemap',
+                'animation',
+                'prefab',
+                'scene',
+                'data',
+                'script',
+            ],
+            exportFormats: ['.c3p', '.c3proj', '.json'],
+        };
+        this.projectId = '';
+        this.uidCounter = 0;
+    }
+    async doExport(project, options) {
+        this.projectId = generateC3UID();
+        this.uidCounter = 0;
+        const platformOpts = options.platformOptions ?? {};
+        if (platformOpts.exportAsAddon) {
+            await this.exportAsAddon(project, options);
+        }
+        else {
+            await this.exportAsProject(project, options);
+        }
+    }
+    /* ── Full Project Export ────────────────────────────────────── */
+    async exportAsProject(project, options) {
+        (options.projectName ?? project.name).replace(/[^a-zA-Z0-9]/g, '');
+        // Generate main project file
+        const c3Project = this.generateProjectFile(project, options);
+        this.addTextFile('project.c3proj', JSON.stringify(c3Project, null, '\t'));
+        // Generate object types
+        await this.generateObjectTypes(project, options);
+        // Generate layouts (scenes)
+        for (const scene of project.scenes) {
+            await this.exportLayout(scene, project, options);
+        }
+        // Generate event sheets
+        for (const scene of project.scenes) {
+            await this.generateEventSheet(scene, project, options);
+        }
+        // Generate scripts
+        await this.generateScripts(project, options);
+        // Generate README
+        await this.generateReadme(project, options);
+    }
+    generateProjectFile(project, options) {
+        const safeName = (options.projectName ?? project.name).replace(/[^a-zA-Z0-9]/g, '');
+        const platformOpts = options.platformOptions ?? {};
+        const layouts = project.scenes.map((s) => s.name.replace(/[^a-zA-Z0-9_]/g, '_'));
+        const eventSheets = project.scenes.map((s) => `${s.name.replace(/[^a-zA-Z0-9_]/g, '_')}_Events`);
+        const objectTypes = this.collectObjectTypes(project);
+        const usedAddons = [
+            { type: 'plugin', id: 'Sprite', name: 'Sprite', author: 'Scirra', bundled: false },
+            { type: 'plugin', id: 'Audio', name: 'Audio', author: 'Scirra', bundled: false },
+            { type: 'plugin', id: 'Keyboard', name: 'Keyboard', author: 'Scirra', bundled: false },
+            { type: 'plugin', id: 'Mouse', name: 'Mouse', author: 'Scirra', bundled: false },
+            { type: 'plugin', id: 'Touch', name: 'Touch', author: 'Scirra', bundled: false },
+        ];
+        if (platformOpts.useBuiltInPhysics !== false) {
+            usedAddons.push({
+                type: 'behavior',
+                id: 'Physics',
+                name: 'Physics',
+                author: 'Scirra',
+                bundled: false,
+            });
+        }
+        return {
+            projectFormatVersion: 1,
+            savedWithRelease: 40000,
+            name: safeName,
+            runtime: 'c3',
+            useWorker: 'auto',
+            bundleAddons: true,
+            usedAddons,
+            uniqueId: this.projectId,
+            objectTypes: { items: objectTypes, subfolders: [] },
+            containers: [],
+            families: { items: [], subfolders: [] },
+            layouts: { items: layouts, subfolders: [] },
+            eventSheets: { items: eventSheets, subfolders: [] },
+            rootFileFolders: {
+                script: { items: ['main.js', 'importsForEvents.js'], subfolders: [] },
+                sound: { items: [], subfolders: [] },
+                music: { items: [], subfolders: [] },
+                video: { items: [], subfolders: [] },
+                font: { items: [], subfolders: [] },
+                icon: { items: [], subfolders: [] },
+                general: { items: [], subfolders: [] },
+            },
+            timelines: { items: [], subfolders: [] },
+            flowcharts: { items: [], subfolders: [] },
+            properties: {
+                description: `Generated from Nice2Dev project: ${project.name}`,
+                version: project.version,
+                author: 'Nice2Dev',
+                authorEmail: '',
+                website: 'https://nice2dev.com',
+                backgroundColour: [0, 0, 0],
+                splashColour: [0, 0, 0],
+                useThemeColour: false,
+                themeColour: [66, 133, 244],
+                orientations: 'landscape',
+                webgpu: 'auto',
+                gpuPreference: 'high-performance',
+                scriptsType: 'module',
+                framerateMode: 'vsync',
+                compositingMode: 'standard',
+                sampling: 'trilinear',
+                downscaling: 'medium',
+                maxSpriteSheetSize: 4096,
+                loaderStyle: 'splash',
+                preloadSounds: 'yes',
+                cordovaDirectory: '',
+                exportFileStructure: 'folders',
+            },
+            viewportWidth: project.settings.resolution.width,
+            viewportHeight: project.settings.resolution.height,
+            firstLayout: layouts[0] ?? 'Layout1',
+        };
+    }
+    collectObjectTypes(project) {
+        const types = new Set();
+        // Add system objects
+        types.add('Keyboard');
+        types.add('Mouse');
+        types.add('Touch');
+        types.add('Audio');
+        // Add entities as sprite types
+        for (const scene of project.scenes) {
+            for (const entity of scene.entities) {
+                const typeName = (entity.name ?? entity.id).replace(/[^a-zA-Z0-9_]/g, '_');
+                types.add(typeName);
+            }
+        }
+        // Add prefabs
+        for (const prefab of project.prefabs) {
+            const typeName = prefab.name.replace(/[^a-zA-Z0-9_]/g, '_');
+            types.add(typeName);
+        }
+        return Array.from(types);
+    }
+    /* ── Object Types ───────────────────────────────────────────── */
+    async generateObjectTypes(project, options) {
+        // System objects
+        this.addTextFile('objectTypes/Keyboard.json', JSON.stringify({
+            c3object: true,
+            name: 'Keyboard',
+            type: 'world',
+            plugin: 'Keyboard',
+        }, null, '\t'));
+        this.addTextFile('objectTypes/Mouse.json', JSON.stringify({
+            c3object: true,
+            name: 'Mouse',
+            type: 'world',
+            plugin: 'Mouse',
+        }, null, '\t'));
+        this.addTextFile('objectTypes/Touch.json', JSON.stringify({
+            c3object: true,
+            name: 'Touch',
+            type: 'world',
+            plugin: 'Touch',
+        }, null, '\t'));
+        this.addTextFile('objectTypes/Audio.json', JSON.stringify({
+            c3object: true,
+            name: 'Audio',
+            type: 'world',
+            plugin: 'Audio',
+        }, null, '\t'));
+        // Entity objects
+        const processedTypes = new Set();
+        for (const scene of project.scenes) {
+            for (const entity of scene.entities) {
+                const typeName = (entity.name ?? entity.id).replace(/[^a-zA-Z0-9_]/g, '_');
+                if (processedTypes.has(typeName)) {
+                    continue;
+                }
+                processedTypes.add(typeName);
+                await this.generateObjectType(typeName, entity, options);
+            }
+        }
+        // Prefab objects
+        for (const prefab of project.prefabs) {
+            const typeName = prefab.name.replace(/[^a-zA-Z0-9_]/g, '_');
+            if (processedTypes.has(typeName)) {
+                continue;
+            }
+            processedTypes.add(typeName);
+            await this.generateObjectType(typeName, prefab.entity, options);
+        }
+    }
+    async generateObjectType(typeName, entity, options) {
+        const behaviors = {};
+        const instanceVariables = {};
+        // Map components to behaviors
+        for (const comp of entity.components) {
+            const mapping = C3_BEHAVIOR_MAP[comp.type];
+            if (mapping) {
+                behaviors[mapping.behavior] = {
+                    behaviorType: mapping.behavior,
+                    ...this.mapProperties(comp.properties ?? {}, mapping.properties),
+                };
+            }
+        }
+        // Add instance variables from tags
+        for (const tag of entity.tags ?? []) {
+            instanceVariables[`tag_${tag}`] = { type: 'boolean', initialValue: true };
+        }
+        const objectType = {
+            c3object: true,
+            name: typeName,
+            type: 'world',
+            plugin: 'Sprite',
+            isGlobal: false,
+            isInteractive: true,
+            instanceVars: instanceVariables,
+            behaviors,
+            effectList: { list: [] },
+            defaultImageWidth: 64,
+            defaultImageHeight: 64,
+            animations: {
+                items: [
+                    {
+                        name: 'Default',
+                        speed: 5,
+                        loop: true,
+                        repeatCount: 1,
+                        repeatTo: 0,
+                        pingPong: false,
+                        frames: [{ duration: 1 }],
+                    },
+                ],
+                subfolders: [],
+            },
+        };
+        this.addTextFile(`objectTypes/${typeName}.json`, JSON.stringify(objectType, null, '\t'));
+    }
+    mapProperties(props, mapping) {
+        const result = {};
+        for (const [from, to] of Object.entries(mapping)) {
+            if (props[from] !== undefined) {
+                result[to] = props[from];
+            }
+        }
+        return result;
+    }
+    /* ── Layout Export ──────────────────────────────────────────── */
+    async exportLayout(scene, project, options) {
+        const layoutName = scene.name.replace(/[^a-zA-Z0-9_]/g, '_');
+        const layout = {
+            c3dtg: true,
+            name: layoutName,
+            width: project.settings.resolution.width,
+            height: project.settings.resolution.height,
+            unboundedScrolling: true,
+            originX: 0,
+            originY: 0,
+            eventSheet: `${layoutName}_Events`,
+            layers: [
+                {
+                    name: 'Main',
+                    type: 'layer',
+                    index: 0,
+                    isVisible: true,
+                    isLocked: false,
+                    initiallyVisible: true,
+                    scrollRateX: 100,
+                    scrollRateY: 100,
+                    zElevation: 0,
+                    parallaxX: 100,
+                    parallaxY: 100,
+                    opacity: 100,
+                    forceOwnTexture: false,
+                    ownTextureAlpha: false,
+                    zIndex: 0,
+                    blendMode: 'normal',
+                    effectList: { list: [] },
+                    instances: scene.entities.map((entity) => this.entityToInstance(entity)),
+                },
+            ],
+        };
+        this.addTextFile(`layouts/${layoutName}.json`, JSON.stringify(layout, null, '\t'));
+    }
+    entityToInstance(entity) {
+        const pos = entity.position ?? { x: 0, y: 0 };
+        const scale = entity.scale ?? { x: 1, y: 1 };
+        const typeName = (entity.name ?? entity.id).replace(/[^a-zA-Z0-9_]/g, '_');
+        const behaviors = {};
+        for (const comp of entity.components) {
+            const mapping = C3_BEHAVIOR_MAP[comp.type];
+            if (mapping) {
+                behaviors[mapping.behavior] = this.mapProperties(comp.properties ?? {}, mapping.properties);
+            }
+        }
+        return {
+            type: typeName,
+            uid: this.uidCounter++,
+            x: pos.x,
+            y: pos.y,
+            width: 64 * scale.x,
+            height: 64 * scale.y,
+            originX: 0.5,
+            originY: 0.5,
+            angle: entity.rotation ?? 0,
+            opacity: 100,
+            zElevation: 0,
+            colorRgb: [255, 255, 255],
+            blendMode: 'normal',
+            effectList: { list: [] },
+            behaviors,
+            instVars: {},
+        };
+    }
+    /* ── Event Sheet ────────────────────────────────────────────── */
+    async generateEventSheet(scene, project, options) {
+        const sheetName = `${scene.name.replace(/[^a-zA-Z0-9_]/g, '_')}_Events`;
+        const eventSheet = {
+            c3eventsheet: true,
+            name: sheetName,
+            events: [
+                {
+                    eventType: 'comment',
+                    children: undefined,
+                    conditions: undefined,
+                    actions: undefined,
+                },
+                // On start of layout
+                {
+                    eventType: 'block',
+                    conditions: [
+                        {
+                            id: 'on-start-of-layout',
+                            objectType: 'System',
+                        },
+                    ],
+                    actions: [
+                        {
+                            id: 'log',
+                            objectType: 'System',
+                            parameters: { message: `Scene ${scene.name} started` },
+                        },
+                    ],
+                },
+                // Main loop
+                {
+                    eventType: 'block',
+                    conditions: [
+                        {
+                            id: 'every-tick',
+                            objectType: 'System',
+                        },
+                    ],
+                    actions: [],
+                    children: this.generateEntityEvents(scene.entities),
+                },
+            ],
+        };
+        this.addTextFile(`eventSheets/${sheetName}.json`, JSON.stringify(eventSheet, null, '\t'));
+    }
+    generateEntityEvents(entities) {
+        const events = [];
+        for (const entity of entities) {
+            (entity.name ?? entity.id).replace(/[^a-zA-Z0-9_]/g, '_');
+            // Generate movement events based on components
+            const hasMovement = entity.components.some((c) => c.type === 'movement');
+            if (hasMovement) {
+                events.push({
+                    eventType: 'comment',
+                    conditions: undefined,
+                    actions: undefined,
+                    children: undefined,
+                });
+            }
+        }
+        return events;
+    }
+    /* ── Scripts ────────────────────────────────────────────────── */
+    async generateScripts(project, options) {
+        // Main script
+        const mainScript = `// ${project.name} - Nice2Dev Export for Construct 3
+// Generated automatically
+
+// Runtime reference
+const runtime = globalThis.runtime;
+
+// Game state
+const gameState = {
+    isPaused: false,
+    entities: new Map(),
+    globalVariables: new Map(),
+};
+
+// Settings from Nice2Dev
+export const GameSettings = {
+    width: ${project.settings.resolution.width},
+    height: ${project.settings.resolution.height},
+    masterVolume: ${project.settings.audio.masterVolume},
+    physicsEnabled: ${project.settings.physics.enabled},
+    gravity: { x: ${project.settings.physics.gravity.x}, y: ${project.settings.physics.gravity.y} },
+};
+
+// Entity class
+export class N2DEntity {
+    constructor(instance) {
+        this.instance = instance;
+        this.name = instance.objectType.name;
+        this.components = [];
+        this.tags = [];
+    }
+    
+    addComponent(type, properties = {}) {
+        this.components.push({ type, properties });
+    }
+    
+    hasComponent(type) {
+        return this.components.some(c => c.type === type);
+    }
+    
+    getComponent(type) {
+        return this.components.find(c => c.type === type);
+    }
+    
+    hasTag(tag) {
+        return this.tags.includes(tag);
+    }
+    
+    addTag(tag) {
+        if (!this.hasTag(tag)) {
+            this.tags.push(tag);
+        }
+    }
+    
+    get position() {
+        return { x: this.instance.x, y: this.instance.y };
+    }
+    
+    set position(pos) {
+        this.instance.x = pos.x;
+        this.instance.y = pos.y;
+    }
+    
+    destroy() {
+        this.instance.destroy();
+        gameState.entities.delete(this.instance.uid);
+    }
+}
+
+// Variable system
+export const Variables = {
+    set(name, value) {
+        gameState.globalVariables.set(name, value);
+    },
+    
+    get(name, defaultValue = null) {
+        return gameState.globalVariables.has(name) 
+            ? gameState.globalVariables.get(name)
+            : defaultValue;
+    },
+    
+    has(name) {
+        return gameState.globalVariables.has(name);
+    },
+    
+    remove(name) {
+        gameState.globalVariables.delete(name);
+    },
+};
+
+// Pause/Resume
+export function pauseGame() {
+    gameState.isPaused = true;
+}
+
+export function resumeGame() {
+    gameState.isPaused = false;
+}
+
+export function isPaused() {
+    return gameState.isPaused;
+}
+
+// Entity management
+export function registerEntity(instance) {
+    const entity = new N2DEntity(instance);
+    gameState.entities.set(instance.uid, entity);
+    return entity;
+}
+
+export function getEntity(uid) {
+    return gameState.entities.get(uid);
+}
+
+export function getAllEntities() {
+    return Array.from(gameState.entities.values());
+}
+
+export function getEntitiesByTag(tag) {
+    return getAllEntities().filter(e => e.hasTag(tag));
+}
+
+// Initialize on runtime ready
+runOnStartup(async runtime => {
+    console.log('[N2D] ${project.name} initialized');
+});
+`;
+        this.addTextFile('scripts/main.js', mainScript);
+        // Imports for events
+        const importsScript = `// Imports for event sheets
+// Add any exports here that should be accessible from event sheets
+
+export * from './main.js';
+`;
+        this.addTextFile('scripts/importsForEvents.js', importsScript);
+    }
+    /* ── Addon Export ───────────────────────────────────────────── */
+    async exportAsAddon(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        const addonId = platformOpts.addonId ?? project.name.toLowerCase().replace(/[^a-z0-9]/g, '');
+        // Addon JSON
+        const addon = {
+            'is-c3-addon': true,
+            type: 'behavior',
+            name: project.name,
+            id: `Nice2Dev_${addonId}`,
+            version: project.version,
+            author: 'Nice2Dev',
+            website: 'https://nice2dev.com',
+            documentation: '',
+            description: `${project.name} - Generated from Nice2Dev`,
+            'editor-scripts': ['editor.js'],
+            'file-list': ['c3runtime/behavior.js', 'c3runtime/instance.js', 'c3runtime/type.js'],
+        };
+        this.addTextFile('addon.json', JSON.stringify(addon, null, '\t'));
+        // Editor script
+        const editorScript = `"use strict";
+
+{
+    const BEHAVIOR_ID = "Nice2Dev_${addonId}";
+    const BEHAVIOR_VERSION = "${project.version}";
+    const BEHAVIOR_CATEGORY = "general";
+
+    const BEHAVIOR_CLASS = SDK.Behaviors.Nice2Dev_${addonId} = class Nice2Dev_${addonId} extends SDK.IBehaviorBase {
+        constructor() {
+            super(BEHAVIOR_ID);
+            SDK.Lang.PushContext("behaviors." + BEHAVIOR_ID.toLowerCase());
+            this._info.SetName(Lang(".name"));
+            this._info.SetDescription(Lang(".description"));
+            this._info.SetVersion(BEHAVIOR_VERSION);
+            this._info.SetCategory(BEHAVIOR_CATEGORY);
+            this._info.SetAuthor("Nice2Dev");
+            this._info.SetHelpUrl("https://nice2dev.com");
+            this._info.SetIsOnlyOneAllowed(false);
+            SDK.Lang.PopContext();
+        }
+    };
+
+    BEHAVIOR_CLASS.Register(BEHAVIOR_ID, BEHAVIOR_CLASS);
+}
+`;
+        this.addTextFile('editor.js', editorScript);
+        // Runtime behavior
+        const runtimeBehavior = `"use strict";
+
+{
+    const C3 = self.C3;
+
+    C3.Behaviors.Nice2Dev_${addonId} = class Nice2Dev_${addonId} extends C3.SDKBehaviorBase {
+        constructor(opts) {
+            super(opts);
+        }
+        
+        Release() {
+            super.Release();
+        }
+    };
+}
+`;
+        this.addTextFile('c3runtime/behavior.js', runtimeBehavior);
+        // Runtime instance
+        const runtimeInstance = `"use strict";
+
+{
+    const C3 = self.C3;
+
+    C3.Behaviors.Nice2Dev_${addonId}.Instance = class Nice2Dev_${addonId}Instance extends C3.SDKBehaviorInstanceBase {
+        constructor(behInst, properties) {
+            super(behInst);
+            
+            // Nice2Dev game state
+            this._gameState = {
+                variables: new Map(),
+                isPaused: false,
+            };
+            
+            // Import Nice2Dev settings
+            this._settings = {
+                width: ${project.settings.resolution.width},
+                height: ${project.settings.resolution.height},
+                gravity: { x: ${project.settings.physics.gravity.x}, y: ${project.settings.physics.gravity.y} },
+            };
+        }
+        
+        Release() {
+            super.Release();
+        }
+        
+        SaveToJson() {
+            return {
+                variables: Object.fromEntries(this._gameState.variables),
+                isPaused: this._gameState.isPaused,
+            };
+        }
+        
+        LoadFromJson(o) {
+            this._gameState.variables = new Map(Object.entries(o.variables || {}));
+            this._gameState.isPaused = o.isPaused || false;
+        }
+        
+        Tick() {
+            if (this._gameState.isPaused) return;
+            // Update logic here
+        }
+        
+        // Actions
+        SetVariable(name, value) {
+            this._gameState.variables.set(name, value);
+        }
+        
+        Pause() {
+            this._gameState.isPaused = true;
+        }
+        
+        Resume() {
+            this._gameState.isPaused = false;
+        }
+        
+        // Conditions
+        IsPaused() {
+            return this._gameState.isPaused;
+        }
+        
+        HasVariable(name) {
+            return this._gameState.variables.has(name);
+        }
+        
+        // Expressions
+        GetVariable(name) {
+            return this._gameState.variables.get(name) ?? '';
+        }
+    };
+}
+`;
+        this.addTextFile('c3runtime/instance.js', runtimeInstance);
+        // Runtime type
+        const runtimeType = `"use strict";
+
+{
+    const C3 = self.C3;
+
+    C3.Behaviors.Nice2Dev_${addonId}.Type = class Nice2Dev_${addonId}Type extends C3.SDKBehaviorTypeBase {
+        constructor(behaviorType) {
+            super(behaviorType);
+        }
+        
+        Release() {
+            super.Release();
+        }
+        
+        OnCreate() {
+        }
+    };
+}
+`;
+        this.addTextFile('c3runtime/type.js', runtimeType);
+    }
+    /* ── README ─────────────────────────────────────────────────── */
+    async generateReadme(project, options) {
+        const readme = `# ${project.name} - Construct 3 Export
+
+Generated from Nice2Dev project v${project.version}
+
+## Installation
+
+1. Create a new Construct 3 project or open existing
+2. Import the .c3p file (if zipped) or copy project structure
+3. Enable any required plugins in Project Properties
+
+## Project Structure
+
+- \`project.c3proj\` - Main project file
+- \`objectTypes/\` - Object type definitions
+- \`layouts/\` - Layout/scene files
+- \`eventSheets/\` - Event sheet files
+- \`scripts/\` - JavaScript modules
+
+## Scenes
+
+${project.scenes.map((s) => `- ${s.name} (${s.entities.length} entities)`).join('\n')}
+
+## Object Types
+
+${this.collectObjectTypes(project)
+            .map((t) => `- ${t}`)
+            .join('\n')}
+
+## JavaScript API
+
+Import from \`main.js\`:
+
+\`\`\`javascript
+import { GameSettings, Variables, pauseGame, resumeGame } from './main.js';
+
+// Get/Set variables
+Variables.set('score', 100);
+const score = Variables.get('score', 0);
+
+// Pause control
+pauseGame();
+resumeGame();
+\`\`\`
+
+## Notes
+
+- Textures need to be imported manually into Construct 3
+- Audio files need to be imported and linked
+- Physics settings may need adjustment
+
+## Settings
+
+- Resolution: ${project.settings.resolution.width}x${project.settings.resolution.height}
+- Physics: ${project.settings.physics.enabled ? 'Enabled' : 'Disabled'}
+- Gravity: (${project.settings.physics.gravity.x}, ${project.settings.physics.gravity.y})
+`;
+        this.addTextFile('README.md', readme);
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createConstruct3Exporter() {
+    return new Construct3Exporter();
+}
+
+exports.Construct3Exporter = Construct3Exporter;
+exports.createConstruct3Exporter = createConstruct3Exporter;
+//# sourceMappingURL=Construct3Exporter.js.map