@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/cjs/export/Solar2DExporter.js

@@ -0,0 +1,1283 @@
+'use strict';
+
+var PlatformExporter = require('./PlatformExporter.js');
+
+/* ────────────────────────────────────────────────────────────────
+   Solar2D (Corona SDK) Exporter
+   
+   Exports Nice2Dev projects to Solar2D format:
+   - Main project files (main.lua, config.lua, build.settings)
+   - Scene modules
+   - Lua scripts
+   - Asset management
+──────────────────────────────────────────────────────────────── */
+/* ── Exporter Implementation ──────────────────────────────────── */
+class Solar2DExporter extends PlatformExporter.PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'solar2d';
+        this.platformInfo = {
+            id: 'solar2d',
+            name: 'Solar2D',
+            description: 'Solar2D (formerly Corona SDK) - Cross-platform 2D game engine',
+            website: 'https://solar2d.com/',
+            features: ['2d-rendering', 'physics-2d', 'audio', 'particles', 'ui-system', 'animation'],
+            supportedAssets: [
+                'texture',
+                'audio',
+                'tilemap',
+                'animation',
+                'prefab',
+                'scene',
+                'data',
+                'font',
+            ],
+            exportFormats: ['.lua', '.json', '.settings'],
+        };
+    }
+    async doExport(project, options) {
+        options.platformOptions ?? {};
+        // Generate config.lua
+        await this.generateConfigLua(project, options);
+        // Generate build.settings
+        await this.generateBuildSettings(project, options);
+        // Generate main.lua
+        await this.generateMainLua(project, options);
+        // Generate utility modules
+        await this.generateUtilityModules(project, options);
+        // Generate scenes
+        for (const scene of project.scenes) {
+            await this.exportScene(scene, project, options);
+        }
+        // Generate prefabs
+        for (const prefab of project.prefabs) {
+            await this.exportPrefab(prefab, options);
+        }
+        // Generate README
+        await this.generateReadme(project, options);
+    }
+    /* ── Config Lua ─────────────────────────────────────────────── */
+    async generateConfigLua(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        const scale = platformOpts.scale ?? 'letterbox';
+        const configLua = `-- Project: ${project.name}
+-- Generated from Nice2Dev
+
+-- config.lua - Application configuration
+
+local aspectRatio = display.pixelHeight / display.pixelWidth
+
+application = {
+    content = {
+        width = ${scale === 'none' ? 'display.pixelWidth' : project.settings.resolution.width},
+        height = ${scale === 'none' ? 'display.pixelHeight' : project.settings.resolution.height},
+        scale = "${scale}",
+        fps = ${project.settings.targetFrameRate ?? 60},
+        
+        -- Dynamic content scaling
+        imageSuffix = {
+            ["@2x"] = 1.5,
+            ["@4x"] = 3.0,
+        },
+    },
+    
+    -- License configuration
+    license = {
+        google = {
+            key = "YOUR_GOOGLE_LICENSE_KEY",
+        },
+    },
+    
+    -- Shader precision (optional)
+    shader = {
+        precisionHint = "highp",
+    },
+}
+
+-- Letterbox scaling adjustments
+if application.content.scale == "letterbox" then
+    if aspectRatio > 1.5 then
+        -- Taller devices (iPad-like)
+        application.content.height = math.ceil(application.content.width * aspectRatio)
+    end
+end
+`;
+        this.addTextFile('config.lua', configLua);
+    }
+    /* ── Build Settings ─────────────────────────────────────────── */
+    async generateBuildSettings(project, options) {
+        const safeName = (options.projectName ?? project.name)
+            .toLowerCase()
+            .replace(/[^a-z0-9_]/g, '_');
+        const platformOpts = options.platformOptions ?? {};
+        const buildSettings = `-- Build settings for ${project.name}
+-- Generated from Nice2Dev
+
+settings = {
+    -- Application orientation(s)
+    orientation = {
+        default = "landscapeRight",
+        supported = { "landscapeLeft", "landscapeRight" },
+    },
+    
+    -- Exclude files from build
+    excludeFiles = {
+        all = { "*.psd", "*.txt", "*.md", "*.json" },
+        ios = { "Icon-*dpi.png", "*.ogg" },
+        android = { "Icon.png", "Icon-Small-*.png", "Icon*@2x.png", "*.aiff" },
+    },
+    
+    -- iOS settings
+    iphone = {
+        plist = {
+            UIStatusBarHidden = true,
+            UILaunchStoryboardName = "LaunchScreen",
+            UIApplicationExitsOnSuspend = false,
+            CFBundleDisplayName = "${project.name}",
+            CFBundleIdentifier = "com.nice2dev.${safeName}",
+            CFBundleName = "${project.name}",
+            CFBundleVersion = "${project.version}",
+            CFBundleShortVersionString = "${project.version}",
+            ITSAppUsesNonExemptEncryption = false,
+            NSAppTransportSecurity = {
+                NSAllowsArbitraryLoads = true,
+            },
+        },
+        xcassets = "Images.xcassets",
+        entitlements = {
+            ["com.apple.developer.game-center"] = true,
+        },
+    },
+    
+    -- Android settings
+    android = {
+        versionCode = "${project.version.replace(/\./g, '')}1",
+        usesPermissions = {
+            "android.permission.INTERNET",
+            "android.permission.WRITE_EXTERNAL_STORAGE",
+            "android.permission.VIBRATE",
+        },
+        supportsScreens = {
+            smallScreens = true,
+            normalScreens = true,
+            largeScreens = true,
+            xlargeScreens = true,
+        },
+        applicationChildElements = {
+            [[
+            <meta-data android:name="com.google.android.gms.version"
+                android:value="@integer/google_play_services_version" />
+            ]],
+        },
+        usesFeatures = {},
+    },
+    
+    -- Windows settings
+    win32 = {
+        singleInstance = true,
+        preferenceStorage = "registry",
+    },
+    
+    -- macOS settings
+    osx = {
+        bundleIdentifier = "com.nice2dev.${safeName}",
+        retinaSupport = true,
+    },
+    
+    -- HTML5 settings
+    html5 = {
+        fps = ${project.settings.targetFrameRate ?? 60},
+        width = ${project.settings.resolution.width},
+        height = ${project.settings.resolution.height},
+        preferWebGL = true,
+    },
+    
+    -- Plugins
+    plugins = {
+${platformOpts.pluginStubs
+            ? `        ["plugin.Bytedance"] = { publisherId = "social.nicetodrive" },
+        ["plugin.ads.mediator"] = { publisherId = "com.coronalabs" },`
+            : ''}
+    },
+    
+    -- Splash screen
+    splashScreen = {
+        enable = true,
+        image = "splash.png",
+    },
+}
+`;
+        this.addTextFile('build.settings', buildSettings);
+    }
+    /* ── Main Lua ───────────────────────────────────────────────── */
+    async generateMainLua(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        const usePhysics = platformOpts.usePhysics !== false;
+        platformOpts.useComposer !== false;
+        const firstScene = project.scenes[0];
+        const firstSceneName = firstScene
+            ? firstScene.name.toLowerCase().replace(/[^a-z0-9_]/g, '_')
+            : 'main_scene';
+        const mainLua = `-- ${project.name}
+-- Main entry point
+-- Generated from Nice2Dev
+
+---------------------------------------------------------------------------------
+-- Modules
+---------------------------------------------------------------------------------
+local composer = require("composer")
+local physics = require("physics")
+
+-- Game modules
+local GameManager = require("modules.game_manager")
+local Utils = require("modules.utils")
+local Events = require("modules.events")
+
+---------------------------------------------------------------------------------
+-- Configuration
+---------------------------------------------------------------------------------
+display.setStatusBar(display.HiddenStatusBar)
+display.setDefault("background", 0, 0, 0)
+
+-- Multitouch
+system.activate("multitouch")
+
+-- Random seed
+math.randomseed(os.time())
+
+---------------------------------------------------------------------------------
+-- Physics Setup
+---------------------------------------------------------------------------------
+${usePhysics
+            ? `physics.start()
+physics.setGravity(${project.settings.physics.gravity.x}, ${project.settings.physics.gravity.y * -1})
+physics.setDrawMode("normal") -- debug: "hybrid" or "debug"
+physics.setScale(${project.settings.physics.scale ?? 30})`
+            : '-- Physics disabled'}
+
+---------------------------------------------------------------------------------
+-- Global Game State
+---------------------------------------------------------------------------------
+_G.GAME = {
+    name = "${project.name}",
+    version = "${project.version}",
+    settings = {
+        width = ${project.settings.resolution.width},
+        height = ${project.settings.resolution.height},
+        masterVolume = ${project.settings.audio.masterVolume},
+    },
+    state = {
+        isPaused = false,
+        currentScene = nil,
+        score = 0,
+        level = 1,
+    },
+    entities = {},
+}
+
+---------------------------------------------------------------------------------
+-- Initialize Game Manager
+---------------------------------------------------------------------------------
+GameManager.init()
+
+---------------------------------------------------------------------------------
+-- Global Key Listener (for testing/debug)
+---------------------------------------------------------------------------------
+local function onKeyEvent(event)
+    if event.phase == "up" then
+        if event.keyName == "escape" or event.keyName == "back" then
+            -- Handle back button
+            if composer.getSceneName("current") ~= "${firstSceneName}" then
+                composer.gotoScene("scenes.${firstSceneName}", { effect = "fade", time = 300 })
+            else
+                native.requestExit()
+            end
+            return true
+        elseif event.keyName == "p" then
+            -- Toggle pause
+            _G.GAME.state.isPaused = not _G.GAME.state.isPaused
+            Events.dispatch("game:pause", { isPaused = _G.GAME.state.isPaused })
+        end
+    end
+    return false
+end
+Runtime:addEventListener("key", onKeyEvent)
+
+---------------------------------------------------------------------------------
+-- Start Game
+---------------------------------------------------------------------------------
+print("[Nice2Dev] Starting ${project.name} v${project.version}")
+
+-- Go to first scene
+composer.gotoScene("scenes.${firstSceneName}", {
+    effect = "fade",
+    time = 500,
+})
+`;
+        this.addTextFile('main.lua', mainLua);
+    }
+    /* ── Utility Modules ────────────────────────────────────────── */
+    async generateUtilityModules(project, options) {
+        // Game Manager
+        const gameManagerLua = `-- Game Manager Module
+-- Central game state and utilities
+-- Generated from Nice2Dev
+
+local M = {}
+
+-- Dependencies
+local Events = require("modules.events")
+local Utils = require("modules.utils")
+
+-- Private state
+local state = {
+    entities = {},
+    pools = {},
+    timers = {},
+    audioChannels = {},
+}
+
+-- Initialize game manager
+function M.init()
+    print("[GameManager] Initializing...")
+    
+    -- Set up audio channels
+    audio.setVolume(_G.GAME.settings.masterVolume)
+    
+    -- Create object pools
+    state.pools = {}
+    
+    print("[GameManager] Ready")
+end
+
+-- Entity management
+function M.registerEntity(entity)
+    if entity and entity.id then
+        state.entities[entity.id] = entity
+        Events.dispatch("entity:registered", { entity = entity })
+    end
+end
+
+function M.unregisterEntity(entityId)
+    if state.entities[entityId] then
+        state.entities[entityId] = nil
+        Events.dispatch("entity:unregistered", { id = entityId })
+    end
+end
+
+function M.getEntity(entityId)
+    return state.entities[entityId]
+end
+
+function M.getEntitiesByTag(tag)
+    local result = {}
+    for id, entity in pairs(state.entities) do
+        if entity.tags and Utils.tableContains(entity.tags, tag) then
+            table.insert(result, entity)
+        end
+    end
+    return result
+end
+
+-- Object pooling
+function M.createPool(name, factory, initialSize)
+    initialSize = initialSize or 10
+    state.pools[name] = {
+        factory = factory,
+        available = {},
+        inUse = {},
+    }
+    
+    for i = 1, initialSize do
+        local obj = factory()
+        obj.isVisible = false
+        table.insert(state.pools[name].available, obj)
+    end
+end
+
+function M.getFromPool(name)
+    local pool = state.pools[name]
+    if not pool then return nil end
+    
+    local obj = table.remove(pool.available)
+    if not obj then
+        obj = pool.factory()
+    end
+    
+    obj.isVisible = true
+    table.insert(pool.inUse, obj)
+    return obj
+end
+
+function M.returnToPool(name, obj)
+    local pool = state.pools[name]
+    if not pool then return end
+    
+    obj.isVisible = false
+    for i, inUseObj in ipairs(pool.inUse) do
+        if inUseObj == obj then
+            table.remove(pool.inUse, i)
+            break
+        end
+    end
+    table.insert(pool.available, obj)
+end
+
+-- Audio helpers
+function M.playSound(filename, options)
+    options = options or {}
+    local sound = audio.loadSound("sounds/" .. filename)
+    local channel = audio.play(sound, {
+        channel = options.channel,
+        loops = options.loops or 0,
+        onComplete = options.onComplete,
+    })
+    return channel
+end
+
+function M.playMusic(filename, options)
+    options = options or {}
+    local music = audio.loadStream("music/" .. filename)
+    local channel = audio.play(music, {
+        channel = 1,
+        loops = options.loops or -1,
+        fadein = options.fadein or 0,
+    })
+    state.audioChannels.music = channel
+    return channel
+end
+
+function M.stopMusic(fadeout)
+    if state.audioChannels.music then
+        if fadeout and fadeout > 0 then
+            audio.fade({
+                channel = state.audioChannels.music,
+                time = fadeout,
+                volume = 0,
+            })
+            timer.performWithDelay(fadeout, function()
+                audio.stop(state.audioChannels.music)
+            end)
+        else
+            audio.stop(state.audioChannels.music)
+        end
+    end
+end
+
+-- Pause/Resume
+function M.pause()
+    _G.GAME.state.isPaused = true
+    physics.pause()
+    Events.dispatch("game:pause", { isPaused = true })
+end
+
+function M.resume()
+    _G.GAME.state.isPaused = false
+    physics.start()
+    Events.dispatch("game:pause", { isPaused = false })
+end
+
+-- Cleanup
+function M.cleanup()
+    -- Clear entities
+    for id, _ in pairs(state.entities) do
+        state.entities[id] = nil
+    end
+    
+    -- Clear pools
+    for name, pool in pairs(state.pools) do
+        for _, obj in ipairs(pool.available) do
+            display.remove(obj)
+        end
+        for _, obj in ipairs(pool.inUse) do
+            display.remove(obj)
+        end
+        state.pools[name] = nil
+    end
+end
+
+return M
+`;
+        this.addTextFile('modules/game_manager.lua', gameManagerLua);
+        // Utils
+        const utilsLua = `-- Utils Module
+-- Common utility functions
+-- Generated from Nice2Dev
+
+local M = {}
+
+-- Math utilities
+function M.lerp(a, b, t)
+    return a + (b - a) * math.max(0, math.min(1, t))
+end
+
+function M.clamp(value, min, max)
+    return math.max(min, math.min(max, value))
+end
+
+function M.randomFloat(min, max)
+    return min + math.random() * (max - min)
+end
+
+function M.randomInt(min, max)
+    return math.random(min, max)
+end
+
+function M.distance(x1, y1, x2, y2)
+    local dx = x2 - x1
+    local dy = y2 - y1
+    return math.sqrt(dx * dx + dy * dy)
+end
+
+function M.angle(x1, y1, x2, y2)
+    return math.atan2(y2 - y1, x2 - x1)
+end
+
+function M.pointInRect(px, py, rx, ry, rw, rh)
+    return px >= rx and px <= rx + rw and py >= ry and py <= ry + rh
+end
+
+function M.rectsOverlap(r1x, r1y, r1w, r1h, r2x, r2y, r2w, r2h)
+    return r1x < r2x + r2w and
+           r1x + r1w > r2x and
+           r1y < r2y + r2h and
+           r1y + r1h > r2y
+end
+
+-- Table utilities
+function M.tableContains(tbl, value)
+    for _, v in ipairs(tbl) do
+        if v == value then return true end
+    end
+    return false
+end
+
+function M.tableCopy(tbl)
+    local copy = {}
+    for k, v in pairs(tbl) do
+        if type(v) == "table" then
+            copy[k] = M.tableCopy(v)
+        else
+            copy[k] = v
+        end
+    end
+    return copy
+end
+
+function M.tableLength(tbl)
+    local count = 0
+    for _ in pairs(tbl) do count = count + 1 end
+    return count
+end
+
+function M.tableKeys(tbl)
+    local keys = {}
+    for k in pairs(tbl) do
+        table.insert(keys, k)
+    end
+    return keys
+end
+
+function M.shuffleTable(tbl)
+    for i = #tbl, 2, -1 do
+        local j = math.random(i)
+        tbl[i], tbl[j] = tbl[j], tbl[i]
+    end
+    return tbl
+end
+
+-- String utilities
+function M.split(str, delimiter)
+    local result = {}
+    for match in (str .. delimiter):gmatch("(.-)" .. delimiter) do
+        table.insert(result, match)
+    end
+    return result
+end
+
+function M.trim(str)
+    return str:match("^%s*(.-)%s*$")
+end
+
+-- Timer helpers
+function M.setTimeout(callback, delay)
+    return timer.performWithDelay(delay, callback)
+end
+
+function M.setInterval(callback, interval)
+    return timer.performWithDelay(interval, callback, 0)
+end
+
+function M.clearTimer(timerHandle)
+    if timerHandle then
+        timer.cancel(timerHandle)
+    end
+end
+
+-- Display helpers
+function M.screenCenter()
+    return display.contentCenterX, display.contentCenterY
+end
+
+function M.screenSize()
+    return display.actualContentWidth, display.actualContentHeight
+end
+
+function M.isOffScreen(obj, margin)
+    margin = margin or 50
+    return obj.x < -margin or 
+           obj.x > display.actualContentWidth + margin or
+           obj.y < -margin or 
+           obj.y > display.actualContentHeight + margin
+end
+
+return M
+`;
+        this.addTextFile('modules/utils.lua', utilsLua);
+        // Events
+        const eventsLua = `-- Events Module
+-- Simple event system
+-- Generated from Nice2Dev
+
+local M = {}
+
+-- Private storage
+local listeners = {}
+
+-- Add event listener
+function M.on(eventName, callback)
+    if not listeners[eventName] then
+        listeners[eventName] = {}
+    end
+    table.insert(listeners[eventName], callback)
+    
+    -- Return unsubscribe function
+    return function()
+        M.off(eventName, callback)
+    end
+end
+
+-- Remove event listener
+function M.off(eventName, callback)
+    if listeners[eventName] then
+        for i, cb in ipairs(listeners[eventName]) do
+            if cb == callback then
+                table.remove(listeners[eventName], i)
+                break
+            end
+        end
+    end
+end
+
+-- Dispatch event
+function M.dispatch(eventName, data)
+    if listeners[eventName] then
+        for _, callback in ipairs(listeners[eventName]) do
+            local success, err = pcall(callback, data)
+            if not success then
+                print("[Events] Error in " .. eventName .. ": " .. tostring(err))
+            end
+        end
+    end
+end
+
+-- Once (listen for single occurrence)
+function M.once(eventName, callback)
+    local unsubscribe
+    unsubscribe = M.on(eventName, function(data)
+        unsubscribe()
+        callback(data)
+    end)
+    return unsubscribe
+end
+
+-- Remove all listeners for an event
+function M.removeAll(eventName)
+    listeners[eventName] = nil
+end
+
+-- Clear all listeners
+function M.clear()
+    listeners = {}
+end
+
+return M
+`;
+        this.addTextFile('modules/events.lua', eventsLua);
+        // Entity base class
+        const entityLua = `-- Entity Module
+-- Base entity class for game objects
+-- Generated from Nice2Dev
+
+local M = {}
+M.__index = M
+
+local Utils = require("modules.utils")
+local Events = require("modules.events")
+local GameManager = require("modules.game_manager")
+
+-- Constructor
+function M.new(params)
+    local self = setmetatable({}, M)
+    
+    params = params or {}
+    
+    self.id = params.id or tostring(os.time() .. math.random(1000, 9999))
+    self.name = params.name or "Entity"
+    self.tags = params.tags or {}
+    self.isAlive = true
+    self.components = {}
+    
+    -- Create display group
+    self.group = display.newGroup()
+    self.group.x = params.x or 0
+    self.group.y = params.y or 0
+    self.group.rotation = params.rotation or 0
+    self.group.xScale = params.scaleX or 1
+    self.group.yScale = params.scaleY or 1
+    
+    -- Reference back to entity
+    self.group.entity = self
+    
+    -- Register with game manager
+    GameManager.registerEntity(self)
+    
+    return self
+end
+
+-- Position getters/setters
+function M:getPosition()
+    return self.group.x, self.group.y
+end
+
+function M:setPosition(x, y)
+    self.group.x = x
+    self.group.y = y
+end
+
+function M:move(dx, dy)
+    self.group.x = self.group.x + dx
+    self.group.y = self.group.y + dy
+end
+
+-- Rotation
+function M:getRotation()
+    return self.group.rotation
+end
+
+function M:setRotation(angle)
+    self.group.rotation = angle
+end
+
+function M:rotate(delta)
+    self.group.rotation = self.group.rotation + delta
+end
+
+-- Scale
+function M:getScale()
+    return self.group.xScale, self.group.yScale
+end
+
+function M:setScale(sx, sy)
+    self.group.xScale = sx
+    self.group.yScale = sy or sx
+end
+
+-- Tags
+function M:hasTag(tag)
+    return Utils.tableContains(self.tags, tag)
+end
+
+function M:addTag(tag)
+    if not self:hasTag(tag) then
+        table.insert(self.tags, tag)
+    end
+end
+
+function M:removeTag(tag)
+    for i, t in ipairs(self.tags) do
+        if t == tag then
+            table.remove(self.tags, i)
+            break
+        end
+    end
+end
+
+-- Components
+function M:addComponent(name, component)
+    self.components[name] = component
+    component.entity = self
+    if component.init then
+        component:init()
+    end
+end
+
+function M:getComponent(name)
+    return self.components[name]
+end
+
+function M:removeComponent(name)
+    local component = self.components[name]
+    if component then
+        if component.destroy then
+            component:destroy()
+        end
+        self.components[name] = nil
+    end
+end
+
+-- Update (called each frame if registered)
+function M:update(dt)
+    if not self.isAlive then return end
+    
+    -- Update all components
+    for _, component in pairs(self.components) do
+        if component.update then
+            component:update(dt)
+        end
+    end
+end
+
+-- Destroy
+function M:destroy()
+    if not self.isAlive then return end
+    
+    self.isAlive = false
+    
+    -- Destroy all components
+    for name, component in pairs(self.components) do
+        if component.destroy then
+            component:destroy()
+        end
+    end
+    self.components = {}
+    
+    -- Unregister
+    GameManager.unregisterEntity(self.id)
+    
+    -- Remove display group
+    if self.group then
+        display.remove(self.group)
+        self.group = nil
+    end
+    
+    Events.dispatch("entity:destroyed", { id = self.id })
+end
+
+return M
+`;
+        this.addTextFile('modules/entity.lua', entityLua);
+    }
+    /* ── Scene Export ───────────────────────────────────────────── */
+    async exportScene(scene, project, options) {
+        const sceneName = scene.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        options.platformOptions ?? {};
+        const sceneLua = `-- Scene: ${scene.name}
+-- Generated from Nice2Dev
+
+local composer = require("composer")
+local physics = require("physics")
+
+local GameManager = require("modules.game_manager")
+local Events = require("modules.events")
+local Utils = require("modules.utils")
+local Entity = require("modules.entity")
+
+local scene = composer.newScene()
+
+---------------------------------------------------------------------------------
+-- Scene Variables
+---------------------------------------------------------------------------------
+local sceneGroup
+local entities = {}
+local timers = {}
+local listeners = {}
+
+---------------------------------------------------------------------------------
+-- Scene Methods
+---------------------------------------------------------------------------------
+
+-- Create scene objects
+function scene:create(event)
+    sceneGroup = self.view
+    
+    -- Background
+    local bg = display.newRect(sceneGroup, display.contentCenterX, display.contentCenterY,
+        display.actualContentWidth, display.actualContentHeight)
+    bg:setFillColor(${this.hexToRGB(scene.background ?? '#000000')})
+    
+    -- Create entities
+${scene.entities.map((entity) => this.createEntityLua(entity)).join('\n')}
+    
+    print("[Scene] ${sceneName} created")
+end
+
+-- Show scene (transition in)
+function scene:show(event)
+    sceneGroup = self.view
+    local phase = event.phase
+    
+    if phase == "will" then
+        -- Called when scene is about to appear
+    elseif phase == "did" then
+        -- Called when scene has fully appeared
+        
+        -- Start physics
+        physics.start()
+        
+        -- Add update listener
+        listeners.enterFrame = function(e)
+            self:update(e)
+        end
+        Runtime:addEventListener("enterFrame", listeners.enterFrame)
+        
+        -- Add touch listener
+        listeners.touch = function(e)
+            return self:touch(e)
+        end
+        Runtime:addEventListener("touch", listeners.touch)
+        
+        _G.GAME.state.currentScene = "${sceneName}"
+        Events.dispatch("scene:started", { name = "${sceneName}" })
+        
+        print("[Scene] ${sceneName} started")
+    end
+end
+
+-- Hide scene (transition out)
+function scene:hide(event)
+    sceneGroup = self.view
+    local phase = event.phase
+    
+    if phase == "will" then
+        -- Called when scene is about to hide
+        
+        -- Remove listeners
+        if listeners.enterFrame then
+            Runtime:removeEventListener("enterFrame", listeners.enterFrame)
+        end
+        if listeners.touch then
+            Runtime:removeEventListener("touch", listeners.touch)
+        end
+        
+    elseif phase == "did" then
+        -- Called when scene has fully hidden
+        physics.pause()
+        
+        Events.dispatch("scene:ended", { name = "${sceneName}" })
+        print("[Scene] ${sceneName} hidden")
+    end
+end
+
+-- Destroy scene
+function scene:destroy(event)
+    sceneGroup = self.view
+    
+    -- Cancel timers
+    for _, t in ipairs(timers) do
+        timer.cancel(t)
+    end
+    timers = {}
+    
+    -- Destroy entities
+    for _, entity in ipairs(entities) do
+        if entity.destroy then
+            entity:destroy()
+        end
+    end
+    entities = {}
+    
+    print("[Scene] ${sceneName} destroyed")
+end
+
+---------------------------------------------------------------------------------
+-- Update Loop
+---------------------------------------------------------------------------------
+function scene:update(event)
+    if _G.GAME.state.isPaused then return end
+    
+    local dt = event.time / 1000 -- Convert to seconds
+    
+    -- Update all entities
+    for i = #entities, 1, -1 do
+        local entity = entities[i]
+        if entity.isAlive then
+            if entity.update then
+                entity:update(dt)
+            end
+        else
+            table.remove(entities, i)
+        end
+    end
+end
+
+---------------------------------------------------------------------------------
+-- Touch Handler
+---------------------------------------------------------------------------------
+function scene:touch(event)
+    if event.phase == "began" then
+        -- Touch started
+        Events.dispatch("touch:start", { x = event.x, y = event.y })
+    elseif event.phase == "moved" then
+        -- Touch moved
+        Events.dispatch("touch:move", { x = event.x, y = event.y })
+    elseif event.phase == "ended" or event.phase == "cancelled" then
+        -- Touch ended
+        Events.dispatch("touch:end", { x = event.x, y = event.y })
+    end
+    return true
+end
+
+---------------------------------------------------------------------------------
+-- Scene Event Listeners
+---------------------------------------------------------------------------------
+scene:addEventListener("create", scene)
+scene:addEventListener("show", scene)
+scene:addEventListener("hide", scene)
+scene:addEventListener("destroy", scene)
+
+return scene
+`;
+        this.addTextFile(`scenes/${sceneName}.lua`, sceneLua);
+    }
+    createEntityLua(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;
+        const tags = entity.tags ?? [];
+        let entityLua = `    -- Entity: ${entity.name ?? entity.id}
+    local ${name} = Entity.new({
+        x = ${pos.x},
+        y = ${pos.y},
+        rotation = ${rotation},
+        scaleX = ${scale.x},
+        scaleY = ${scale.y},
+        name = "${entity.name ?? entity.id}",
+        tags = {${tags.map((t) => `"${t}"`).join(', ')}},
+    })
+    ${name}.group.anchorX = 0.5
+    ${name}.group.anchorY = 0.5
+    sceneGroup:insert(${name}.group)
+    table.insert(entities, ${name})
+`;
+        // Add sprite if present
+        const spriteComp = entity.components.find((c) => c.type === 'sprite');
+        if (spriteComp) {
+            const texture = spriteComp.properties?.['texture'] ?? 'placeholder.png';
+            entityLua += `    local ${name}_sprite = display.newImageRect(${name}.group, "images/${texture}", ${32 * scale.x}, ${32 * scale.y})
+    ${name}_sprite.x = 0
+    ${name}_sprite.y = 0
+`;
+        }
+        // Add physics if rigidbody
+        const rigidbodyComp = entity.components.find((c) => c.type === 'rigidbody');
+        if (rigidbodyComp) {
+            const bodyType = rigidbodyComp.properties?.['isKinematic']
+                ? 'kinematic'
+                : 'dynamic';
+            const mass = rigidbodyComp.properties?.['mass'] ?? 1;
+            entityLua += `    physics.addBody(${name}.group, "${bodyType}", {
+        density = ${mass},
+        friction = 0.5,
+        bounce = 0.2,
+    })
+`;
+        }
+        return entityLua;
+    }
+    hexToRGB(hex) {
+        const cleanHex = hex.replace('#', '');
+        const r = parseInt(cleanHex.substring(0, 2), 16) / 255;
+        const g = parseInt(cleanHex.substring(2, 4), 16) / 255;
+        const b = parseInt(cleanHex.substring(4, 6), 16) / 255;
+        return `${r.toFixed(2)}, ${g.toFixed(2)}, ${b.toFixed(2)}`;
+    }
+    /* ── Prefab Export ──────────────────────────────────────────── */
+    async exportPrefab(prefab, options) {
+        const prefabName = prefab.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        const entity = prefab.entity;
+        const tags = entity.tags ?? [];
+        const prefabLua = `-- Prefab: ${prefab.name}
+-- Generated from Nice2Dev
+
+local Entity = require("modules.entity")
+
+local M = {}
+
+function M.create(params)
+    params = params or {}
+    
+    local entity = Entity.new({
+        id = params.id,
+        name = "${prefab.name}",
+        x = params.x or 0,
+        y = params.y or 0,
+        rotation = params.rotation or ${entity.rotation ?? 0},
+        scaleX = params.scaleX or ${entity.scale?.x ?? 1},
+        scaleY = params.scaleY or ${entity.scale?.y ?? 1},
+        tags = params.tags or {${tags.map((t) => `"${t}"`).join(', ')}},
+    })
+    
+${entity.components.map((c) => this.componentToLua(c, prefabName)).join('\n')}
+    
+    return entity
+end
+
+return M
+`;
+        this.addTextFile(`prefabs/${prefabName}.lua`, prefabLua);
+    }
+    componentToLua(component, entityName) {
+        switch (component.type) {
+            case 'sprite': {
+                const texture = component.properties?.['texture'] ?? 'placeholder.png';
+                return `    -- Sprite component
+    local sprite = display.newImageRect(entity.group, "images/${texture}", 32, 32)
+    sprite.x = 0
+    sprite.y = 0`;
+            }
+            case 'rigidbody': {
+                const bodyType = component.properties?.['isKinematic']
+                    ? 'kinematic'
+                    : 'dynamic';
+                const mass = component.properties?.['mass'] ?? 1;
+                return `    -- Physics component
+    local physics = require("physics")
+    physics.addBody(entity.group, "${bodyType}", {
+        density = ${mass},
+        friction = 0.5,
+        bounce = 0.2,
+    })`;
+            }
+            default:
+                return `    -- ${component.type} component (custom)`;
+        }
+    }
+    /* ── README ─────────────────────────────────────────────────── */
+    async generateReadme(project, options) {
+        const readme = `# ${project.name} - Solar2D Export
+
+Generated from Nice2Dev project v${project.version}
+
+## Requirements
+
+- Solar2D Simulator (download from https://solar2d.com/)
+- Solar2D account for building
+
+## Installation
+
+1. Open Solar2D Simulator
+2. File > Open Project
+3. Select this folder
+4. Click "Open main.lua"
+
+## Project Structure
+
+- \`main.lua\` - Entry point
+- \`config.lua\` - App configuration
+- \`build.settings\` - Build settings for all platforms
+- \`modules/\` - Core modules
+  - \`game_manager.lua\` - Central game state
+  - \`utils.lua\` - Utility functions
+  - \`events.lua\` - Event system
+  - \`entity.lua\` - Entity base class
+- \`scenes/\` - Composer scenes
+- \`prefabs/\` - Spawnable prefabs
+- \`images/\` - Image assets (add your own)
+- \`sounds/\` - Sound effects (add your own)
+- \`music/\` - Background music (add your own)
+
+## Scenes
+
+${project.scenes.map((s) => `- ${s.name} (${s.entities.length} entities)`).join('\n')}
+
+## Building
+
+### Simulator
+Just open main.lua in Solar2D Simulator.
+
+### Device Build
+1. File > Build
+2. Select platform (iOS, Android, HTML5, etc.)
+3. Configure signing (for iOS/Android)
+4. Build!
+
+### HTML5
+1. File > Build > HTML5
+2. Upload build folder to web server
+
+## Key Modules
+
+### GameManager
+\`\`\`lua
+local GameManager = require("modules.game_manager")
+
+-- Register entity
+GameManager.registerEntity(entity)
+
+-- Get entities by tag
+local enemies = GameManager.getEntitiesByTag("enemy")
+
+-- Play sound
+GameManager.playSound("explosion.wav")
+
+-- Play music
+GameManager.playMusic("background.mp3", { loops = -1 })
+\`\`\`
+
+### Events
+\`\`\`lua
+local Events = require("modules.events")
+
+-- Listen for event
+Events.on("game:pause", function(data)
+    print("Game paused:", data.isPaused)
+end)
+
+-- Dispatch event
+Events.dispatch("game:pause", { isPaused = true })
+\`\`\`
+
+### Entity
+\`\`\`lua
+local Entity = require("modules.entity")
+
+local player = Entity.new({
+    x = 100,
+    y = 200,
+    name = "Player",
+    tags = {"player"},
+})
+
+player:setPosition(300, 400)
+player:rotate(45)
+player:destroy()
+\`\`\`
+
+## Notes
+
+- Add your image assets to \`images/\` folder
+- Add sound effects to \`sounds/\` folder
+- Add music to \`music/\` folder
+- Physics uses Box2D (built-in)
+- Scenes use Composer for lifecycle management
+
+## 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 createSolar2DExporter() {
+    return new Solar2DExporter();
+}
+
+exports.Solar2DExporter = Solar2DExporter;
+exports.createSolar2DExporter = createSolar2DExporter;
+//# sourceMappingURL=Solar2DExporter.js.map