@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/esm/export/GameMakerExporter.js

@@ -0,0 +1,843 @@
+import { PlatformExporter } from './PlatformExporter.js';
+
+/* ────────────────────────────────────────────────────────────────
+   GameMaker Exporter — GameMaker Studio 2 Project Export
+   
+   Exports Nice2Dev projects to GameMaker Studio 2 format including:
+   - GML scripts (.gml)
+   - Object files (.yy)
+   - Room files (.yy)
+   - Sprite assets (.yy)
+   - Project file (.yyp)
+──────────────────────────────────────────────────────────────── */
+/* ── GameMaker UUID Generator ─────────────────────────────────── */
+function generateGMUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/* ── GameMaker Event Types ────────────────────────────────────── */
+const GM_EVENTS = {
+    CREATE: { type: 0, num: 0 },
+    STEP: { type: 3, num: 0 },
+    DRAW: { type: 8, num: 0 }};
+/* ── GameMaker Exporter Implementation ────────────────────────── */
+class GameMakerExporter extends PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'gamemaker';
+        this.platformInfo = {
+            id: 'gamemaker',
+            name: 'GameMaker Studio 2',
+            description: 'YoYo Games GameMaker Studio 2 with GML scripting',
+            website: 'https://gamemaker.io',
+            features: [
+                '2d-rendering',
+                'physics-2d',
+                'audio',
+                'networking',
+                'ui-system',
+                'tilemaps',
+                'particles',
+                'animation',
+            ],
+            supportedAssets: [
+                'sprite',
+                'tileset',
+                'audio',
+                'font',
+                'script',
+                'scene',
+                'prefab',
+                'particleSystem',
+                'data',
+            ],
+            exportFormats: ['.yyp', '.yy', '.gml'],
+        };
+        this.projectName = 'Nice2DevGame';
+        this.resourceTree = [];
+        this.objectScripts = new Map();
+    }
+    async doExport(project, options) {
+        this.projectName = (options.projectName ?? project.name).replace(/[^a-zA-Z0-9_]/g, '_');
+        this.resourceTree = [];
+        this.objectScripts.clear();
+        const platformOpts = options.platformOptions ?? {};
+        platformOpts.enablePhysics ?? project.settings.physics.enabled;
+        // Generate project file
+        await this.generateProjectFile(project, options);
+        // Generate scripts
+        await this.generateScripts(project, options);
+        // Generate objects from prefabs and unique entities
+        await this.generateObjects(project, options);
+        // Generate rooms from scenes
+        for (const scene of project.scenes) {
+            await this.generateRoom(scene, project, options);
+        }
+        // Generate sprite assets
+        for (const asset of project.assets) {
+            if (asset.type === 'sprite' || asset.type === 'texture') {
+                await this.generateSprite(asset, options);
+            }
+            else if (asset.type === 'audio') {
+                await this.generateSound(asset, options);
+            }
+        }
+    }
+    /* ── Project File ───────────────────────────────────────────── */
+    async generateProjectFile(project, options) {
+        const projectFile = {
+            resourceType: 'GMProject',
+            resourceVersion: '1.6',
+            name: this.projectName,
+            AudioGroups: [
+                {
+                    resourceType: 'GMAudioGroup',
+                    resourceVersion: '1.3',
+                    name: 'audiogroup_default',
+                    targets: -1,
+                },
+            ],
+            configs: {
+                children: [],
+                name: 'Default',
+            },
+            defaultScriptType: 1, // GML
+            Folders: this.generateFolderStructure(),
+            IncludedFiles: [],
+            isEcma: false,
+            LibaryEmitters: [],
+            MetaData: {
+                IDEVersion: '2024.2.0.132',
+            },
+            resources: this.resourceTree,
+            RoomOrderNodes: project.scenes.map((s) => ({
+                roomId: { name: `rm_${s.name}`, path: `rooms/rm_${s.name}/rm_${s.name}.yy` },
+            })),
+            templateType: null,
+            TextureGroups: [
+                {
+                    resourceType: 'GMTextureGroup',
+                    resourceVersion: '1.3',
+                    name: 'Default',
+                    autocrop: true,
+                    border: 2,
+                    compressFormat: 'bz2',
+                    directory: '',
+                    groupParent: null,
+                    isScaled: true,
+                    loadType: 'default',
+                    mipsToGenerate: 0,
+                    targets: -1,
+                },
+            ],
+        };
+        this.addTextFile(`${this.projectName}.yyp`, JSON.stringify(projectFile, null, 2));
+    }
+    generateFolderStructure() {
+        return [
+            this.createFolder('Sprites', 'sprites'),
+            this.createFolder('Sounds', 'sounds'),
+            this.createFolder('Scripts', 'scripts'),
+            this.createFolder('Objects', 'objects'),
+            this.createFolder('Rooms', 'rooms'),
+        ];
+    }
+    createFolder(name, folderPath) {
+        return {
+            resourceType: 'GMFolder',
+            resourceVersion: '1.0',
+            name,
+            folderPath: `folders/${name}.yy`,
+            order: 0,
+        };
+    }
+    /* ── Scripts ────────────────────────────────────────────────── */
+    async generateScripts(project, options) {
+        // Utility script
+        const utilScript = `/// @description Nice2Dev Utility Functions
+
+/// @function n2d_move_towards(target_x, target_y, speed)
+/// @param target_x
+/// @param target_y
+/// @param speed
+function n2d_move_towards(_target_x, _target_y, _speed) {
+    var _dir = point_direction(x, y, _target_x, _target_y);
+    var _dist = point_distance(x, y, _target_x, _target_y);
+    
+    if (_dist <= _speed) {
+        x = _target_x;
+        y = _target_y;
+    } else {
+        x += lengthdir_x(_speed, _dir);
+        y += lengthdir_y(_speed, _dir);
+    }
+}
+
+/// @function n2d_look_at(target_x, target_y)
+/// @param target_x
+/// @param target_y
+function n2d_look_at(_target_x, _target_y) {
+    image_angle = point_direction(x, y, _target_x, _target_y);
+}
+
+/// @function n2d_random_point_in_circle(center_x, center_y, radius)
+/// @param center_x
+/// @param center_y
+/// @param radius
+function n2d_random_point_in_circle(_cx, _cy, _radius) {
+    var _angle = random(360);
+    var _dist = sqrt(random(1)) * _radius;
+    return {
+        x: _cx + lengthdir_x(_dist, _angle),
+        y: _cy + lengthdir_y(_dist, _angle)
+    };
+}
+
+/// @function n2d_spawn_entity(object, x_, y_)
+/// @param object
+/// @param x_
+/// @param y_
+function n2d_spawn_entity(_object, _x, _y) {
+    return instance_create_layer(_x, _y, "Instances", _object);
+}
+
+/// @function n2d_find_by_tag(tag)
+/// @param tag
+function n2d_find_by_tag(_tag) {
+    var _result = [];
+    with (obj_nice2dev_base) {
+        if (variable_instance_exists(id, "tags")) {
+            for (var i = 0; i < array_length(tags); i++) {
+                if (tags[i] == _tag) {
+                    array_push(_result, id);
+                    break;
+                }
+            }
+        }
+    }
+    return _result;
+}
+`;
+        this.addTextFile('scripts/scr_nice2dev_utils/scr_nice2dev_utils.gml', utilScript);
+        this.addTextFile('scripts/scr_nice2dev_utils/scr_nice2dev_utils.yy', JSON.stringify({
+            resourceType: 'GMScript',
+            resourceVersion: '1.0',
+            name: 'scr_nice2dev_utils',
+            isCompatibility: false,
+            isDnD: false,
+            parent: { name: 'Scripts', path: 'folders/Scripts.yy' },
+        }, null, 2));
+        this.resourceTree.push({
+            id: { name: 'scr_nice2dev_utils', path: 'scripts/scr_nice2dev_utils/scr_nice2dev_utils.yy' },
+        });
+        // Game controller script
+        const gameScript = `/// @description Game Controller Functions
+
+globalvar game_paused;
+game_paused = false;
+
+/// @function game_pause()
+function game_pause() {
+    game_paused = true;
+    // Deactivate all instances except UI
+    instance_deactivate_all(true);
+    // Keep UI active
+    // instance_activate_object(obj_ui_controller);
+}
+
+/// @function game_resume()
+function game_resume() {
+    game_paused = false;
+    instance_activate_all();
+}
+
+/// @function game_goto_room(room_name)
+/// @param room_name
+function game_goto_room(_room_name) {
+    room_goto(asset_get_index(_room_name));
+}
+
+/// @function game_save(slot)
+/// @param slot
+function game_save(_slot) {
+    var _save_data = {
+        room: room_get_name(room),
+        // Add more save data as needed
+    };
+    
+    var _filename = "save_" + string(_slot) + ".json";
+    var _file = file_text_open_write(_filename);
+    file_text_write_string(_file, json_stringify(_save_data));
+    file_text_close(_file);
+}
+
+/// @function game_load(slot)
+/// @param slot
+function game_load(_slot) {
+    var _filename = "save_" + string(_slot) + ".json";
+    if (file_exists(_filename)) {
+        var _file = file_text_open_read(_filename);
+        var _json = file_text_read_string(_file);
+        file_text_close(_file);
+        
+        var _data = json_parse(_json);
+        room_goto(asset_get_index(_data.room));
+    }
+}
+`;
+        this.addTextFile('scripts/scr_game_controller/scr_game_controller.gml', gameScript);
+        this.addTextFile('scripts/scr_game_controller/scr_game_controller.yy', JSON.stringify({
+            resourceType: 'GMScript',
+            resourceVersion: '1.0',
+            name: 'scr_game_controller',
+            isCompatibility: false,
+            isDnD: false,
+            parent: { name: 'Scripts', path: 'folders/Scripts.yy' },
+        }, null, 2));
+        this.resourceTree.push({
+            id: {
+                name: 'scr_game_controller',
+                path: 'scripts/scr_game_controller/scr_game_controller.yy',
+            },
+        });
+    }
+    /* ── Objects ────────────────────────────────────────────────── */
+    async generateObjects(project, options) {
+        // Base object for Nice2Dev entities
+        await this.generateBaseObject();
+        // Generate objects from prefabs
+        for (const prefab of project.prefabs) {
+            await this.generateObjectFromEntity(prefab.entity, `obj_${prefab.name}`, options);
+        }
+        // Generate unique entity type objects
+        const entityTypes = new Set();
+        for (const scene of project.scenes) {
+            for (const entity of scene.entities) {
+                if (entity.type && !project.prefabs.find((p) => p.name === entity.type)) {
+                    entityTypes.add(entity.type);
+                }
+            }
+        }
+        for (const entityType of entityTypes) {
+            const templateEntity = this.findEntityByType(project, entityType);
+            if (templateEntity) {
+                await this.generateObjectFromEntity(templateEntity, `obj_${entityType}`, options);
+            }
+        }
+    }
+    findEntityByType(project, type) {
+        for (const scene of project.scenes) {
+            const found = scene.entities.find((e) => e.type === type);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    }
+    async generateBaseObject() {
+        const objectDef = {
+            resourceType: 'GMObject',
+            resourceVersion: '1.0',
+            name: 'obj_nice2dev_base',
+            solid: false,
+            visible: true,
+            managed: true,
+            persistent: false,
+            physicsObject: false,
+            physicsShape: 1,
+            eventList: [
+                {
+                    resourceType: 'GMEvent',
+                    resourceVersion: '1.0',
+                    isDnD: false,
+                    eventNum: GM_EVENTS.CREATE.num,
+                    eventType: GM_EVENTS.CREATE.type,
+                },
+            ],
+            properties: [
+                {
+                    resourceType: 'GMObjectProperty',
+                    resourceVersion: '1.0',
+                    name: 'entity_id',
+                    varType: 1, // String
+                    value: '""',
+                },
+                {
+                    resourceType: 'GMObjectProperty',
+                    resourceVersion: '1.0',
+                    name: 'tags',
+                    varType: 5, // Array
+                    value: '[]',
+                },
+            ],
+            overriddenProperties: [],
+            parent: { name: 'Objects', path: 'folders/Objects.yy' },
+        };
+        this.addTextFile('objects/obj_nice2dev_base/obj_nice2dev_base.yy', JSON.stringify(objectDef, null, 2));
+        // Create event
+        const createEvent = `/// @description Initialize base Nice2Dev entity
+entity_id = "";
+tags = [];
+
+// Override in child objects
+event_inherited();
+`;
+        this.addTextFile('objects/obj_nice2dev_base/Create_0.gml', createEvent);
+        this.resourceTree.push({
+            id: { name: 'obj_nice2dev_base', path: 'objects/obj_nice2dev_base/obj_nice2dev_base.yy' },
+        });
+    }
+    async generateObjectFromEntity(entity, objectName, options) {
+        const safeName = objectName.replace(/[^a-zA-Z0-9_]/g, '_');
+        const hasPhysics = entity.components.some((c) => c.type === 'rigidbody');
+        // Find sprite component
+        const spriteComp = entity.components.find((c) => c.type === 'sprite');
+        const spriteName = spriteComp?.properties?.['texture'];
+        const objectDef = {
+            resourceType: 'GMObject',
+            resourceVersion: '1.0',
+            name: safeName,
+            spriteId: spriteName
+                ? { name: `spr_${spriteName}`, path: `sprites/spr_${spriteName}/spr_${spriteName}.yy` }
+                : undefined,
+            solid: entity.components.some((c) => c.type === 'boxCollider' && !c.properties?.['isTrigger']),
+            visible: entity.active !== false,
+            managed: true,
+            persistent: false,
+            parentObjectId: {
+                name: 'obj_nice2dev_base',
+                path: 'objects/obj_nice2dev_base/obj_nice2dev_base.yy',
+            },
+            physicsObject: hasPhysics,
+            physicsShape: 1,
+            eventList: this.generateEventList(entity),
+            properties: this.extractEntityProperties(entity),
+            overriddenProperties: [],
+            parent: { name: 'Objects', path: 'folders/Objects.yy' },
+        };
+        this.addTextFile(`objects/${safeName}/${safeName}.yy`, JSON.stringify(objectDef, null, 2));
+        // Generate event scripts
+        await this.generateEventScripts(entity, safeName);
+        this.resourceTree.push({
+            id: { name: safeName, path: `objects/${safeName}/${safeName}.yy` },
+        });
+    }
+    generateEventList(entity) {
+        const events = [
+            {
+                resourceType: 'GMEvent',
+                resourceVersion: '1.0',
+                isDnD: false,
+                eventNum: GM_EVENTS.CREATE.num,
+                eventType: GM_EVENTS.CREATE.type,
+            },
+            {
+                resourceType: 'GMEvent',
+                resourceVersion: '1.0',
+                isDnD: false,
+                eventNum: GM_EVENTS.STEP.num,
+                eventType: GM_EVENTS.STEP.type,
+            },
+        ];
+        // Add draw event if sprite
+        if (entity.components.some((c) => c.type === 'sprite')) {
+            events.push({
+                resourceType: 'GMEvent',
+                resourceVersion: '1.0',
+                isDnD: false,
+                eventNum: GM_EVENTS.DRAW.num,
+                eventType: GM_EVENTS.DRAW.type,
+            });
+        }
+        return events;
+    }
+    extractEntityProperties(entity) {
+        const props = [];
+        // Add common properties
+        for (const comp of entity.components) {
+            if (comp.properties) {
+                for (const [key, value] of Object.entries(comp.properties)) {
+                    const varType = this.getGMLVarType(value);
+                    props.push({
+                        resourceType: 'GMObjectProperty',
+                        resourceVersion: '1.0',
+                        name: `${comp.type}_${key}`,
+                        varType,
+                        value: this.valueToGML(value),
+                    });
+                }
+            }
+        }
+        return props;
+    }
+    getGMLVarType(value) {
+        if (typeof value === 'number') {
+            return Number.isInteger(value) ? 0 : 2;
+        } // Int or Real
+        if (typeof value === 'string') {
+            return 1;
+        } // String
+        if (typeof value === 'boolean') {
+            return 3;
+        } // Bool
+        if (Array.isArray(value)) {
+            return 5;
+        } // Array
+        return 1; // Default to string
+    }
+    valueToGML(value) {
+        if (typeof value === 'string') {
+            return `"${value}"`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'true' : 'false';
+        }
+        if (Array.isArray(value)) {
+            return JSON.stringify(value);
+        }
+        if (typeof value === 'object' && value !== null) {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    }
+    async generateEventScripts(entity, objectName) {
+        // Create event
+        let createScript = `/// @description Initialize ${entity.name ?? objectName}
+event_inherited();
+
+entity_id = "${entity.id}";
+`;
+        // Add tag initialization
+        if (entity.tags && entity.tags.length > 0) {
+            createScript += `tags = ${JSON.stringify(entity.tags)};\n`;
+        }
+        // Add component-specific initialization
+        for (const comp of entity.components) {
+            createScript += this.generateComponentInit(comp);
+        }
+        this.addTextFile(`objects/${objectName}/Create_0.gml`, createScript);
+        // Step event
+        const stepScript = `/// @description Step event for ${entity.name ?? objectName}
+
+// Add update logic here
+`;
+        this.addTextFile(`objects/${objectName}/Step_0.gml`, stepScript);
+        // Draw event (if has sprite)
+        if (entity.components.some((c) => c.type === 'sprite')) {
+            const drawScript = `/// @description Draw event
+draw_self();
+`;
+            this.addTextFile(`objects/${objectName}/Draw_0.gml`, drawScript);
+        }
+    }
+    generateComponentInit(comp) {
+        let code = `\n// ${comp.type} component\n`;
+        switch (comp.type) {
+            case 'sprite':
+                const color = comp.properties?.['color'];
+                if (color) {
+                    code += `image_blend = ${this.colorToGML(color)};\n`;
+                }
+                break;
+            case 'rigidbody':
+                code += `phy_active = true;\n`;
+                if (comp.properties?.['mass']) {
+                    code += `phy_mass = ${comp.properties['mass']};\n`;
+                }
+                if (comp.properties?.['linearDamping']) {
+                    code += `phy_linear_damping = ${comp.properties['linearDamping']};\n`;
+                }
+                break;
+            case 'audioSource':
+                if (comp.properties?.['playOnAwake']) {
+                    const clip = comp.properties['clip'];
+                    if (clip) {
+                        code += `audio_play_sound(snd_${clip}, 1, ${comp.properties['loop'] ? 'true' : 'false'});\n`;
+                    }
+                }
+                break;
+        }
+        return code;
+    }
+    colorToGML(color) {
+        if (color.startsWith('#')) {
+            // Convert hex to GML color (BGR format)
+            const hex = color.replace('#', '');
+            const r = parseInt(hex.substr(0, 2), 16);
+            const g = parseInt(hex.substr(2, 2), 16);
+            const b = parseInt(hex.substr(4, 2), 16);
+            return `make_colour_rgb(${r}, ${g}, ${b})`;
+        }
+        return 'c_white';
+    }
+    /* ── Rooms ──────────────────────────────────────────────────── */
+    async generateRoom(scene, project, options) {
+        const roomName = `rm_${scene.name.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+        const width = project.settings.resolution.width;
+        const height = project.settings.resolution.height;
+        const platformOpts = options.platformOptions ?? {};
+        const instances = [];
+        const instanceOrder = [];
+        // Generate instances from entities
+        for (const entity of scene.entities) {
+            const objName = entity.prefabId
+                ? `obj_${entity.prefabId}`
+                : entity.type
+                    ? `obj_${entity.type}`
+                    : 'obj_nice2dev_base';
+            const instanceName = `inst_${generateGMUUID().substr(0, 8)}`;
+            const pos = entity.position ?? { x: 0, y: 0 };
+            instances.push({
+                resourceType: 'GMRoomInstance',
+                resourceVersion: '1.0',
+                name: instanceName,
+                properties: [],
+                isDnd: false,
+                objectId: { name: objName, path: `objects/${objName}/${objName}.yy` },
+                inheritCode: false,
+                hasCreationCode: false,
+                colour: 4294967295,
+                rotation: entity.rotation ?? 0,
+                scaleX: entity.scale?.x ?? 1,
+                scaleY: entity.scale?.y ?? 1,
+                x: pos.x,
+                y: pos.y,
+            });
+            instanceOrder.push({ name: instanceName, path: `rooms/${roomName}/${roomName}.yy` });
+        }
+        // Build layers
+        const layers = [
+            {
+                resourceType: 'GMRLayer',
+                resourceVersion: '1.0',
+                name: 'Instances',
+                visible: true,
+                depth: 0,
+                userdefinedDepth: false,
+                inheritLayerDepth: false,
+                inheritLayerSettings: false,
+                instances,
+            },
+            {
+                resourceType: 'GMRBackgroundLayer',
+                resourceVersion: '1.0',
+                name: 'Background',
+                visible: true,
+                depth: 100,
+                userdefinedDepth: false,
+                inheritLayerDepth: false,
+                inheritLayerSettings: false,
+            },
+        ];
+        // Add tile layers from tilemaps
+        if (scene.tilemaps) {
+            for (const tilemap of scene.tilemaps) {
+                layers.push(this.createTileLayer(tilemap, project));
+            }
+        }
+        const room = {
+            resourceType: 'GMRoom',
+            resourceVersion: '1.0',
+            name: roomName,
+            isDnd: false,
+            creationCodeFile: '',
+            inheritCode: false,
+            inheritCreationOrder: false,
+            inheritLayers: false,
+            instanceCreationOrder: instanceOrder,
+            layers,
+            parent: { name: 'Rooms', path: 'folders/Rooms.yy' },
+            roomSettings: {
+                inheritRoomSettings: false,
+                Width: width,
+                Height: height,
+                persistent: false,
+            },
+            viewSettings: {
+                inheritViewSettings: false,
+                enableViews: true,
+                clearViewBackground: true,
+                clearDisplayBuffer: true,
+            },
+            physicsSettings: {
+                inheritPhysicsSettings: false,
+                PhysicsWorld: platformOpts.enablePhysics ?? project.settings.physics.enabled,
+                PhysicsWorldGravityX: project.settings.physics.gravity.x,
+                PhysicsWorldGravityY: project.settings.physics.gravity.y,
+                PhysicsWorldPixToMetres: 0.1,
+            },
+        };
+        this.addTextFile(`rooms/${roomName}/${roomName}.yy`, JSON.stringify(room, null, 2));
+        this.resourceTree.push({
+            id: { name: roomName, path: `rooms/${roomName}/${roomName}.yy` },
+        });
+    }
+    createTileLayer(tilemap, project) {
+        return {
+            resourceType: 'GMRTileLayer',
+            resourceVersion: '1.1',
+            name: tilemap.name,
+            visible: true,
+            depth: 50,
+            userdefinedDepth: false,
+            inheritLayerDepth: false,
+            inheritLayerSettings: false,
+            tiles: {
+                SerialiseWidth: tilemap.width,
+                SerialiseHeight: tilemap.height,
+                TileSerialiseData: tilemap.layers[0]?.data ?? [],
+            },
+        };
+    }
+    /* ── Sprites ────────────────────────────────────────────────── */
+    async generateSprite(asset, options) {
+        const spriteName = `spr_${asset.name.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+        const platformOpts = options.platformOptions ?? {};
+        // Determine origin based on options
+        let originX = 0, originY = 0;
+        switch (platformOpts.spriteOrigin) {
+            case 'center':
+                originX = 0.5;
+                originY = 0.5;
+                break;
+            case 'bottom-center':
+                originX = 0.5;
+                originY = 1;
+                break;
+            default: // top-left
+                originX = 0;
+                originY = 0;
+        }
+        const spriteDef = {
+            resourceType: 'GMSprite',
+            resourceVersion: '1.0',
+            name: spriteName,
+            bboxMode: 0,
+            bbox_bottom: 31,
+            bbox_left: 0,
+            bbox_right: 31,
+            bbox_top: 0,
+            collisionKind: 1,
+            collisionTolerance: 0,
+            DynamicTexturePage: false,
+            edgeFiltering: false,
+            For3D: false,
+            frames: [
+                {
+                    resourceType: 'GMSpriteFrame',
+                    resourceVersion: '1.1',
+                    name: generateGMUUID(),
+                },
+            ],
+            gridX: 0,
+            gridY: 0,
+            height: 32,
+            HTile: false,
+            layers: [
+                {
+                    resourceType: 'GMImageLayer',
+                    resourceVersion: '1.0',
+                    name: generateGMUUID(),
+                    blendMode: 0,
+                    displayName: 'default',
+                    isLocked: false,
+                    opacity: 100,
+                    visible: true,
+                },
+            ],
+            nineSlice: null,
+            origin: platformOpts.spriteOrigin === 'center'
+                ? 4
+                : platformOpts.spriteOrigin === 'bottom-center'
+                    ? 7
+                    : 0,
+            parent: { name: 'Sprites', path: 'folders/Sprites.yy' },
+            preMultiplyAlpha: false,
+            sequence: {
+                resourceType: 'GMSequence',
+                resourceVersion: '1.4',
+                name: spriteName,
+                autoRecord: true,
+                backdropHeight: 768,
+                backdropImageOpacity: 0.5,
+                backdropImagePath: '',
+                backdropWidth: 1366,
+                backdropXOffset: 0.0,
+                backdropYOffset: 0.0,
+                events: {
+                    Keyframes: [],
+                    resourceType: 'KeyframeStore<MessageEventKeyframe>',
+                    resourceVersion: '1.0',
+                },
+                eventStubScript: null,
+                eventToFunction: {},
+                length: 1.0,
+                lockOrigin: false,
+                moments: {
+                    Keyframes: [],
+                    resourceType: 'KeyframeStore<MomentsEventKeyframe>',
+                    resourceVersion: '1.0',
+                },
+                playback: 1,
+                playbackSpeed: 15.0,
+                playbackSpeedType: 0,
+                showBackdrop: true,
+                showBackdropImage: false,
+                spriteId: { name: spriteName, path: `sprites/${spriteName}/${spriteName}.yy` },
+                timeUnits: 1,
+                tracks: [],
+                volume: 1.0,
+                xorigin: Math.floor(32 * originX),
+                yorigin: Math.floor(32 * originY),
+            },
+            swatchColours: null,
+            swfPrecision: 2.525,
+            textureGroupId: { name: 'Default', path: 'texturegroups/Default' },
+            type: 0,
+            VTile: false,
+            width: 32,
+        };
+        this.addTextFile(`sprites/${spriteName}/${spriteName}.yy`, JSON.stringify(spriteDef, null, 2));
+        // Add warning for actual image file
+        this.addWarning('SPRITE_MANUAL', `Sprite "${asset.name}" requires manual image import`, `Copy sprite image to sprites/${spriteName}/ folder`);
+        this.resourceTree.push({
+            id: { name: spriteName, path: `sprites/${spriteName}/${spriteName}.yy` },
+        });
+    }
+    /* ── Sounds ─────────────────────────────────────────────────── */
+    async generateSound(asset, options) {
+        const soundName = `snd_${asset.name.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+        const soundDef = {
+            resourceType: 'GMSound',
+            resourceVersion: '1.0',
+            name: soundName,
+            audioGroupId: { name: 'audiogroup_default', path: 'audiogroups/audiogroup_default' },
+            bitDepth: 1,
+            bitRate: 128,
+            compression: 0,
+            conversionMode: 0,
+            duration: 1.0,
+            parent: { name: 'Sounds', path: 'folders/Sounds.yy' },
+            preload: false,
+            sampleRate: 44100,
+            soundFile: `${soundName}.ogg`,
+            type: 0,
+            volume: 1.0,
+        };
+        this.addTextFile(`sounds/${soundName}/${soundName}.yy`, JSON.stringify(soundDef, null, 2));
+        this.addWarning('SOUND_MANUAL', `Sound "${asset.name}" requires manual audio import`, `Copy audio file to sounds/${soundName}/ folder as ${soundName}.ogg`);
+        this.resourceTree.push({
+            id: { name: soundName, path: `sounds/${soundName}/${soundName}.yy` },
+        });
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createGameMakerExporter() {
+    return new GameMakerExporter();
+}
+
+export { GameMakerExporter, createGameMakerExporter };
+//# sourceMappingURL=GameMakerExporter.js.map