@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/cjs/export/DefoldExporter.js

@@ -0,0 +1,1106 @@
+'use strict';
+
+var PlatformExporter = require('./PlatformExporter.js');
+
+/* ────────────────────────────────────────────────────────────────
+   Defold Exporter — Defold Game Engine Export
+   
+   Exports Nice2Dev projects to Defold format:
+   - Project file (game.project)
+   - Collection files (.collection)
+   - Game object files (.go)
+   - Lua scripts
+   - GUI files
+   - Atlas definitions
+──────────────────────────────────────────────────────────────── */
+/* ── Defold Component Mappings ────────────────────────────────── */
+const DEFOLD_COMPONENT_MAP = {
+    sprite: (comp, entity) => {
+        comp.properties?.['texture'] ?? 'main';
+        return `components {
+  id: "sprite"
+  component: "/main/sprites/${(entity.name ?? entity.id).toLowerCase()}.sprite"
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+}`;
+    },
+    rigidbody: (comp, entity) => {
+        comp.properties?.['mass'] ?? 1;
+        comp.properties?.['linearDamping'] ?? 0;
+        comp.properties?.['angularDamping'] ?? 0;
+        return `components {
+  id: "collisionobject"
+  component: "/main/collision/${(entity.name ?? entity.id).toLowerCase()}.collisionobject"
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+}`;
+    },
+    script: (comp, entity) => {
+        return `components {
+  id: "script"
+  component: "/main/scripts/${(entity.name ?? entity.id).toLowerCase()}.script"
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+}`;
+    },
+};
+/* ── Exporter Implementation ──────────────────────────────────── */
+class DefoldExporter extends PlatformExporter.PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'defold';
+        this.platformInfo = {
+            id: 'defold',
+            name: 'Defold',
+            description: 'Defold - Cross-platform game engine by King',
+            website: 'https://defold.com/',
+            features: [
+                '2d-rendering',
+                '3d-rendering',
+                'physics-2d',
+                'physics-3d',
+                'audio',
+                'particles',
+                'ui-system',
+                'animation',
+            ],
+            supportedAssets: [
+                'texture',
+                'audio',
+                'tilemap',
+                'animation',
+                'prefab',
+                'scene',
+                'data',
+                'script',
+            ],
+            exportFormats: ['.project', '.collection', '.go', '.script', '.gui'],
+        };
+    }
+    async doExport(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        // Generate main project file
+        await this.generateProjectFile(project, options);
+        // Generate main collection (bootstrap)
+        await this.generateMainCollection(project, options);
+        // Generate scenes as collections
+        for (const scene of project.scenes) {
+            await this.exportScene(scene, project, options);
+        }
+        // Generate prefabs as game objects
+        for (const prefab of project.prefabs) {
+            await this.exportPrefab(prefab, options);
+        }
+        // Generate shared scripts
+        await this.generateSharedScripts(project, options);
+        // Generate app manifest for HTML5
+        if (platformOpts.html5Manifest !== false) {
+            await this.generateAppManifest(project, options);
+        }
+        // Generate README
+        await this.generateReadme(project, options);
+    }
+    /* ── Project File ───────────────────────────────────────────── */
+    async generateProjectFile(project, options) {
+        const safeName = (options.projectName ?? project.name)
+            .toLowerCase()
+            .replace(/[^a-z0-9_]/g, '_');
+        const platformOpts = options.platformOptions ?? {};
+        const projectContent = `[project]
+title = ${project.name}
+version = ${project.version}
+write_log = 0
+compress_archive = 1
+publisher = Nice2Dev
+developer = Nice2Dev
+
+[display]
+width = ${project.settings.resolution.width}
+height = ${project.settings.resolution.height}
+high_dpi = 1
+samples = 0
+fullscreen = 0
+update_frequency = 0
+swap_interval = 1
+vsync = 1
+display_profiles = /builtins/render/default.display_profilesc
+dynamic_orientation = 0
+
+[render]
+clear_color_red = 0
+clear_color_green = 0
+clear_color_blue = 0
+clear_color_alpha = 0
+
+[physics]
+type = ${platformOpts.usePhysics3D ? '3D' : '2D'}
+max_collision_object_count = 128
+use_fixed_timestep = 0
+gravity_y = ${project.settings.physics.gravity.y}
+gravity_x = ${project.settings.physics.gravity.x}
+gravity_z = 0
+debug = 0
+debug_alpha = 0.9
+world_count = 4
+scale = 0.02
+
+[bootstrap]
+main_collection = /main/main.collectionc
+render = /builtins/render/default.renderc
+
+[graphics]
+default_texture_min_filter = linear
+default_texture_mag_filter = linear
+max_draw_calls = 1024
+max_characters = 8192
+max_font_batches = 4
+max_debug_vertices = 10000
+texture_profiles = /builtins/graphics/default.texture_profiles
+
+[shader]
+output_spirv = 0
+
+[sound]
+gain = ${project.settings.audio.masterVolume}
+max_sound_data = 128
+max_sound_buffers = 32
+max_sound_sources = 16
+max_sound_instances = 256
+max_component_count = 32
+use_thread = 1
+
+[resource]
+http_cache = 0
+max_resources = 1024
+
+[input]
+repeat_delay = 0.5
+repeat_interval = 0.2
+gamepads = /builtins/input/default.gamepadsc
+game_binding = /input/game.input_bindingc
+use_accelerometer = 1
+
+[sprite]
+max_count = 128
+subpixels = 1
+
+[model]
+max_count = 128
+
+[mesh]
+max_count = 128
+
+[gui]
+max_count = 64
+max_particlefx_count = 64
+max_particle_count = 1024
+
+[collection]
+max_instances = 1024
+max_input_stack_entries = 16
+
+[collection_proxy]
+max_count = 8
+
+[collectionfactory]
+max_count = 128
+
+[factory]
+max_count = 128
+
+[ios]
+launch_screen = /builtins/manifests/ios/LaunchScreen.storyboardc
+infoplist = /builtins/manifests/ios/Info.plist
+default_language = en
+localizations = en
+
+[android]
+version_code = 1
+minimum_sdk_version = 19
+target_sdk_version = 33
+package = com.nice2dev.${safeName}
+manifest = /builtins/manifests/android/AndroidManifest.xml
+iap_provider = GooglePlay
+input_method = HiddenInputField
+immersive_mode = 0
+display_cutout = 1
+debuggable = 0
+
+[osx]
+infoplist = /builtins/manifests/osx/Info.plist
+bundle_identifier = com.nice2dev.${safeName}
+default_language = en
+localizations = en
+
+[windows]
+icon = /builtins/manifests/windows/game.ico
+
+[html5]
+custom_heap_size = 0
+heap_size = 256
+htmlfile = /builtins/manifests/web/engine_template.html
+cssfile = /builtins/manifests/web/light_theme.css
+splash_image = /builtins/manifests/web/splash.png
+archive_location_prefix = archive
+archive_location_suffix = 
+engine_arguments = --verify-graphics-calls=false
+wasm_streaming = 0
+show_fullscreen_button = 1
+show_made_with_defold = 1
+show_console_banner = 1
+scale_mode = fit
+power_preference = default
+
+[particle_fx]
+max_count = 64
+max_emitter_count = 64
+max_particle_count = 1024
+
+[iap]
+auto_finish_transactions = 1
+
+[network]
+http_timeout = 0
+ssl_certificates = /builtins/network/ssl_certificates.pem
+http_thread_count = 4
+
+[library]
+include_dirs = 
+
+[script]
+shared_state = 0
+
+[label]
+max_count = 64
+subpixels = 1
+
+[profiler]
+track_cpu = 0
+sleep_between_server_updates = 0
+
+[liveupdate]
+settings = /liveupdate.settings
+enabled = 1
+
+[tilemap]
+max_count = 16
+max_tile_count = 2048
+
+[engine]
+run_while_iconified = 0
+fixed_update_frequency = 60
+
+[native_extension]
+_plugins = 
+`;
+        this.addTextFile('game.project', projectContent);
+    }
+    /* ── Main Collection ────────────────────────────────────────── */
+    async generateMainCollection(project, options) {
+        const firstScene = project.scenes[0];
+        const sceneName = firstScene
+            ? firstScene.name.toLowerCase().replace(/[^a-z0-9_]/g, '_')
+            : 'level1';
+        const mainCollection = `name: "main"
+scale_along_z: 0
+embedded_instances {
+  id: "game_manager"
+  data: "components {\\n"
+  "  id: \\"game_manager\\"\\n"
+  "  component: \\"/main/scripts/game_manager.script\\"\\n"
+  "  position {\\n"
+  "    x: 0.0\\n"
+  "    y: 0.0\\n"
+  "    z: 0.0\\n"
+  "  }\\n"
+  "  rotation {\\n"
+  "    x: 0.0\\n"
+  "    y: 0.0\\n"
+  "    z: 0.0\\n"
+  "    w: 1.0\\n"
+  "  }\\n"
+  "}\\n"
+  ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}
+collection_instances {
+  id: "level"
+  collection: "/main/scenes/${sceneName}.collection"
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}
+`;
+        this.addTextFile('main/main.collection', mainCollection);
+    }
+    /* ── Scene Export ───────────────────────────────────────────── */
+    async exportScene(scene, project, options) {
+        const sceneName = scene.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        // Generate collection
+        let collectionContent = `name: "${sceneName}"
+scale_along_z: 0
+`;
+        // Add entities as embedded instances
+        for (const entity of scene.entities) {
+            collectionContent += this.entityToEmbeddedInstance(entity);
+        }
+        this.addTextFile(`main/scenes/${sceneName}.collection`, collectionContent);
+        // Generate game objects for each entity
+        for (const entity of scene.entities) {
+            await this.generateGameObject(entity, options);
+        }
+        // Generate scene script
+        const sceneScript = this.generateSceneScript(scene, project);
+        this.addTextFile(`main/scripts/${sceneName}_controller.script`, sceneScript);
+    }
+    entityToEmbeddedInstance(entity) {
+        const name = (entity.name ?? entity.id).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        const pos = entity.position ?? { x: 0, y: 0 };
+        const scale = entity.scale ?? { x: 1, y: 1 };
+        const rotation = entity.rotation ?? 0;
+        // Calculate quaternion from rotation angle
+        const radians = (rotation * Math.PI) / 180;
+        const qz = Math.sin(radians / 2);
+        const qw = Math.cos(radians / 2);
+        return `embedded_instances {
+  id: "${name}"
+  data: ""
+  position {
+    x: ${pos.x}
+    y: ${pos.y}
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: ${qz.toFixed(6)}
+    w: ${qw.toFixed(6)}
+  }
+  scale3 {
+    x: ${scale.x}
+    y: ${scale.y}
+    z: 1.0
+  }
+}
+`;
+    }
+    async generateGameObject(entity, options) {
+        const name = (entity.name ?? entity.id).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        let goContent = '';
+        // Add components
+        for (const comp of entity.components) {
+            const mapper = DEFOLD_COMPONENT_MAP[comp.type];
+            if (mapper) {
+                goContent += mapper(comp, entity) + '\n';
+            }
+        }
+        // Always add a script component
+        goContent += `components {
+  id: "script"
+  component: "/main/scripts/${name}.script"
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+}
+`;
+        this.addTextFile(`main/go/${name}.go`, goContent);
+        // Generate entity script
+        const entityScript = this.generateEntityScript(entity);
+        this.addTextFile(`main/scripts/${name}.script`, entityScript);
+        // Generate sprite definition if has sprite component
+        const hasSprite = entity.components.some((c) => c.type === 'sprite');
+        if (hasSprite) {
+            await this.generateSpriteDefinition(entity);
+        }
+        // Generate collision object if has physics
+        const hasPhysics = entity.components.some((c) => c.type === 'rigidbody' || c.type.includes('Collider'));
+        if (hasPhysics) {
+            await this.generateCollisionObject(entity);
+        }
+    }
+    generateEntityScript(entity) {
+        const name = entity.name ?? entity.id;
+        const tags = entity.tags ?? [];
+        return `-- ${name} Entity Script
+-- Generated from Nice2Dev
+
+-- Properties
+go.property("speed", ${this.getComponentProperty(entity, 'movement', 'speed', 200)})
+go.property("health", ${this.getComponentProperty(entity, 'health', 'max', 100)})
+go.property("max_health", ${this.getComponentProperty(entity, 'health', 'max', 100)})
+
+-- Tags: ${tags.join(', ') || 'none'}
+
+-- Initialize
+function init(self)
+    self.velocity = vmath.vector3(0, 0, 0)
+    self.is_alive = true
+    self.tags = {${tags.map((t) => `["${t}"] = true`).join(', ')}}
+    
+    -- Register with game manager
+    msg.post("/game_manager#game_manager", "register_entity", {
+        id = go.get_id(),
+        name = "${name}",
+        tags = self.tags,
+    })
+end
+
+-- Update (called every frame)
+function update(self, dt)
+    if not self.is_alive then return end
+    
+    -- Apply velocity
+    if vmath.length(self.velocity) > 0 then
+        local pos = go.get_position()
+        pos = pos + self.velocity * dt
+        go.set_position(pos)
+    end
+end
+
+-- Fixed update (physics)
+function fixed_update(self, dt)
+    -- Physics updates here
+end
+
+-- Handle messages
+function on_message(self, message_id, message, sender)
+    if message_id == hash("take_damage") then
+        self.health = self.health - (message.amount or 10)
+        if self.health <= 0 then
+            self:die()
+        end
+    elseif message_id == hash("heal") then
+        self.health = math.min(self.health + (message.amount or 10), self.max_health)
+    elseif message_id == hash("set_velocity") then
+        self.velocity = message.velocity or vmath.vector3(0, 0, 0)
+    elseif message_id == hash("destroy") then
+        self:die()
+    end
+end
+
+-- Handle input (if enabled)
+function on_input(self, action_id, action)
+    -- Input handling here
+    return false
+end
+
+-- Cleanup
+function final(self)
+    msg.post("/game_manager#game_manager", "unregister_entity", {
+        id = go.get_id(),
+    })
+end
+
+-- Custom methods
+function die(self)
+    self.is_alive = false
+    -- Play death animation/effect
+    -- Then delete
+    go.delete()
+end
+
+function has_tag(self, tag)
+    return self.tags[tag] == true
+end
+`;
+    }
+    getComponentProperty(entity, componentType, property, defaultValue) {
+        const comp = entity.components.find((c) => c.type === componentType);
+        if (comp && comp.properties && property in comp.properties) {
+            return comp.properties[property];
+        }
+        return defaultValue;
+    }
+    async generateSpriteDefinition(entity) {
+        const name = (entity.name ?? entity.id).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        const spriteContent = `tile_set: "/main/atlases/main.atlas"
+default_animation: "default"
+material: "/builtins/materials/sprite.material"
+blend_mode: BLEND_MODE_ALPHA
+`;
+        this.addTextFile(`main/sprites/${name}.sprite`, spriteContent);
+    }
+    async generateCollisionObject(entity) {
+        const name = (entity.name ?? entity.id).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        const hasRigidbody = entity.components.some((c) => c.type === 'rigidbody');
+        const scale = entity.scale ?? { x: 1, y: 1 };
+        const collisionContent = `collision_shape: ""
+type: ${hasRigidbody ? 'COLLISION_OBJECT_TYPE_DYNAMIC' : 'COLLISION_OBJECT_TYPE_STATIC'}
+mass: ${this.getComponentProperty(entity, 'rigidbody', 'mass', 1)}
+friction: 0.5
+restitution: 0.2
+group: "default"
+mask: "default"
+linear_damping: ${this.getComponentProperty(entity, 'rigidbody', 'linearDamping', 0)}
+angular_damping: ${this.getComponentProperty(entity, 'rigidbody', 'angularDamping', 0)}
+locked_rotation: false
+bullet: false
+embedded_collision_shape {
+  shapes {
+    shape_type: TYPE_BOX
+    position {
+      x: 0.0
+      y: 0.0
+      z: 0.0
+    }
+    rotation {
+      x: 0.0
+      y: 0.0
+      z: 0.0
+      w: 1.0
+    }
+    index: 0
+    count: 3
+  }
+  data: ${32 * scale.x}
+  data: ${32 * scale.y}
+  data: 0.0
+}
+`;
+        this.addTextFile(`main/collision/${name}.collisionobject`, collisionContent);
+    }
+    /* ── Prefab Export ──────────────────────────────────────────── */
+    async exportPrefab(prefab, options) {
+        // Prefabs in Defold are just regular game objects that can be spawned
+        await this.generateGameObject(prefab.entity, options);
+        // Generate factory for spawning
+        const name = prefab.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        const factoryContent = `prototype: "/main/go/${name}.go"
+load_dynamically: false
+`;
+        this.addTextFile(`main/factories/${name}.factory`, factoryContent);
+    }
+    /* ── Scene Script ───────────────────────────────────────────── */
+    generateSceneScript(scene, project) {
+        const sceneName = scene.name;
+        return `-- ${sceneName} Scene Controller
+-- Generated from Nice2Dev
+
+-- Properties
+go.property("music_volume", ${project.settings.audio.masterVolume})
+go.property("sfx_volume", 1.0)
+
+function init(self)
+    self.entities = {}
+    self.is_paused = false
+    
+    -- Acquire input focus
+    msg.post(".", "acquire_input_focus")
+    
+    print("[Scene] ${sceneName} initialized")
+end
+
+function update(self, dt)
+    if self.is_paused then return end
+    
+    -- Scene update logic
+end
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("pause") then
+        self.is_paused = true
+    elseif message_id == hash("resume") then
+        self.is_paused = false
+    elseif message_id == hash("entity_spawned") then
+        self.entities[message.id] = message
+    elseif message_id == hash("entity_destroyed") then
+        self.entities[message.id] = nil
+    end
+end
+
+function on_input(self, action_id, action)
+    if action_id == hash("pause") and action.pressed then
+        self.is_paused = not self.is_paused
+        msg.post("/game_manager#game_manager", self.is_paused and "pause" or "resume")
+    end
+    return false
+end
+
+function final(self)
+    msg.post(".", "release_input_focus")
+    print("[Scene] ${sceneName} finalized")
+end
+`;
+    }
+    /* ── Shared Scripts ─────────────────────────────────────────── */
+    async generateSharedScripts(project, options) {
+        // Game Manager Script
+        const gameManagerScript = `-- Game Manager
+-- Central game state and utility management
+-- Generated from Nice2Dev
+
+-- Settings from Nice2Dev project
+local SETTINGS = {
+    game_width = ${project.settings.resolution.width},
+    game_height = ${project.settings.resolution.height},
+    master_volume = ${project.settings.audio.masterVolume},
+    physics_enabled = ${project.settings.physics.enabled},
+    gravity_x = ${project.settings.physics.gravity.x},
+    gravity_y = ${project.settings.physics.gravity.y},
+}
+
+-- Game state
+local state = {
+    is_paused = false,
+    entities = {},
+    global_variables = {},
+    current_scene = nil,
+}
+
+function init(self)
+    self.state = state
+    self.settings = SETTINGS
+    
+    print("[GameManager] Initialized - ${project.name} v${project.version}")
+end
+
+function update(self, dt)
+    if self.state.is_paused then return end
+    
+    -- Global game update
+end
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("pause") then
+        self.state.is_paused = true
+        print("[GameManager] Game paused")
+    elseif message_id == hash("resume") then
+        self.state.is_paused = false
+        print("[GameManager] Game resumed")
+    elseif message_id == hash("register_entity") then
+        self.state.entities[message.id] = {
+            id = message.id,
+            name = message.name,
+            tags = message.tags,
+        }
+    elseif message_id == hash("unregister_entity") then
+        self.state.entities[message.id] = nil
+    elseif message_id == hash("set_variable") then
+        self.state.global_variables[message.key] = message.value
+    elseif message_id == hash("get_variable") then
+        msg.post(sender, "variable_value", {
+            key = message.key,
+            value = self.state.global_variables[message.key],
+        })
+    elseif message_id == hash("load_scene") then
+        self:load_scene(message.scene)
+    end
+end
+
+function load_scene(self, scene_name)
+    if self.state.current_scene then
+        -- Unload current scene
+        msg.post("#" .. self.state.current_scene, "unload")
+    end
+    
+    -- Load new scene
+    self.state.current_scene = scene_name
+    msg.post("#" .. scene_name, "load")
+    
+    print("[GameManager] Loaded scene: " .. scene_name)
+end
+
+-- Utility functions accessible via msg
+function get_entities_by_tag(self, tag)
+    local result = {}
+    for id, entity in pairs(self.state.entities) do
+        if entity.tags and entity.tags[tag] then
+            table.insert(result, entity)
+        end
+    end
+    return result
+end
+`;
+        this.addTextFile('main/scripts/game_manager.script', gameManagerScript);
+        // Input bindings
+        const inputBindings = `key_trigger {
+  input: KEY_SPACE
+  action: "jump"
+}
+key_trigger {
+  input: KEY_W
+  action: "up"
+}
+key_trigger {
+  input: KEY_S
+  action: "down"
+}
+key_trigger {
+  input: KEY_A
+  action: "left"
+}
+key_trigger {
+  input: KEY_D
+  action: "right"
+}
+key_trigger {
+  input: KEY_UP
+  action: "up"
+}
+key_trigger {
+  input: KEY_DOWN
+  action: "down"
+}
+key_trigger {
+  input: KEY_LEFT
+  action: "left"
+}
+key_trigger {
+  input: KEY_RIGHT
+  action: "right"
+}
+key_trigger {
+  input: KEY_ESC
+  action: "pause"
+}
+key_trigger {
+  input: KEY_P
+  action: "pause"
+}
+mouse_trigger {
+  input: MOUSE_BUTTON_LEFT
+  action: "click"
+}
+mouse_trigger {
+  input: MOUSE_BUTTON_RIGHT
+  action: "right_click"
+}
+touch_trigger {
+  input: TOUCH_MULTI
+  action: "touch"
+}
+`;
+        this.addTextFile('input/game.input_binding', inputBindings);
+        // Main atlas (placeholder)
+        const atlasContent = `images {
+  image: "/main/images/placeholder.png"
+}
+margin: 0
+extrude_borders: 2
+inner_padding: 0
+`;
+        this.addTextFile('main/atlases/main.atlas', atlasContent);
+        // Utility module
+        const utilityModule = `-- Nice2Dev Utility Module
+-- Common utility functions
+
+local M = {}
+
+-- Math utilities
+function M.lerp(a, b, t)
+    return a + (b - a) * math.max(0, math.min(1, t))
+end
+
+function M.lerp_vector(a, b, t)
+    t = math.max(0, math.min(1, t))
+    return vmath.vector3(
+        a.x + (b.x - a.x) * t,
+        a.y + (b.y - a.y) * t,
+        a.z + (b.z - a.z) * t
+    )
+end
+
+function M.distance(a, b)
+    return vmath.length(b - a)
+end
+
+function M.angle_between(a, b)
+    local diff = b - a
+    return math.atan2(diff.y, diff.x)
+end
+
+function M.random_range(min, max)
+    return min + math.random() * (max - min)
+end
+
+function M.random_int(min, max)
+    return math.random(min, max)
+end
+
+function M.clamp(value, min, max)
+    return math.max(min, math.min(max, value))
+end
+
+-- Timer utilities
+M.timers = {}
+
+function M.set_timeout(callback, delay)
+    local id = tostring(socket.gettime())
+    M.timers[id] = {
+        callback = callback,
+        remaining = delay,
+        repeat_interval = nil,
+    }
+    return id
+end
+
+function M.set_interval(callback, interval)
+    local id = tostring(socket.gettime())
+    M.timers[id] = {
+        callback = callback,
+        remaining = interval,
+        repeat_interval = interval,
+    }
+    return id
+end
+
+function M.clear_timer(id)
+    M.timers[id] = nil
+end
+
+function M.update_timers(dt)
+    for id, timer in pairs(M.timers) do
+        timer.remaining = timer.remaining - dt
+        if timer.remaining <= 0 then
+            timer.callback()
+            if timer.repeat_interval then
+                timer.remaining = timer.repeat_interval
+            else
+                M.timers[id] = nil
+            end
+        end
+    end
+end
+
+-- Spawn utilities
+function M.spawn(factory_url, position, properties)
+    local id = factory.create(factory_url, position, nil, properties)
+    return id
+end
+
+function M.spawn_at(factory_url, x, y, z, properties)
+    return M.spawn(factory_url, vmath.vector3(x, y, z or 0), properties)
+end
+
+return M
+`;
+        this.addTextFile('main/scripts/utility.lua', utilityModule);
+    }
+    /* ── App Manifest ───────────────────────────────────────────── */
+    async generateAppManifest(project, options) {
+        const manifest = `platforms:
+  x86_64-osx:
+    context:
+      excludeLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+  x86_64-linux:
+    context:
+      excludeLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+  js-web:
+    context:
+      excludeLibs: []
+      excludeJsLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+  wasm-web:
+    context:
+      excludeLibs: []
+      excludeJsLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+  x86-win32:
+    context:
+      excludeLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+  x86_64-win32:
+    context:
+      excludeLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+  armv7-android:
+    context:
+      excludeLibs: []
+      excludeJars: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+      jetifier: true
+  arm64-android:
+    context:
+      excludeLibs: []
+      excludeJars: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+      jetifier: true
+  armv7-ios:
+    context:
+      excludeLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+  arm64-ios:
+    context:
+      excludeLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+  x86_64-ios:
+    context:
+      excludeLibs: []
+      excludeSymbols: []
+      symbols: []
+      libs: []
+      linkFlags: []
+`;
+        this.addTextFile('app.manifest', manifest);
+    }
+    /* ── README ─────────────────────────────────────────────────── */
+    async generateReadme(project, options) {
+        const readme = `# ${project.name} - Defold Export
+
+Generated from Nice2Dev project v${project.version}
+
+## Installation
+
+1. Install Defold Editor from https://defold.com/
+2. Open Defold and create a new project from this folder
+3. Or copy contents to existing project
+
+## Project Structure
+
+- \`game.project\` - Main project configuration
+- \`main/main.collection\` - Bootstrap collection
+- \`main/scenes/\` - Scene collections
+- \`main/go/\` - Game object definitions
+- \`main/scripts/\` - Lua scripts
+- \`main/sprites/\` - Sprite definitions
+- \`main/collision/\` - Collision objects
+- \`main/factories/\` - Factory components (for spawning)
+- \`main/atlases/\` - Texture atlases
+- \`input/\` - Input bindings
+
+## Scenes
+
+${project.scenes.map((s) => `- ${s.name} (${s.entities.length} entities)`).join('\n')}
+
+## Key Scripts
+
+### game_manager.script
+Central game state management:
+- Pause/Resume handling
+- Entity registration
+- Global variables
+- Scene loading
+
+### utility.lua
+Common utility functions:
+- Math helpers (lerp, distance, clamp)
+- Timer system (setTimeout, setInterval)
+- Spawn utilities
+
+## Input Bindings
+
+- WASD / Arrow Keys: Movement
+- Space: Jump
+- P / Escape: Pause
+- Mouse: Click, Right-click
+- Touch: Multi-touch support
+
+## Notes
+
+- Add your textures to \`main/images/\` and update atlases
+- Configure physics in \`game.project\` [physics] section
+- Adjust collision groups as needed
+
+## 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})
+- Master Volume: ${project.settings.audio.masterVolume}
+`;
+        this.addTextFile('README.md', readme);
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createDefoldExporter() {
+    return new DefoldExporter();
+}
+
+exports.DefoldExporter = DefoldExporter;
+exports.createDefoldExporter = createDefoldExporter;
+//# sourceMappingURL=DefoldExporter.js.map