@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/esm/export/RobloxExporter.js

@@ -0,0 +1,940 @@
+import { PlatformExporter } from './PlatformExporter.js';
+
+/* ────────────────────────────────────────────────────────────────
+   Roblox Exporter — Roblox Studio Project Export
+   
+   Exports Nice2Dev projects to Roblox Studio format including:
+   - Luau scripts (.lua)
+   - Model instances (.rbxmx XML)
+   - Module scripts
+   - Place file structure
+──────────────────────────────────────────────────────────────── */
+/* ── Roblox Exporter Implementation ───────────────────────────── */
+class RobloxExporter extends PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'roblox';
+        this.platformInfo = {
+            id: 'roblox',
+            name: 'Roblox Studio',
+            description: 'Roblox platform with Luau scripting language',
+            website: 'https://create.roblox.com',
+            features: [
+                '3d-rendering',
+                'physics-3d',
+                'audio',
+                'networking',
+                'ui-system',
+                'particles',
+                'animation',
+            ],
+            supportedAssets: ['audio', 'script', 'scene', 'prefab', 'particleSystem', 'texture', 'data'],
+            exportFormats: ['.lua', '.rbxmx', '.rbxlx'],
+        };
+        this.projectName = 'Nice2DevGame';
+        this.useStrictMode = true;
+    }
+    async doExport(project, options) {
+        this.projectName = (options.projectName ?? project.name).replace(/[^a-zA-Z0-9_]/g, '_');
+        const platformOpts = options.platformOptions ?? {};
+        this.useStrictMode = platformOpts.strictMode !== false;
+        // Generate folder structure
+        await this.generateFolderStructure(project, options);
+        // Generate core scripts
+        await this.generateCoreScripts(project, options);
+        // Generate services setup
+        await this.generateServicesSetup(project, options);
+        // Export scenes as places/models
+        for (const scene of project.scenes) {
+            await this.exportScene(scene, project, options);
+        }
+        // Export prefabs as models
+        for (const prefab of project.prefabs) {
+            await this.exportPrefab(prefab, options);
+        }
+        // Generate client scripts if enabled
+        if (platformOpts.includeClientScripts !== false) {
+            await this.generateClientScripts(project, options);
+        }
+        // Generate server scripts if enabled
+        if (platformOpts.includeServerScripts !== false) {
+            await this.generateServerScripts(project, options);
+        }
+    }
+    /* ── Folder Structure ───────────────────────────────────────── */
+    async generateFolderStructure(project, options) {
+        // README for the export
+        const readme = `# ${project.name} - Roblox Export
+
+Generated from Nice2Dev project v${project.version}
+
+## Folder Structure
+
+- \`ServerScriptService/\` - Server-side scripts
+- \`ReplicatedStorage/\` - Shared modules and assets
+- \`StarterPlayer/StarterPlayerScripts/\` - Client scripts
+- \`StarterGui/\` - UI elements
+- \`Workspace/\` - Game world objects
+
+## Setup Instructions
+
+1. Open Roblox Studio
+2. Create a new place or open existing
+3. Import the .rbxmx model files
+4. Copy Lua scripts to appropriate services
+5. Configure game settings as needed
+
+## Notes
+
+- Textures and audio assets need to be uploaded to Roblox and IDs updated
+- Physics settings may need adjustment for Roblox's scale
+`;
+        this.addTextFile('README.md', readme);
+    }
+    /* ── Core Scripts ───────────────────────────────────────────── */
+    async generateCoreScripts(project, options) {
+        // Game Manager Module
+        const gameManagerModule = `${this.useStrictMode ? '--!strict\n' : ''}--[[
+    Game Manager Module
+    Generated from Nice2Dev project: ${project.name}
+    
+    Central game state and utility management.
+]]
+
+local GameManager = {}
+GameManager.__index = GameManager
+
+-- Services
+local Players = game:GetService("Players")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local RunService = game:GetService("RunService")
+
+-- Game State
+local gameState = {
+    isPaused = false,
+    currentScene = nil,
+    entities = {},
+    globalVariables = {},
+}
+
+-- Settings from Nice2Dev project
+GameManager.Settings = {
+    GameWidth = ${project.settings.resolution.width},
+    GameHeight = ${project.settings.resolution.height},
+    MasterVolume = ${project.settings.audio.masterVolume},
+    PhysicsEnabled = ${project.settings.physics.enabled},
+    GravityX = ${project.settings.physics.gravity.x},
+    GravityY = ${project.settings.physics.gravity.y},
+}
+
+function GameManager.new()
+    local self = setmetatable({}, GameManager)
+    return self
+end
+
+function GameManager:Initialize()
+    -- Apply gravity settings
+    workspace.Gravity = math.abs(self.Settings.GravityY)
+    
+    -- Set up game loop
+    RunService.Heartbeat:Connect(function(deltaTime)
+        if not gameState.isPaused then
+            self:Update(deltaTime)
+        end
+    end)
+    
+    print("[GameManager] Initialized")
+end
+
+function GameManager:Update(deltaTime: number)
+    -- Update all registered entities
+    for id, entity in pairs(gameState.entities) do
+        if entity.Update then
+            entity:Update(deltaTime)
+        end
+    end
+end
+
+function GameManager:RegisterEntity(id: string, entity: any)
+    gameState.entities[id] = entity
+end
+
+function GameManager:UnregisterEntity(id: string)
+    gameState.entities[id] = nil
+end
+
+function GameManager:GetEntity(id: string)
+    return gameState.entities[id]
+end
+
+function GameManager:SetVariable(key: string, value: any)
+    gameState.globalVariables[key] = value
+end
+
+function GameManager:GetVariable(key: string): any
+    return gameState.globalVariables[key]
+end
+
+function GameManager:Pause()
+    gameState.isPaused = true
+end
+
+function GameManager:Resume()
+    gameState.isPaused = false
+end
+
+function GameManager:IsPaused(): boolean
+    return gameState.isPaused
+end
+
+return GameManager
+`;
+        this.addTextFile('ReplicatedStorage/Modules/GameManager.lua', gameManagerModule);
+        // Entity Base Module
+        const entityBaseModule = `${this.useStrictMode ? '--!strict\n' : ''}--[[
+    Entity Base Module
+    Base class for all Nice2Dev entities
+]]
+
+local EntityBase = {}
+EntityBase.__index = EntityBase
+
+export type Entity = {
+    Id: string,
+    Name: string,
+    Tags: {string},
+    Instance: Instance?,
+    
+    Start: (self: Entity) -> (),
+    Update: (self: Entity, deltaTime: number) -> (),
+    Destroy: (self: Entity) -> (),
+    HasTag: (self: Entity, tag: string) -> boolean,
+}
+
+function EntityBase.new(id: string, name: string): Entity
+    local self = setmetatable({}, EntityBase)
+    self.Id = id
+    self.Name = name
+    self.Tags = {}
+    self.Instance = nil
+    return self :: Entity
+end
+
+function EntityBase:Start()
+    -- Override in derived entities
+end
+
+function EntityBase:Update(deltaTime: number)
+    -- Override in derived entities
+end
+
+function EntityBase:Destroy()
+    if self.Instance then
+        self.Instance:Destroy()
+    end
+end
+
+function EntityBase:HasTag(tag: string): boolean
+    for _, t in ipairs(self.Tags) do
+        if t == tag then
+            return true
+        end
+    end
+    return false
+end
+
+function EntityBase:AddTag(tag: string)
+    if not self:HasTag(tag) then
+        table.insert(self.Tags, tag)
+    end
+end
+
+function EntityBase:RemoveTag(tag: string)
+    for i, t in ipairs(self.Tags) do
+        if t == tag then
+            table.remove(self.Tags, i)
+            return
+        end
+    end
+end
+
+function EntityBase:SetPosition(x: number, y: number, z: number?)
+    if self.Instance and self.Instance:IsA("BasePart") then
+        self.Instance.Position = Vector3.new(x, y, z or 0)
+    elseif self.Instance and self.Instance:IsA("Model") then
+        local primary = self.Instance.PrimaryPart
+        if primary then
+            self.Instance:SetPrimaryPartCFrame(CFrame.new(x, y, z or 0))
+        end
+    end
+end
+
+function EntityBase:GetPosition(): Vector3
+    if self.Instance and self.Instance:IsA("BasePart") then
+        return self.Instance.Position
+    elseif self.Instance and self.Instance:IsA("Model") then
+        local primary = self.Instance.PrimaryPart
+        if primary then
+            return primary.Position
+        end
+    end
+    return Vector3.new(0, 0, 0)
+end
+
+function EntityBase:MoveTowards(targetPosition: Vector3, speed: number, deltaTime: number)
+    local currentPos = self:GetPosition()
+    local direction = (targetPosition - currentPos).Unit
+    local distance = (targetPosition - currentPos).Magnitude
+    
+    if distance <= speed * deltaTime then
+        self:SetPosition(targetPosition.X, targetPosition.Y, targetPosition.Z)
+    else
+        local newPos = currentPos + direction * speed * deltaTime
+        self:SetPosition(newPos.X, newPos.Y, newPos.Z)
+    end
+end
+
+function EntityBase:LookAt(targetPosition: Vector3)
+    if self.Instance and self.Instance:IsA("BasePart") then
+        self.Instance.CFrame = CFrame.lookAt(self.Instance.Position, targetPosition)
+    end
+end
+
+return EntityBase
+`;
+        this.addTextFile('ReplicatedStorage/Modules/EntityBase.lua', entityBaseModule);
+        // Utility Module
+        const utilityModule = `${this.useStrictMode ? '--!strict\n' : ''}--[[
+    Nice2Dev Utility Module
+    Common utility functions for game development
+]]
+
+local Utility = {}
+
+-- Math Utilities
+function Utility.Lerp(a: number, b: number, t: number): number
+    return a + (b - a) * math.clamp(t, 0, 1)
+end
+
+function Utility.LerpVector3(a: Vector3, b: Vector3, t: number): Vector3
+    return a:Lerp(b, math.clamp(t, 0, 1))
+end
+
+function Utility.LerpColor3(a: Color3, b: Color3, t: number): Color3
+    return a:Lerp(b, math.clamp(t, 0, 1))
+end
+
+function Utility.Remap(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number
+    return outMin + (value - inMin) * (outMax - outMin) / (inMax - inMin)
+end
+
+function Utility.RandomPointInCircle(center: Vector3, radius: number): Vector3
+    local angle = math.random() * math.pi * 2
+    local distance = math.sqrt(math.random()) * radius
+    return center + Vector3.new(
+        math.cos(angle) * distance,
+        0,
+        math.sin(angle) * distance
+    )
+end
+
+function Utility.RandomPointInSphere(center: Vector3, radius: number): Vector3
+    local theta = math.random() * math.pi * 2
+    local phi = math.acos(2 * math.random() - 1)
+    local r = radius * math.random() ^ (1/3)
+    
+    return center + Vector3.new(
+        r * math.sin(phi) * math.cos(theta),
+        r * math.sin(phi) * math.sin(theta),
+        r * math.cos(phi)
+    )
+end
+
+-- Distance Utilities
+function Utility.Distance2D(a: Vector3, b: Vector3): number
+    local dx = a.X - b.X
+    local dz = a.Z - b.Z
+    return math.sqrt(dx * dx + dz * dz)
+end
+
+function Utility.Distance3D(a: Vector3, b: Vector3): number
+    return (a - b).Magnitude
+end
+
+-- Instance Utilities
+function Utility.FindFirstChildWithTag(parent: Instance, tag: string): Instance?
+    local CollectionService = game:GetService("CollectionService")
+    for _, child in ipairs(parent:GetChildren()) do
+        if CollectionService:HasTag(child, tag) then
+            return child
+        end
+    end
+    return nil
+end
+
+function Utility.FindChildrenWithTag(parent: Instance, tag: string): {Instance}
+    local CollectionService = game:GetService("CollectionService")
+    local result = {}
+    for _, child in ipairs(parent:GetDescendants()) do
+        if CollectionService:HasTag(child, tag) then
+            table.insert(result, child)
+        end
+    end
+    return result
+end
+
+-- Timer Utility
+function Utility.CreateTimer(duration: number, callback: () -> ()): thread
+    return task.spawn(function()
+        task.wait(duration)
+        callback()
+    end)
+end
+
+function Utility.CreateRepeatingTimer(interval: number, callback: () -> boolean): thread
+    return task.spawn(function()
+        while true do
+            task.wait(interval)
+            local shouldContinue = callback()
+            if not shouldContinue then
+                break
+            end
+        end
+    end)
+end
+
+-- Spawn Utility
+function Utility.SpawnModel(model: Model, position: Vector3, parent: Instance?): Model
+    local clone = model:Clone()
+    if clone.PrimaryPart then
+        clone:SetPrimaryPartCFrame(CFrame.new(position))
+    end
+    clone.Parent = parent or workspace
+    return clone
+end
+
+return Utility
+`;
+        this.addTextFile('ReplicatedStorage/Modules/Utility.lua', utilityModule);
+    }
+    /* ── Services Setup ─────────────────────────────────────────── */
+    async generateServicesSetup(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        // Based on genre, include different default setups
+        const genre = platformOpts.genre ?? 'adventure';
+        // Game Initialization Script
+        const initScript = `${this.useStrictMode ? '--!strict\n' : ''}--[[
+    Game Initialization Script
+    Generated from Nice2Dev project: ${project.name}
+    Genre: ${genre}
+]]
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Players = game:GetService("Players")
+
+-- Wait for modules to load
+local Modules = ReplicatedStorage:WaitForChild("Modules")
+local GameManager = require(Modules:WaitForChild("GameManager"))
+
+-- Initialize game
+local gameManager = GameManager.new()
+gameManager:Initialize()
+
+-- Store reference globally for other scripts
+_G.GameManager = gameManager
+
+-- Player handling
+Players.PlayerAdded:Connect(function(player)
+    print("[Game] Player joined:", player.Name)
+    
+    player.CharacterAdded:Connect(function(character)
+        -- Character setup
+        local humanoid = character:WaitForChild("Humanoid")
+        
+        -- Apply Nice2Dev settings
+        -- humanoid.WalkSpeed = 16
+        -- humanoid.JumpPower = 50
+    end)
+end)
+
+Players.PlayerRemoving:Connect(function(player)
+    print("[Game] Player left:", player.Name)
+end)
+
+print("[Game] ${project.name} initialized successfully!")
+`;
+        this.addTextFile('ServerScriptService/GameInit.server.lua', initScript);
+    }
+    /* ── Client Scripts ─────────────────────────────────────────── */
+    async generateClientScripts(project, options) {
+        // Client-side game controller
+        const clientController = `${this.useStrictMode ? '--!strict\n' : ''}--[[
+    Client Controller
+    Handles client-side game logic and input
+]]
+
+local Players = game:GetService("Players")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local UserInputService = game:GetService("UserInputService")
+local RunService = game:GetService("RunService")
+
+local LocalPlayer = Players.LocalPlayer
+
+-- Modules
+local Modules = ReplicatedStorage:WaitForChild("Modules")
+local Utility = require(Modules:WaitForChild("Utility"))
+
+-- Input State
+local inputState = {
+    moveDirection = Vector3.new(0, 0, 0),
+    mousePosition = Vector2.new(0, 0),
+    keysDown = {},
+}
+
+-- Input Handling
+UserInputService.InputBegan:Connect(function(input, gameProcessed)
+    if gameProcessed then return end
+    
+    if input.UserInputType == Enum.UserInputType.Keyboard then
+        inputState.keysDown[input.KeyCode] = true
+        
+        -- Example: Jump on space
+        if input.KeyCode == Enum.KeyCode.Space then
+            local character = LocalPlayer.Character
+            if character then
+                local humanoid = character:FindFirstChildOfClass("Humanoid")
+                if humanoid then
+                    humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
+                end
+            end
+        end
+    elseif input.UserInputType == Enum.UserInputType.MouseButton1 then
+        -- Left click
+    elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
+        -- Right click
+    end
+end)
+
+UserInputService.InputEnded:Connect(function(input, gameProcessed)
+    if input.UserInputType == Enum.UserInputType.Keyboard then
+        inputState.keysDown[input.KeyCode] = nil
+    end
+end)
+
+-- Mouse tracking
+UserInputService.InputChanged:Connect(function(input)
+    if input.UserInputType == Enum.UserInputType.MouseMovement then
+        inputState.mousePosition = Vector2.new(input.Position.X, input.Position.Y)
+    end
+end)
+
+-- Helper functions
+local function IsKeyDown(keyCode: Enum.KeyCode): boolean
+    return inputState.keysDown[keyCode] ~= nil
+end
+
+local function GetMoveDirection(): Vector3
+    local direction = Vector3.new(0, 0, 0)
+    
+    if IsKeyDown(Enum.KeyCode.W) or IsKeyDown(Enum.KeyCode.Up) then
+        direction = direction + Vector3.new(0, 0, -1)
+    end
+    if IsKeyDown(Enum.KeyCode.S) or IsKeyDown(Enum.KeyCode.Down) then
+        direction = direction + Vector3.new(0, 0, 1)
+    end
+    if IsKeyDown(Enum.KeyCode.A) or IsKeyDown(Enum.KeyCode.Left) then
+        direction = direction + Vector3.new(-1, 0, 0)
+    end
+    if IsKeyDown(Enum.KeyCode.D) or IsKeyDown(Enum.KeyCode.Right) then
+        direction = direction + Vector3.new(1, 0, 0)
+    end
+    
+    if direction.Magnitude > 0 then
+        direction = direction.Unit
+    end
+    
+    return direction
+end
+
+-- Client update loop
+RunService.RenderStepped:Connect(function(deltaTime)
+    inputState.moveDirection = GetMoveDirection()
+    
+    -- Update client-side effects, animations, etc.
+end)
+
+print("[ClientController] Initialized")
+`;
+        this.addTextFile('StarterPlayer/StarterPlayerScripts/ClientController.client.lua', clientController);
+    }
+    /* ── Server Scripts ─────────────────────────────────────────── */
+    async generateServerScripts(project, options) {
+        // Data handling script
+        const dataScript = `${this.useStrictMode ? '--!strict\n' : ''}--[[
+    Data Handler Script
+    Handles player data saving and loading using DataStoreService
+]]
+
+local DataStoreService = game:GetService("DataStoreService")
+local Players = game:GetService("Players")
+
+local playerDataStore = DataStoreService:GetDataStore("PlayerData_${this.projectName}")
+
+-- Default player data
+local defaultData = {
+    coins = 0,
+    level = 1,
+    experience = 0,
+    inventory = {},
+    settings = {
+        musicVolume = ${project.settings.audio.masterVolume},
+        sfxVolume = 1.0,
+    },
+}
+
+local playerData = {}
+
+local function LoadPlayerData(player: Player): {[string]: any}
+    local success, data = pcall(function()
+        return playerDataStore:GetAsync("Player_" .. player.UserId)
+    end)
+    
+    if success and data then
+        -- Merge with defaults for any missing keys
+        for key, value in pairs(defaultData) do
+            if data[key] == nil then
+                data[key] = value
+            end
+        end
+        return data
+    else
+        warn("[Data] Failed to load data for", player.Name, "using defaults")
+        return table.clone(defaultData)
+    end
+end
+
+local function SavePlayerData(player: Player, data: {[string]: any})
+    local success, err = pcall(function()
+        playerDataStore:SetAsync("Player_" .. player.UserId, data)
+    end)
+    
+    if not success then
+        warn("[Data] Failed to save data for", player.Name, ":", err)
+    end
+end
+
+-- Player handling
+Players.PlayerAdded:Connect(function(player)
+    playerData[player.UserId] = LoadPlayerData(player)
+    print("[Data] Loaded data for", player.Name)
+end)
+
+Players.PlayerRemoving:Connect(function(player)
+    if playerData[player.UserId] then
+        SavePlayerData(player, playerData[player.UserId])
+        playerData[player.UserId] = nil
+        print("[Data] Saved data for", player.Name)
+    end
+end)
+
+-- Auto-save every 5 minutes
+task.spawn(function()
+    while true do
+        task.wait(300)
+        for userId, data in pairs(playerData) do
+            local player = Players:GetPlayerByUserId(userId)
+            if player then
+                SavePlayerData(player, data)
+            end
+        end
+        print("[Data] Auto-save complete")
+    end
+end)
+
+-- API for other scripts
+local DataHandler = {}
+
+function DataHandler.GetPlayerData(player: Player): {[string]: any}?
+    return playerData[player.UserId]
+end
+
+function DataHandler.SetPlayerData(player: Player, key: string, value: any)
+    if playerData[player.UserId] then
+        playerData[player.UserId][key] = value
+    end
+end
+
+return DataHandler
+`;
+        this.addTextFile('ServerScriptService/DataHandler.server.lua', dataScript);
+    }
+    /* ── Scene Export ───────────────────────────────────────────── */
+    async exportScene(scene, project, options) {
+        // Generate scene as a Model in RBXMX format
+        const modelXml = this.generateSceneModel(scene, project);
+        this.addTextFile(`Workspace/${scene.name}.rbxmx`, modelXml);
+        // Generate scene script
+        const sceneScript = this.generateSceneScript(scene);
+        this.addTextFile(`ServerScriptService/Scenes/${scene.name}.server.lua`, sceneScript);
+    }
+    generateSceneModel(scene, project) {
+        const instances = [];
+        // Root folder for scene
+        instances.push(`<Item class="Folder" referent="RBX_SCENE_ROOT">
+    <Properties>
+      <string name="Name">${scene.name}</string>
+    </Properties>`);
+        // Generate entity instances
+        for (const entity of scene.entities) {
+            instances.push(this.generateEntityXml(entity));
+        }
+        instances.push(`</Item>`);
+        return `<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
+  <Meta name="ExplicitAutoJoints">true</Meta>
+  ${instances.join('\n  ')}
+</roblox>`;
+    }
+    generateEntityXml(entity, parentRef = 'RBX_SCENE_ROOT') {
+        const pos = entity.position ?? { x: 0, y: 0 };
+        const scale = entity.scale ?? { x: 1, y: 1 };
+        const referent = `RBX_${entity.id.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        // Determine instance class based on components
+        let instanceClass = 'Part';
+        const additionalProps = '';
+        const hasCollider = entity.components.some((c) => c.type.includes('Collider'));
+        entity.components.some((c) => c.type === 'sprite');
+        const hasLight = entity.components.some((c) => c.type === 'light');
+        if (hasLight) {
+            instanceClass = 'Part'; // Will contain a PointLight child
+        }
+        const xml = `<Item class="${instanceClass}" referent="${referent}">
+    <Properties>
+      <string name="Name">${entity.name ?? entity.id}</string>
+      <Vector3 name="Position">
+        <X>${pos.x}</X>
+        <Y>${pos.y}</Y>
+        <Z>0</Z>
+      </Vector3>
+      <Vector3 name="Size">
+        <X>${scale.x}</X>
+        <Y>${scale.y}</Y>
+        <Z>1</Z>
+      </Vector3>
+      <bool name="Anchored">${!entity.components.some((c) => c.type === 'rigidbody')}</bool>
+      <bool name="CanCollide">${hasCollider}</bool>
+      ${additionalProps}
+    </Properties>
+    ${this.generateComponentChildren(entity)}
+  </Item>`;
+        return xml;
+    }
+    generateComponentChildren(entity) {
+        const children = [];
+        for (const comp of entity.components) {
+            switch (comp.type) {
+                case 'light':
+                    const lightColor = comp.properties?.['color'] ?? '#ffffff';
+                    const brightness = comp.properties?.['intensity'] ?? 1;
+                    const range = comp.properties?.['range'] ?? 10;
+                    children.push(`<Item class="PointLight">
+      <Properties>
+        <Color3 name="Color">${this.hexToRobloxColor3(lightColor)}</Color3>
+        <float name="Brightness">${brightness}</float>
+        <float name="Range">${range}</float>
+      </Properties>
+    </Item>`);
+                    break;
+                case 'audioSource':
+                    const soundId = comp.properties?.['clip'];
+                    const volume = comp.properties?.['volume'] ?? 1;
+                    const loop = comp.properties?.['loop'] ?? false;
+                    children.push(`<Item class="Sound">
+      <Properties>
+        <string name="Name">${comp.type}_sound</string>
+        <Content name="SoundId"><url>${soundId ?? ''}</url></Content>
+        <float name="Volume">${volume}</float>
+        <bool name="Looped">${loop}</bool>
+      </Properties>
+    </Item>`);
+                    break;
+                case 'particleEmitter':
+                    children.push(`<Item class="ParticleEmitter">
+      <Properties>
+        <string name="Name">${comp.type}_emitter</string>
+        <float name="Rate">${comp.properties?.['rate'] ?? 10}</float>
+      </Properties>
+    </Item>`);
+                    break;
+            }
+        }
+        return children.join('\n    ');
+    }
+    hexToRobloxColor3(hex) {
+        const h = hex.replace('#', '');
+        const r = parseInt(h.substr(0, 2), 16) / 255;
+        const g = parseInt(h.substr(2, 2), 16) / 255;
+        const b = parseInt(h.substr(4, 2), 16) / 255;
+        return `<R>${r.toFixed(6)}</R><G>${g.toFixed(6)}</G><B>${b.toFixed(6)}</B>`;
+    }
+    generateSceneScript(scene) {
+        return `${this.useStrictMode ? '--!strict\n' : ''}--[[
+    Scene Script: ${scene.name}
+    Generated from Nice2Dev scene
+]]
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Modules = ReplicatedStorage:WaitForChild("Modules")
+local EntityBase = require(Modules:WaitForChild("EntityBase"))
+local GameManager = require(Modules:WaitForChild("GameManager"))
+
+local SceneManager = {}
+
+-- Entity definitions for this scene
+local entityDefinitions = {
+${scene.entities
+            .map((e) => `    ["${e.id}"] = {
+        name = "${e.name ?? e.id}",
+        position = Vector3.new(${e.position?.x ?? 0}, ${e.position?.y ?? 0}, 0),
+        tags = {${(e.tags ?? []).map((t) => `"${t}"`).join(', ')}},
+    },`)
+            .join('\n')}
+}
+
+function SceneManager:Initialize()
+    -- Create entities from definitions
+    for id, def in pairs(entityDefinitions) do
+        local entity = EntityBase.new(id, def.name)
+        entity.Tags = def.tags
+        
+        -- Find or create instance in workspace
+        local folder = workspace:FindFirstChild("${scene.name}")
+        if folder then
+            local instance = folder:FindFirstChild(def.name)
+            if instance then
+                entity.Instance = instance
+            end
+        end
+        
+        -- Register with GameManager
+        if _G.GameManager then
+            _G.GameManager:RegisterEntity(id, entity)
+        end
+        
+        entity:Start()
+    end
+    
+    print("[Scene] ${scene.name} initialized with", #entityDefinitions, "entities")
+end
+
+function SceneManager:Cleanup()
+    for id, _ in pairs(entityDefinitions) do
+        if _G.GameManager then
+            local entity = _G.GameManager:GetEntity(id)
+            if entity then
+                entity:Destroy()
+            end
+            _G.GameManager:UnregisterEntity(id)
+        end
+    end
+end
+
+return SceneManager
+`;
+    }
+    /* ── Prefab Export ──────────────────────────────────────────── */
+    async exportPrefab(prefab, options) {
+        // Generate prefab as a Module script that can instantiate the entity
+        const prefabModule = `${this.useStrictMode ? '--!strict\n' : ''}--[[
+    Prefab Module: ${prefab.name}
+    Generated from Nice2Dev prefab
+]]
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Modules = ReplicatedStorage:WaitForChild("Modules")
+local EntityBase = require(Modules:WaitForChild("EntityBase"))
+
+local ${prefab.name}Prefab = {}
+
+-- Prefab definition
+local prefabDef = {
+    name = "${prefab.entity.name ?? prefab.name}",
+    components = {
+${prefab.entity.components.map((c) => `        { type = "${c.type}", properties = ${this.luaTableFromObject(c.properties ?? {})} },`).join('\n')}
+    },
+    tags = {${(prefab.entity.tags ?? []).map((t) => `"${t}"`).join(', ')}},
+}
+
+function ${prefab.name}Prefab.Spawn(position: Vector3, parent: Instance?): any
+    local entity = EntityBase.new(
+        game:GetService("HttpService"):GenerateGUID(false),
+        prefabDef.name
+    )
+    entity.Tags = table.clone(prefabDef.tags)
+    
+    -- Create instance
+    local part = Instance.new("Part")
+    part.Name = prefabDef.name
+    part.Position = position
+    part.Anchored = true
+    part.Parent = parent or workspace
+    
+    entity.Instance = part
+    
+    -- Apply components
+    for _, comp in ipairs(prefabDef.components) do
+        -- Component setup based on type
+        if comp.type == "light" then
+            local light = Instance.new("PointLight")
+            light.Parent = part
+        elseif comp.type == "audioSource" then
+            local sound = Instance.new("Sound")
+            sound.Parent = part
+        end
+    end
+    
+    -- Register with GameManager
+    if _G.GameManager then
+        _G.GameManager:RegisterEntity(entity.Id, entity)
+    end
+    
+    entity:Start()
+    return entity
+end
+
+return ${prefab.name}Prefab
+`;
+        this.addTextFile(`ReplicatedStorage/Prefabs/${prefab.name}.lua`, prefabModule);
+    }
+    luaTableFromObject(obj) {
+        const entries = Object.entries(obj).map(([key, value]) => {
+            let luaValue;
+            if (typeof value === 'string') {
+                luaValue = `"${value}"`;
+            }
+            else if (typeof value === 'boolean') {
+                luaValue = value ? 'true' : 'false';
+            }
+            else if (typeof value === 'number') {
+                luaValue = String(value);
+            }
+            else if (value === null || value === undefined) {
+                luaValue = 'nil';
+            }
+            else if (typeof value === 'object') {
+                luaValue = this.luaTableFromObject(value);
+            }
+            else {
+                luaValue = String(value);
+            }
+            return `${key} = ${luaValue}`;
+        });
+        return `{ ${entries.join(', ')} }`;
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createRobloxExporter() {
+    return new RobloxExporter();
+}
+
+export { RobloxExporter, createRobloxExporter };
+//# sourceMappingURL=RobloxExporter.js.map