@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/esm/export/RPGMakerExporter.js

@@ -0,0 +1,903 @@
+import { PlatformExporter } from './PlatformExporter.js';
+
+/* ────────────────────────────────────────────────────────────────
+   RPG Maker Exporter — MV/MZ Plugin & Resource Export
+   
+   Exports Nice2Dev projects to RPG Maker MV/MZ format:
+   - Plugin files (.js)
+   - Map data (JSON)
+   - Event pages
+   - Character/Enemy data
+   - Tileset configurations
+──────────────────────────────────────────────────────────────── */
+/* ── RPG Maker Event Codes ────────────────────────────────────── */
+const EventCode = {
+    END: 0,
+    COMMENT: 108,
+    SCRIPT: 355,
+    SCRIPT_DATA: 655};
+/* ── Exporter Implementation ──────────────────────────────────── */
+class RPGMakerExporter extends PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'rpgmaker';
+        this.platformInfo = {
+            id: 'rpgmaker',
+            name: 'RPG Maker MV/MZ',
+            description: 'RPG Maker MV and MZ game engine with JavaScript plugins',
+            website: 'https://www.rpgmakerweb.com/',
+            features: ['2d-rendering', 'audio', 'particles', 'ui-system', 'animation', 'tilemaps'],
+            supportedAssets: ['texture', 'audio', 'tilemap', 'animation', 'prefab', 'scene', 'data'],
+            exportFormats: ['.js', '.json', '.png', '.ogg'],
+        };
+        this.version = 'MZ';
+        this.pluginPrefix = 'N2D';
+        this.tileSize = 48;
+    }
+    async doExport(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        this.version = platformOpts.version ?? 'MZ';
+        this.pluginPrefix = platformOpts.pluginPrefix ?? 'N2D';
+        this.tileSize = platformOpts.tileSize ?? 48;
+        // Generate main plugin
+        await this.generateMainPlugin(project, options);
+        // Generate utility plugin
+        await this.generateUtilityPlugin(project, options);
+        // Export scenes as maps
+        for (const scene of project.scenes) {
+            await this.exportScene(scene, project, options);
+        }
+        // Export prefabs as event templates/actors/enemies
+        for (const prefab of project.prefabs) {
+            await this.exportPrefab(prefab, options);
+        }
+        // Generate common events if requested
+        if (platformOpts.generateCommonEvents !== false) {
+            await this.generateCommonEvents(project, options);
+        }
+        // Generate data files
+        await this.generateDataFiles(project, options);
+    }
+    /* ── Main Plugin ────────────────────────────────────────────── */
+    async generateMainPlugin(project, options) {
+        const versionSpecific = this.version === 'MZ' ? this.getMZPluginHeader() : this.getMVPluginHeader();
+        const plugin = `/*:
+ * @target ${this.version}
+ * @plugindesc ${project.name} - Nice2Dev Game Integration
+ * @author Nice2Dev Generator
+ * @version ${project.version}
+ * @url https://nice2dev.com
+ *
+${versionSpecific}
+ *
+ * @help
+ * ============================================================================
+ * ${project.name}
+ * ============================================================================
+ * 
+ * This plugin was generated from Nice2Dev project.
+ * 
+ * Game 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})
+ * 
+ * Scenes: ${project.scenes.length}
+ * Prefabs: ${project.prefabs.length}
+ * Assets: ${project.assets?.length ?? 0}
+ * 
+ * ============================================================================
+ * Plugin Commands
+ * ============================================================================
+ * 
+ * N2D_LoadScene <sceneName>  - Load a Nice2Dev scene
+ * N2D_SpawnEntity <prefab> <x> <y>  - Spawn an entity from prefab
+ * N2D_SetVariable <name> <value>  - Set a game variable
+ * N2D_GetVariable <name>  - Get a game variable
+ * 
+ */
+
+(() => {
+    'use strict';
+    
+    const pluginName = '${this.pluginPrefix}_${project.name.replace(/[^a-zA-Z0-9]/g, '')}';
+    
+    //=========================================================================
+    // Game State
+    //=========================================================================
+    
+    const N2D = window.N2D = window.N2D || {};
+    
+    N2D.State = {
+        currentScene: null,
+        entities: new Map(),
+        globalVariables: new Map(),
+        isPaused: false,
+    };
+    
+    N2D.Settings = {
+        gameWidth: ${project.settings.resolution.width},
+        gameHeight: ${project.settings.resolution.height},
+        masterVolume: ${project.settings.audio.masterVolume},
+        physicsEnabled: ${project.settings.physics.enabled},
+        gravityX: ${project.settings.physics.gravity.x},
+        gravityY: ${project.settings.physics.gravity.y},
+    };
+    
+    //=========================================================================
+    // Entity System
+    //=========================================================================
+    
+    N2D.Entity = class {
+        constructor(id, name) {
+            this.id = id;
+            this.name = name;
+            this.position = { x: 0, y: 0 };
+            this.components = [];
+            this.tags = [];
+            this.active = true;
+        }
+        
+        addComponent(component) {
+            this.components.push(component);
+        }
+        
+        getComponent(type) {
+            return this.components.find(c => c.type === type);
+        }
+        
+        hasTag(tag) {
+            return this.tags.includes(tag);
+        }
+        
+        update(deltaTime) {
+            if (!this.active) return;
+            for (const component of this.components) {
+                if (component.update) {
+                    component.update(deltaTime);
+                }
+            }
+        }
+        
+        destroy() {
+            N2D.State.entities.delete(this.id);
+        }
+    };
+    
+    //=========================================================================
+    // Scene Management
+    //=========================================================================
+    
+    N2D.SceneManager = {
+        scenes: {},
+        
+        registerScene(name, sceneData) {
+            this.scenes[name] = sceneData;
+        },
+        
+        loadScene(name) {
+            const scene = this.scenes[name];
+            if (!scene) {
+                console.error(\`[N2D] Scene not found: \${name}\`);
+                return false;
+            }
+            
+            // Clear current entities
+            N2D.State.entities.clear();
+            N2D.State.currentScene = name;
+            
+            // Spawn scene entities
+            if (scene.entities) {
+                for (const entityDef of scene.entities) {
+                    this.spawnEntity(entityDef);
+                }
+            }
+            
+            console.log(\`[N2D] Loaded scene: \${name}\`);
+            return true;
+        },
+        
+        spawnEntity(definition) {
+            const entity = new N2D.Entity(definition.id, definition.name);
+            entity.position = { ...definition.position };
+            entity.tags = [...(definition.tags || [])];
+            
+            if (definition.components) {
+                for (const compDef of definition.components) {
+                    entity.addComponent({ ...compDef });
+                }
+            }
+            
+            N2D.State.entities.set(entity.id, entity);
+            return entity;
+        },
+    };
+    
+    //=========================================================================
+    // Variable System
+    //=========================================================================
+    
+    N2D.Variables = {
+        set(name, value) {
+            N2D.State.globalVariables.set(name, value);
+        },
+        
+        get(name, defaultValue = null) {
+            return N2D.State.globalVariables.has(name) 
+                ? N2D.State.globalVariables.get(name) 
+                : defaultValue;
+        },
+        
+        has(name) {
+            return N2D.State.globalVariables.has(name);
+        },
+        
+        remove(name) {
+            N2D.State.globalVariables.delete(name);
+        },
+        
+        clear() {
+            N2D.State.globalVariables.clear();
+        },
+    };
+    
+    //=========================================================================
+    // Update Loop Integration
+    //=========================================================================
+    
+    const _Scene_Map_update = Scene_Map.prototype.update;
+    Scene_Map.prototype.update = function() {
+        _Scene_Map_update.call(this);
+        
+        if (!N2D.State.isPaused) {
+            const deltaTime = 1 / 60; // Approximate 60 FPS
+            for (const entity of N2D.State.entities.values()) {
+                entity.update(deltaTime);
+            }
+        }
+    };
+    
+    //=========================================================================
+    // Plugin Commands
+    //=========================================================================
+    
+${this.version === 'MZ' ? this.getMZPluginCommands() : this.getMVPluginCommands()}
+    
+    //=========================================================================
+    // Initialization
+    //=========================================================================
+    
+    console.log(\`[${this.pluginPrefix}] ${project.name} plugin loaded (v${project.version})\`);
+    
+})();
+`;
+        this.addTextFile(`js/plugins/${this.pluginPrefix}_${project.name.replace(/[^a-zA-Z0-9]/g, '')}.js`, plugin);
+    }
+    getMZPluginHeader() {
+        return ` * @command loadScene
+ * @text Load Scene
+ * @desc Load a Nice2Dev scene by name
+ *
+ * @arg sceneName
+ * @text Scene Name
+ * @type string
+ * @desc Name of the scene to load
+ *
+ * @command spawnEntity
+ * @text Spawn Entity
+ * @desc Spawn an entity from a prefab
+ *
+ * @arg prefabName
+ * @text Prefab Name
+ * @type string
+ * @desc Name of the prefab to spawn
+ *
+ * @arg x
+ * @text X Position
+ * @type number
+ * @default 0
+ *
+ * @arg y
+ * @text Y Position
+ * @type number
+ * @default 0
+ *
+ * @command setVariable
+ * @text Set Variable
+ * @desc Set a Nice2Dev game variable
+ *
+ * @arg varName
+ * @text Variable Name
+ * @type string
+ *
+ * @arg value
+ * @text Value
+ * @type string`;
+    }
+    getMVPluginHeader() {
+        return ` * @param gameTitle
+ * @text Game Title
+ * @type string
+ * @default ${this.pluginPrefix} Game
+ *
+ * @param debugMode
+ * @text Debug Mode
+ * @type boolean
+ * @default false`;
+    }
+    getMZPluginCommands() {
+        return `    PluginManager.registerCommand(pluginName, 'loadScene', args => {
+        N2D.SceneManager.loadScene(args.sceneName);
+    });
+    
+    PluginManager.registerCommand(pluginName, 'spawnEntity', args => {
+        const prefab = N2D.Prefabs[args.prefabName];
+        if (prefab) {
+            const entity = N2D.SceneManager.spawnEntity({
+                id: \`\${args.prefabName}_\${Date.now()}\`,
+                name: args.prefabName,
+                position: { x: Number(args.x), y: Number(args.y) },
+                ...prefab,
+            });
+        }
+    });
+    
+    PluginManager.registerCommand(pluginName, 'setVariable', args => {
+        N2D.Variables.set(args.varName, args.value);
+    });`;
+    }
+    getMVPluginCommands() {
+        return `    const _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
+    Game_Interpreter.prototype.pluginCommand = function(command, args) {
+        _Game_Interpreter_pluginCommand.call(this, command, args);
+        
+        if (command === 'N2D_LoadScene') {
+            N2D.SceneManager.loadScene(args[0]);
+        }
+        else if (command === 'N2D_SpawnEntity') {
+            const prefab = N2D.Prefabs[args[0]];
+            if (prefab) {
+                N2D.SceneManager.spawnEntity({
+                    id: \`\${args[0]}_\${Date.now()}\`,
+                    name: args[0],
+                    position: { x: Number(args[1] || 0), y: Number(args[2] || 0) },
+                    ...prefab,
+                });
+            }
+        }
+        else if (command === 'N2D_SetVariable') {
+            N2D.Variables.set(args[0], args[1]);
+        }
+        else if (command === 'N2D_GetVariable') {
+            const value = N2D.Variables.get(args[0]);
+            if (args[1]) {
+                $gameVariables.setValue(Number(args[1]), value);
+            }
+        }
+    };`;
+    }
+    /* ── Utility Plugin ─────────────────────────────────────────── */
+    async generateUtilityPlugin(project, options) {
+        const utility = `/*:
+ * @target ${this.version}
+ * @plugindesc Nice2Dev Utility Functions
+ * @author Nice2Dev Generator
+ * @version 1.0.0
+ *
+ * @help
+ * Utility functions for Nice2Dev exported games.
+ */
+
+(() => {
+    'use strict';
+    
+    const N2D = window.N2D = window.N2D || {};
+    
+    //=========================================================================
+    // Math Utilities
+    //=========================================================================
+    
+    N2D.Math = {
+        lerp(a, b, t) {
+            return a + (b - a) * Math.max(0, Math.min(1, t));
+        },
+        
+        clamp(value, min, max) {
+            return Math.max(min, Math.min(max, value));
+        },
+        
+        distance(x1, y1, x2, y2) {
+            const dx = x2 - x1;
+            const dy = y2 - y1;
+            return Math.sqrt(dx * dx + dy * dy);
+        },
+        
+        angle(x1, y1, x2, y2) {
+            return Math.atan2(y2 - y1, x2 - x1);
+        },
+        
+        randomRange(min, max) {
+            return Math.random() * (max - min) + min;
+        },
+        
+        randomInt(min, max) {
+            return Math.floor(Math.random() * (max - min + 1)) + min;
+        },
+        
+        degToRad(degrees) {
+            return degrees * (Math.PI / 180);
+        },
+        
+        radToDeg(radians) {
+            return radians * (180 / Math.PI);
+        },
+    };
+    
+    //=========================================================================
+    // Timer Utilities
+    //=========================================================================
+    
+    N2D.Timer = {
+        _timers: [],
+        _nextId: 1,
+        
+        setTimeout(callback, frames) {
+            const id = this._nextId++;
+            this._timers.push({
+                id,
+                callback,
+                frames,
+                remaining: frames,
+                repeat: false,
+            });
+            return id;
+        },
+        
+        setInterval(callback, frames) {
+            const id = this._nextId++;
+            this._timers.push({
+                id,
+                callback,
+                frames,
+                remaining: frames,
+                repeat: true,
+            });
+            return id;
+        },
+        
+        clear(id) {
+            const index = this._timers.findIndex(t => t.id === id);
+            if (index !== -1) {
+                this._timers.splice(index, 1);
+            }
+        },
+        
+        update() {
+            for (let i = this._timers.length - 1; i >= 0; i--) {
+                const timer = this._timers[i];
+                timer.remaining--;
+                
+                if (timer.remaining <= 0) {
+                    timer.callback();
+                    
+                    if (timer.repeat) {
+                        timer.remaining = timer.frames;
+                    } else {
+                        this._timers.splice(i, 1);
+                    }
+                }
+            }
+        },
+    };
+    
+    // Update timers in scene
+    const _Scene_Base_update = Scene_Base.prototype.update;
+    Scene_Base.prototype.update = function() {
+        _Scene_Base_update.call(this);
+        N2D.Timer.update();
+    };
+    
+    //=========================================================================
+    // Tween System
+    //=========================================================================
+    
+    N2D.Tween = {
+        _tweens: [],
+        
+        create(target, properties, duration, easing = 'linear') {
+            const tween = {
+                target,
+                properties: {},
+                duration,
+                elapsed: 0,
+                easing: this.easings[easing] || this.easings.linear,
+            };
+            
+            for (const [key, endValue] of Object.entries(properties)) {
+                tween.properties[key] = {
+                    start: target[key],
+                    end: endValue,
+                };
+            }
+            
+            this._tweens.push(tween);
+            return tween;
+        },
+        
+        update() {
+            for (let i = this._tweens.length - 1; i >= 0; i--) {
+                const tween = this._tweens[i];
+                tween.elapsed++;
+                
+                const t = Math.min(tween.elapsed / tween.duration, 1);
+                const easedT = tween.easing(t);
+                
+                for (const [key, values] of Object.entries(tween.properties)) {
+                    tween.target[key] = N2D.Math.lerp(values.start, values.end, easedT);
+                }
+                
+                if (t >= 1) {
+                    this._tweens.splice(i, 1);
+                    if (tween.onComplete) {
+                        tween.onComplete();
+                    }
+                }
+            }
+        },
+        
+        easings: {
+            linear: t => t,
+            easeIn: t => t * t,
+            easeOut: t => t * (2 - t),
+            easeInOut: t => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+            easeInCubic: t => t * t * t,
+            easeOutCubic: t => (--t) * t * t + 1,
+            easeInOutCubic: t => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+            bounce: t => {
+                const n1 = 7.5625;
+                const d1 = 2.75;
+                if (t < 1 / d1) return n1 * t * t;
+                if (t < 2 / d1) return n1 * (t -= 1.5 / d1) * t + 0.75;
+                if (t < 2.5 / d1) return n1 * (t -= 2.25 / d1) * t + 0.9375;
+                return n1 * (t -= 2.625 / d1) * t + 0.984375;
+            },
+        },
+    };
+    
+    // Update tweens in scene
+    const _Scene_Base_update2 = Scene_Base.prototype.update;
+    Scene_Base.prototype.update = function() {
+        _Scene_Base_update2.call(this);
+        N2D.Tween.update();
+    };
+    
+    //=========================================================================
+    // Array Utilities
+    //=========================================================================
+    
+    N2D.Array = {
+        shuffle(array) {
+            const result = [...array];
+            for (let i = result.length - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [result[i], result[j]] = [result[j], result[i]];
+            }
+            return result;
+        },
+        
+        pick(array) {
+            return array[Math.floor(Math.random() * array.length)];
+        },
+        
+        remove(array, item) {
+            const index = array.indexOf(item);
+            if (index !== -1) {
+                array.splice(index, 1);
+            }
+            return array;
+        },
+    };
+    
+    console.log('[N2D] Utility plugin loaded');
+    
+})();
+`;
+        this.addTextFile(`js/plugins/${this.pluginPrefix}_Utility.js`, utility);
+    }
+    /* ── Scene Export ───────────────────────────────────────────── */
+    async exportScene(scene, project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        const mapWidth = platformOpts.defaultMapWidth ?? 20;
+        const mapHeight = platformOpts.defaultMapHeight ?? 15;
+        // Create map data
+        const map = {
+            autoplayBgm: false,
+            autoplayBgs: false,
+            battleback1Name: '',
+            battleback2Name: '',
+            bgm: { name: '', pan: 0, pitch: 100, volume: 90 },
+            bgs: { name: '', pan: 0, pitch: 100, volume: 90 },
+            disableDashing: false,
+            displayName: scene.name,
+            encounterList: [],
+            encounterStep: 30,
+            height: mapHeight,
+            note: `<N2D_Scene:${scene.name}>`,
+            parallaxLoopX: false,
+            parallaxLoopY: false,
+            parallaxName: '',
+            parallaxShow: true,
+            parallaxSx: 0,
+            parallaxSy: 0,
+            scrollType: 0,
+            specifyBattleback: false,
+            tilesetId: 1,
+            width: mapWidth,
+            data: new Array(mapWidth * mapHeight * 6).fill(0),
+            events: [null], // First element is always null
+        };
+        // Convert entities to events
+        for (const entity of scene.entities) {
+            const event = this.entityToEvent(entity, map.events.length);
+            if (event) {
+                map.events.push(event);
+            }
+        }
+        // Generate scene registration script
+        const sceneScript = `// Scene: ${scene.name}
+// Generated from Nice2Dev
+
+(() => {
+    const N2D = window.N2D;
+    if (!N2D) return;
+    
+    N2D.SceneManager.registerScene('${scene.name}', {
+        name: '${scene.name}',
+        entities: [
+${scene.entities
+            .map((e) => `            {
+                id: '${e.id}',
+                name: '${e.name ?? e.id}',
+                position: { x: ${e.position?.x ?? 0}, y: ${e.position?.y ?? 0} },
+                tags: [${(e.tags ?? []).map((t) => `'${t}'`).join(', ')}],
+                components: [${e.components.map((c) => `{ type: '${c.type}', properties: ${JSON.stringify(c.properties ?? {})} }`).join(', ')}],
+            }`)
+            .join(',\n')}
+        ],
+    });
+    
+    console.log('[N2D] Scene registered: ${scene.name}');
+})();
+`;
+        this.addTextFile(`js/plugins/${this.pluginPrefix}_Scene_${scene.name.replace(/[^a-zA-Z0-9]/g, '')}.js`, sceneScript);
+        // Map file would need map ID - using scene name hash
+        const mapId = (Math.abs(this.hashCode(scene.name)) % 999) + 1;
+        const mapIdStr = mapId.toString().padStart(3, '0');
+        this.addTextFile(`data/Map${mapIdStr}.json`, JSON.stringify(map, null, 2));
+    }
+    entityToEvent(entity, eventId) {
+        const pos = entity.position ?? { x: 0, y: 0 };
+        const tileX = Math.floor(pos.x / this.tileSize);
+        const tileY = Math.floor(pos.y / this.tileSize);
+        const event = {
+            id: eventId,
+            name: entity.name ?? entity.id,
+            note: `<N2D_Entity:${entity.id}>`,
+            pages: [
+                {
+                    conditions: {
+                        actorId: 1,
+                        actorValid: false,
+                        itemId: 1,
+                        itemValid: false,
+                        selfSwitchCh: 'A',
+                        selfSwitchValid: false,
+                        switch1Id: 1,
+                        switch1Valid: false,
+                        switch2Id: 1,
+                        switch2Valid: false,
+                        variableId: 1,
+                        variableValid: false,
+                        variableValue: 0,
+                    },
+                    directionFix: false,
+                    image: {
+                        characterIndex: 0,
+                        characterName: '',
+                        direction: 2,
+                        pattern: 0,
+                        tileId: 0,
+                    },
+                    list: this.generateEventCommands(entity),
+                    moveFrequency: 3,
+                    moveRoute: { list: [{ code: 0 }], repeat: true, skippable: false, wait: false },
+                    moveSpeed: 3,
+                    moveType: 0,
+                    priorityType: 1,
+                    stepAnime: false,
+                    through: false,
+                    trigger: 0, // Action button
+                    walkAnime: true,
+                },
+            ],
+            x: tileX,
+            y: tileY,
+        };
+        return event;
+    }
+    generateEventCommands(entity) {
+        const commands = [];
+        // Add a comment with entity info
+        commands.push({
+            code: EventCode.COMMENT,
+            indent: 0,
+            parameters: [`Nice2Dev Entity: ${entity.name ?? entity.id}`],
+        });
+        // Add script call for custom entity behavior
+        commands.push({
+            code: EventCode.SCRIPT,
+            indent: 0,
+            parameters: [`const entity = N2D.State.entities.get('${entity.id}');`],
+        });
+        commands.push({
+            code: EventCode.SCRIPT_DATA,
+            indent: 0,
+            parameters: [`if (entity) { /* Custom behavior */ }`],
+        });
+        // End
+        commands.push({ code: EventCode.END, indent: 0, parameters: [] });
+        return commands;
+    }
+    /* ── Prefab Export ──────────────────────────────────────────── */
+    async exportPrefab(prefab, options) {
+        const safeName = prefab.name.replace(/[^a-zA-Z0-9]/g, '');
+        // Generate prefab registration script
+        const prefabScript = `// Prefab: ${prefab.name}
+// Generated from Nice2Dev
+
+(() => {
+    const N2D = window.N2D;
+    if (!N2D) return;
+    
+    N2D.Prefabs = N2D.Prefabs || {};
+    
+    N2D.Prefabs['${prefab.name}'] = {
+        name: '${prefab.entity.name ?? prefab.name}',
+        components: [
+${prefab.entity.components.map((c) => `            { type: '${c.type}', properties: ${JSON.stringify(c.properties ?? {})} },`).join('\n')}
+        ],
+        tags: [${(prefab.entity.tags ?? []).map((t) => `'${t}'`).join(', ')}],
+    };
+    
+    console.log('[N2D] Prefab registered: ${prefab.name}');
+})();
+`;
+        this.addTextFile(`js/plugins/${this.pluginPrefix}_Prefab_${safeName}.js`, prefabScript);
+    }
+    /* ── Common Events ──────────────────────────────────────────── */
+    async generateCommonEvents(project, options) {
+        const commonEvents = [
+            null, // Index 0 is always null
+            {
+                id: 1,
+                name: 'N2D_GameInit',
+                switchId: 0,
+                trigger: 0,
+                list: [
+                    { code: EventCode.COMMENT, indent: 0, parameters: ['Nice2Dev Game Initialization'] },
+                    {
+                        code: EventCode.SCRIPT,
+                        indent: 0,
+                        parameters: ['console.log("[N2D] Game initialized");'],
+                    },
+                    { code: EventCode.END, indent: 0, parameters: [] },
+                ],
+            },
+            {
+                id: 2,
+                name: 'N2D_GameUpdate',
+                switchId: 0,
+                trigger: 0,
+                list: [
+                    { code: EventCode.COMMENT, indent: 0, parameters: ['Nice2Dev Game Update Loop'] },
+                    { code: EventCode.SCRIPT, indent: 0, parameters: ['// Called by parallel process'] },
+                    { code: EventCode.END, indent: 0, parameters: [] },
+                ],
+            },
+        ];
+        this.addTextFile('data/CommonEvents.json', JSON.stringify(commonEvents, null, 2));
+    }
+    /* ── Data Files ─────────────────────────────────────────────── */
+    async generateDataFiles(project, options) {
+        // System.json stub
+        ({
+            gameTitle: project.name});
+        this.addTextFile('data/System.json.stub.txt', `// System.json should be configured in RPG Maker editor\n// Game Title: ${project.name}`);
+        // Plugins.json for plugin loading order
+        const plugins = [
+            { name: `${this.pluginPrefix}_Utility`, status: true, parameters: {} },
+            {
+                name: `${this.pluginPrefix}_${project.name.replace(/[^a-zA-Z0-9]/g, '')}`,
+                status: true,
+                parameters: {},
+            },
+        ];
+        // Add scene plugins
+        for (const scene of project.scenes) {
+            plugins.push({
+                name: `${this.pluginPrefix}_Scene_${scene.name.replace(/[^a-zA-Z0-9]/g, '')}`,
+                status: true,
+                parameters: {},
+            });
+        }
+        // Add prefab plugins
+        for (const prefab of project.prefabs) {
+            plugins.push({
+                name: `${this.pluginPrefix}_Prefab_${prefab.name.replace(/[^a-zA-Z0-9]/g, '')}`,
+                status: true,
+                parameters: {},
+            });
+        }
+        this.addTextFile('js/plugins.js', `var $plugins = ${JSON.stringify(plugins, null, 2)};`);
+        // README
+        const readme = `# ${project.name} - RPG Maker ${this.version} Export
+
+Generated from Nice2Dev project v${project.version}
+
+## Installation
+
+1. Create a new RPG Maker ${this.version} project
+2. Copy the contents of \`js/plugins/\` to your project's \`js/plugins/\` folder
+3. Copy \`js/plugins.js\` (or merge with existing)
+4. Copy map files from \`data/\` to your project's \`data/\` folder
+5. Enable plugins in Plugin Manager
+
+## Plugin Order
+
+Ensure plugins are loaded in this order:
+${plugins.map((p, i) => `${i + 1}. ${p.name}`).join('\n')}
+
+## Usage
+
+Use plugin commands to control Nice2Dev features:
+
+### MZ Commands (Plugin Command)
+- **Load Scene**: Load a Nice2Dev scene by name
+- **Spawn Entity**: Spawn an entity from a prefab
+- **Set Variable**: Set a game variable
+
+### MV Commands (Script Call)
+\`\`\`
+N2D_LoadScene <sceneName>
+N2D_SpawnEntity <prefabName> <x> <y>
+N2D_SetVariable <name> <value>
+\`\`\`
+
+## Scenes
+
+${project.scenes.map((s) => `- ${s.name} (${s.entities.length} entities)`).join('\n')}
+
+## Prefabs
+
+${project.prefabs.map((p) => `- ${p.name}`).join('\n') || 'None'}
+`;
+        this.addTextFile('README.md', readme);
+    }
+    /* ── Helpers ────────────────────────────────────────────────── */
+    hashCode(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return hash;
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createRPGMakerExporter() {
+    return new RPGMakerExporter();
+}
+
+export { RPGMakerExporter, createRPGMakerExporter };
+//# sourceMappingURL=RPGMakerExporter.js.map