@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/export/Tic80Exporter.js

@@ -0,0 +1,1315 @@
+'use strict';
+
+var PlatformExporter = require('./PlatformExporter.js');
+
+/* ────────────────────────────────────────────────────────────────
+   TIC-80 Exporter — Fantasy Computer Export
+   
+   Exports Nice2Dev projects to TIC-80 format:
+   - TIC cartridge file format (.tic)
+   - Support for Lua, JavaScript, and Moonscript
+   - Sprites, map, sound, music
+   
+   Specs:
+   - 240x136 pixels
+   - 16 colors palette
+   - 256 8x8 sprites
+   - Free and open source
+──────────────────────────────────────────────────────────────── */
+/* ── TIC-80 Constants ─────────────────────────────────────────── */
+const TIC80_PALETTE = [
+    '#1a1c2c', // 0 - dark purple
+    '#5d275d', // 1 - magenta
+    '#b13e53', // 2 - red
+    '#ef7d57', // 3 - orange
+    '#ffcd75', // 4 - yellow
+    '#a7f070', // 5 - lime
+    '#38b764', // 6 - green
+    '#257179', // 7 - teal
+    '#29366f', // 8 - dark blue
+    '#3b5dc9', // 9 - blue
+    '#41a6f6', // 10 - sky blue
+    '#73eff7', // 11 - cyan
+    '#f4f4f4', // 12 - white
+    '#94b0c2', // 13 - light gray
+    '#566c86', // 14 - gray
+    '#333c57', // 15 - dark gray
+];
+const TIC80_WIDTH = 240;
+const TIC80_HEIGHT = 136;
+/* ── Exporter Implementation ──────────────────────────────────── */
+class Tic80Exporter extends PlatformExporter.PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'tic80';
+        this.platformInfo = {
+            id: 'tic80',
+            name: 'TIC-80',
+            description: 'TIC-80 tiny computer - Free and open-source fantasy console',
+            website: 'https://tic80.com/',
+            features: ['2d-rendering', 'pixel-graphics', 'audio', 'music', 'retro', 'multi-language'],
+            supportedAssets: ['sprite', 'tilemap', 'audio', 'music'],
+            exportFormats: ['.tic', '.lua', '.js', '.moon'],
+        };
+    }
+    async doExport(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        const language = platformOpts.language ?? 'lua';
+        // Generate code based on language
+        let code;
+        let extension;
+        switch (language) {
+            case 'javascript':
+                code = this.generateJavaScriptCode(project, options);
+                extension = 'js';
+                break;
+            case 'moonscript':
+                code = this.generateMoonscriptCode(project, options);
+                extension = 'moon';
+                break;
+            case 'wren':
+                code = this.generateWrenCode(project, options);
+                extension = 'wren';
+                break;
+            case 'lua':
+            default:
+                code = this.generateLuaCode(project, options);
+                extension = 'lua';
+                break;
+        }
+        // Generate TIC file (text format - can be loaded in TIC-80)
+        await this.generateTicFile(project, code, language, options);
+        // Generate standalone source file
+        const safeName = (options.projectName ?? project.name)
+            .toLowerCase()
+            .replace(/[^a-z0-9_]/g, '_');
+        this.addTextFile(`${safeName}.${extension}`, code);
+        // Generate README
+        await this.generateReadme(project, options);
+    }
+    /* ── TIC File Generation ────────────────────────────────────── */
+    async generateTicFile(project, code, language, options) {
+        const safeName = (options.projectName ?? project.name)
+            .toLowerCase()
+            .replace(/[^a-z0-9_]/g, '_');
+        const platformOpts = options.platformOptions ?? {};
+        // TIC-80 uses a specific text format for .tic files
+        let ticContent = '';
+        // Metadata
+        ticContent += `-- title:   ${project.name}\n`;
+        ticContent += `-- author:  Nice2Dev Export\n`;
+        ticContent += `-- desc:    Generated from Nice2Dev v${project.version}\n`;
+        ticContent += `-- site:    https://nice2dev.com\n`;
+        ticContent += `-- license: MIT\n`;
+        ticContent += `-- version: ${project.version}\n`;
+        ticContent += `-- script:  ${language}\n`;
+        ticContent += '\n';
+        // Code section
+        ticContent += code;
+        ticContent += '\n';
+        // Sprites section (placeholder)
+        ticContent += this.generateSpritesSection(project);
+        ticContent += '\n';
+        // Map section
+        ticContent += this.generateMapSection(project);
+        ticContent += '\n';
+        // Waves section (sound waveforms)
+        ticContent += this.generateWavesSection(project, options);
+        ticContent += '\n';
+        // SFX section
+        if (platformOpts.sfxPlaceholders) {
+            ticContent += this.generateSfxSection(project);
+            ticContent += '\n';
+        }
+        // Music patterns
+        if (platformOpts.musicPatterns) {
+            ticContent += this.generateMusicSection(project);
+            ticContent += '\n';
+        }
+        // Palette section
+        ticContent += this.generatePaletteSection();
+        this.addTextFile(`${safeName}.tic`, ticContent);
+    }
+    /* ── Lua Code Generation ────────────────────────────────────── */
+    generateLuaCode(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        const lines = [];
+        // Game state
+        lines.push('-- Game State');
+        lines.push('local game = {');
+        lines.push('  t = 0,');
+        lines.push('  state = "play",');
+        lines.push('  cam = {x = 0, y = 0},');
+        lines.push('  entities = {},');
+        lines.push(`  debug = ${platformOpts.includeDebug ?? false}`);
+        lines.push('}');
+        lines.push('');
+        // Constants
+        lines.push('-- Constants');
+        lines.push(`local SCREEN_W = ${TIC80_WIDTH}`);
+        lines.push(`local SCREEN_H = ${TIC80_HEIGHT}`);
+        lines.push('');
+        // Core functions
+        lines.push(this.generateLuaCoreFunctions(project, options));
+        // Entity system
+        lines.push(this.generateLuaEntitySystem());
+        // Entity definitions
+        lines.push(this.generateLuaEntityDefinitions(project));
+        // Scene management
+        lines.push(this.generateLuaSceneManagement(project));
+        // Utilities
+        lines.push(this.generateLuaUtilities(platformOpts.includeDebug ?? false));
+        return lines.join('\n');
+    }
+    generateLuaCoreFunctions(project, options) {
+        const bgColor = this.getClosestTic80Color(project.scenes[0]?.background ?? '#1a1c2c');
+        return `
+-- Boot (called once)
+function BOOT()
+  -- Initialize
+  trace("${project.name} v${project.version}")
+  load_scene(1)
+end
+
+-- TIC (main loop, 60fps)
+function TIC()
+  game.t = game.t + 1
+  
+  if game.state == "play" then
+    -- Update
+    update_entities()
+    check_collisions()
+    cleanup_dead()
+    
+    -- Draw
+    cls(${bgColor})
+    draw_map()
+    draw_entities()
+    draw_ui()
+    
+    if game.debug then
+      draw_debug()
+    end
+  end
+end
+
+-- Called when scanline is drawn (for effects)
+function scanline(row)
+  -- Scanline effects here
+end
+
+-- Called before each line is drawn
+function BDR(row)
+  -- Border effects
+end
+
+-- Override palette (called on startup)
+function OVR()
+  -- Overlay/palette effects
+end
+
+-- Boot message
+function MENU(index)
+  if index == 0 then
+    trace("Restart")
+    BOOT()
+  end
+end
+`;
+    }
+    generateLuaEntitySystem() {
+        return `
+-- Entity System
+local entity_mt = {}
+entity_mt.__index = entity_mt
+
+function make_entity(type_name, x, y, props)
+  local e = setmetatable({
+    type = type_name,
+    x = x or 0,
+    y = y or 0,
+    dx = 0,
+    dy = 0,
+    w = 8,
+    h = 8,
+    spr = 0,
+    flip = 0,
+    scale = 1,
+    anim = {frames = {0}, speed = 0.1, t = 0, i = 1},
+    dead = false,
+    solid = false,
+    tags = {},
+  }, entity_mt)
+  
+  -- Apply custom properties
+  if props then
+    for k, v in pairs(props) do
+      e[k] = v
+    end
+  end
+  
+  -- Apply type defaults
+  if entity_types[type_name] then
+    local def = entity_types[type_name]
+    for k, v in pairs(def) do
+      if type(v) ~= "function" then
+        e[k] = v
+      end
+    end
+    if def.init then
+      def.init(e)
+    end
+  end
+  
+  table.insert(game.entities, e)
+  return e
+end
+
+function entity_mt:update()
+  -- Movement
+  self.x = self.x + self.dx
+  self.y = self.y + self.dy
+  
+  -- Friction
+  self.dx = self.dx * 0.9
+  self.dy = self.dy * 0.9
+  
+  -- Animation
+  if self.anim.speed > 0 then
+    self.anim.t = self.anim.t + self.anim.speed
+    if self.anim.t >= 1 then
+      self.anim.t = 0
+      self.anim.i = self.anim.i + 1
+      if self.anim.i > #self.anim.frames then
+        self.anim.i = 1
+      end
+      self.spr = self.anim.frames[self.anim.i]
+    end
+  end
+end
+
+function entity_mt:draw()
+  spr(self.spr, self.x - game.cam.x, self.y - game.cam.y, 0, self.scale, self.flip)
+end
+
+function entity_mt:has_tag(tag)
+  for _, t in ipairs(self.tags) do
+    if t == tag then return true end
+  end
+  return false
+end
+
+function entity_mt:kill()
+  self.dead = true
+end
+
+function update_entities()
+  for _, e in ipairs(game.entities) do
+    if not e.dead then
+      -- Call type-specific update
+      if entity_types[e.type] and entity_types[e.type].update then
+        entity_types[e.type].update(e)
+      else
+        e:update()
+      end
+    end
+  end
+end
+
+function draw_entities()
+  -- Sort by Y for proper layering
+  table.sort(game.entities, function(a, b) return a.y < b.y end)
+  
+  for _, e in ipairs(game.entities) do
+    if not e.dead then
+      -- Call type-specific draw
+      if entity_types[e.type] and entity_types[e.type].draw then
+        entity_types[e.type].draw(e)
+      else
+        e:draw()
+      end
+    end
+  end
+end
+
+function cleanup_dead()
+  for i = #game.entities, 1, -1 do
+    if game.entities[i].dead then
+      table.remove(game.entities, i)
+    end
+  end
+end
+
+function check_collisions()
+  for i = 1, #game.entities do
+    local a = game.entities[i]
+    if not a.dead and a.solid then
+      for j = i + 1, #game.entities do
+        local b = game.entities[j]
+        if not b.dead and b.solid then
+          if collides(a, b) then
+            if entity_types[a.type] and entity_types[a.type].on_collision then
+              entity_types[a.type].on_collision(a, b)
+            end
+            if entity_types[b.type] and entity_types[b.type].on_collision then
+              entity_types[b.type].on_collision(b, a)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+function collides(a, b)
+  return a.x < b.x + b.w and
+         a.x + a.w > b.x and
+         a.y < b.y + b.h and
+         a.y + a.h > b.y
+end
+`;
+    }
+    generateLuaEntityDefinitions(project) {
+        const lines = [];
+        lines.push('');
+        lines.push('-- Entity Type Definitions');
+        lines.push('entity_types = {}');
+        lines.push('');
+        // Gather all entity types
+        const entityTypes = new Map();
+        for (const prefab of project.prefabs) {
+            entityTypes.set(prefab.name.toLowerCase().replace(/[^a-z0-9_]/g, '_'), prefab.entity);
+        }
+        for (const scene of project.scenes) {
+            for (const entity of scene.entities) {
+                const typeName = (entity.name ?? entity.id).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+                if (!entityTypes.has(typeName)) {
+                    entityTypes.set(typeName, entity);
+                }
+            }
+        }
+        for (const [typeName, entity] of entityTypes) {
+            lines.push(this.entityTypeToLuaDef(typeName, entity));
+        }
+        return lines.join('\n');
+    }
+    entityTypeToLuaDef(typeName, entity) {
+        const tags = entity.tags ?? [];
+        const hasPhysics = entity.components.some((c) => c.type === 'rigidbody');
+        const sprIndex = this.getEntitySpriteIndex(entity);
+        const speed = this.getComponentProperty(entity, 'movement', 'speed', 50) / 50;
+        return `entity_types["${typeName}"] = {
+  spr = ${sprIndex},
+  w = 8,
+  h = 8,
+  solid = ${hasPhysics},
+  tags = {${tags.map((t) => `"${t}"`).join(', ')}},
+  speed = ${speed},
+  hp = ${this.getComponentProperty(entity, 'health', 'max', 3)},
+  
+  init = function(self)
+    -- Custom initialization
+  end,
+  
+  update = function(self)
+    -- Custom update logic
+    self:update()
+  end,
+  
+  draw = function(self)
+    self:draw()
+  end,
+  
+  on_collision = function(self, other)
+    -- Collision handling
+  end,
+}
+
+`;
+    }
+    getEntitySpriteIndex(entity) {
+        const name = (entity.name ?? 'entity').toLowerCase();
+        if (name.includes('player')) {
+            return 1;
+        }
+        if (name.includes('enemy')) {
+            return 17;
+        }
+        if (name.includes('item')) {
+            return 33;
+        }
+        if (name.includes('bullet')) {
+            return 49;
+        }
+        return 0;
+    }
+    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;
+    }
+    generateLuaSceneManagement(project) {
+        const lines = [];
+        lines.push('');
+        lines.push('-- Scenes');
+        lines.push('local scenes = {}');
+        lines.push('');
+        for (let i = 0; i < project.scenes.length; i++) {
+            const scene = project.scenes[i];
+            const sceneName = scene.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+            lines.push(`scenes[${i + 1}] = {`);
+            lines.push(`  name = "${sceneName}",`);
+            lines.push(`  entities = {`);
+            for (const entity of scene.entities) {
+                const typeName = (entity.name ?? entity.id).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+                const pos = entity.position ?? { x: 0, y: 0 };
+                // Scale position for TIC-80 (240x136)
+                const x = Math.floor((pos.x / project.settings.resolution.width) * TIC80_WIDTH);
+                const y = Math.floor((pos.y / project.settings.resolution.height) * TIC80_HEIGHT);
+                lines.push(`    {type = "${typeName}", x = ${x}, y = ${y}},`);
+            }
+            lines.push(`  }`);
+            lines.push(`}`);
+            lines.push('');
+        }
+        lines.push(`function load_scene(index)
+  game.entities = {}
+  local scene = scenes[index]
+  if scene then
+    for _, e in ipairs(scene.entities) do
+      make_entity(e.type, e.x, e.y)
+    end
+    trace("Loaded scene: " .. scene.name)
+  end
+end
+`);
+        return lines.join('\n');
+    }
+    generateLuaUtilities(includeDebug) {
+        let code = `
+-- Utilities
+function lerp(a, b, t)
+  return a + (b - a) * math.max(0, math.min(1, t))
+end
+
+function dist(x1, y1, x2, y2)
+  local dx = x2 - x1
+  local dy = y2 - y1
+  return math.sqrt(dx * dx + dy * dy)
+end
+
+function clamp(v, min, max)
+  return math.max(min, math.min(max, v))
+end
+
+function sign(v)
+  return v > 0 and 1 or v < 0 and -1 or 0
+end
+
+function draw_map()
+  map(0, 0, 30, 17, 0, 0, 0)
+end
+
+function draw_ui()
+  -- HUD
+  print("Nice2Dev", 2, 2, 12)
+end
+
+function spawn_particle(x, y, color)
+  make_entity("particle", x, y, {
+    spr = -1,
+    dx = math.random() * 2 - 1,
+    dy = math.random() * 2 - 1,
+    c = color,
+    life = 15 + math.random(10),
+    draw = function(self)
+      pix(self.x, self.y, self.c)
+    end,
+    update = function(self)
+      self.x = self.x + self.dx
+      self.y = self.y + self.dy
+      self.dy = self.dy + 0.1
+      self.life = self.life - 1
+      if self.life <= 0 then
+        self.dead = true
+      end
+    end,
+  })
+end
+
+-- Particle pseudo-type
+entity_types["particle"] = {
+  spr = -1,
+  solid = false,
+}
+`;
+        if (includeDebug) {
+            code += `
+function draw_debug()
+  local mem = pmem(0) or 0
+  local fps = 60
+  
+  rect(0, 0, 80, 16, 0)
+  print("fps:" .. fps, 2, 2, 12)
+  print("ent:" .. #game.entities, 2, 9, 12)
+  
+  -- Draw hitboxes
+  for _, e in ipairs(game.entities) do
+    if e.solid then
+      rectb(e.x - game.cam.x, e.y - game.cam.y, e.w, e.h, 2)
+    end
+  end
+end
+`;
+        }
+        else {
+            code += `
+function draw_debug()
+  -- Debug disabled
+end
+`;
+        }
+        return code;
+    }
+    /* ── JavaScript Code Generation ─────────────────────────────── */
+    generateJavaScriptCode(project, options) {
+        const lines = [];
+        lines.push(`// ${project.name} - TIC-80 JavaScript`);
+        lines.push('// Generated from Nice2Dev');
+        lines.push('');
+        // Game state
+        lines.push('// Game State');
+        lines.push('var game = {');
+        lines.push('  t: 0,');
+        lines.push('  state: "play",');
+        lines.push('  cam: {x: 0, y: 0},');
+        lines.push('  entities: [],');
+        lines.push(`  debug: ${options.platformOptions?.includeDebug ?? false}`);
+        lines.push('};');
+        lines.push('');
+        // Core functions
+        lines.push(`
+// Boot
+function BOOT() {
+  trace("${project.name} v${project.version}");
+  loadScene(1);
+}
+
+// Main loop
+function TIC() {
+  game.t++;
+  
+  if (game.state === "play") {
+    updateEntities();
+    checkCollisions();
+    cleanupDead();
+    
+    cls(0);
+    drawMap();
+    drawEntities();
+    drawUI();
+    
+    if (game.debug) {
+      drawDebug();
+    }
+  }
+}
+
+// Entity functions
+function makeEntity(typeName, x, y, props) {
+  var e = {
+    type: typeName,
+    x: x || 0,
+    y: y || 0,
+    dx: 0,
+    dy: 0,
+    w: 8,
+    h: 8,
+    spr: 0,
+    flip: 0,
+    dead: false,
+    solid: false,
+    tags: []
+  };
+  
+  // Apply type defaults
+  var def = entityTypes[typeName];
+  if (def) {
+    for (var k in def) {
+      if (typeof def[k] !== 'function') {
+        e[k] = def[k];
+      }
+    }
+    if (def.init) def.init(e);
+  }
+  
+  // Apply custom props
+  if (props) {
+    for (var k in props) {
+      e[k] = props[k];
+    }
+  }
+  
+  game.entities.push(e);
+  return e;
+}
+
+function updateEntities() {
+  game.entities.forEach(function(e) {
+    if (!e.dead) {
+      var def = entityTypes[e.type];
+      if (def && def.update) {
+        def.update(e);
+      } else {
+        // Default update
+        e.x += e.dx;
+        e.y += e.dy;
+        e.dx *= 0.9;
+        e.dy *= 0.9;
+      }
+    }
+  });
+}
+
+function drawEntities() {
+  // Sort by Y
+  game.entities.sort(function(a, b) { return a.y - b.y; });
+  
+  game.entities.forEach(function(e) {
+    if (!e.dead) {
+      var def = entityTypes[e.type];
+      if (def && def.draw) {
+        def.draw(e);
+      } else {
+        spr(e.spr, e.x - game.cam.x, e.y - game.cam.y, 0, 1, e.flip);
+      }
+    }
+  });
+}
+
+function cleanupDead() {
+  game.entities = game.entities.filter(function(e) { return !e.dead; });
+}
+
+function checkCollisions() {
+  for (var i = 0; i < game.entities.length; i++) {
+    var a = game.entities[i];
+    if (!a.dead && a.solid) {
+      for (var j = i + 1; j < game.entities.length; j++) {
+        var b = game.entities[j];
+        if (!b.dead && b.solid && collides(a, b)) {
+          var defA = entityTypes[a.type];
+          var defB = entityTypes[b.type];
+          if (defA && defA.onCollision) defA.onCollision(a, b);
+          if (defB && defB.onCollision) defB.onCollision(b, a);
+        }
+      }
+    }
+  }
+}
+
+function collides(a, b) {
+  return a.x < b.x + b.w &&
+         a.x + a.w > b.x &&
+         a.y < b.y + b.h &&
+         a.y + a.h > b.y;
+}
+
+function drawMap() {
+  map(0, 0, 30, 17, 0, 0, 0);
+}
+
+function drawUI() {
+  print("Nice2Dev", 2, 2, 12);
+}
+
+function drawDebug() {
+  rect(0, 0, 80, 16, 0);
+  print("ent:" + game.entities.length, 2, 2, 12);
+}
+`);
+        // Entity types
+        lines.push('// Entity Types');
+        lines.push('var entityTypes = {};');
+        lines.push('');
+        // Scenes
+        lines.push('// Scenes');
+        lines.push('var scenes = [');
+        for (const scene of project.scenes) {
+            const sceneName = scene.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+            lines.push(`  {`);
+            lines.push(`    name: "${sceneName}",`);
+            lines.push(`    entities: [`);
+            for (const entity of scene.entities) {
+                const typeName = (entity.name ?? entity.id).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+                const pos = entity.position ?? { x: 0, y: 0 };
+                const x = Math.floor((pos.x / project.settings.resolution.width) * TIC80_WIDTH);
+                const y = Math.floor((pos.y / project.settings.resolution.height) * TIC80_HEIGHT);
+                lines.push(`      {type: "${typeName}", x: ${x}, y: ${y}},`);
+            }
+            lines.push(`    ]`);
+            lines.push(`  },`);
+        }
+        lines.push('];');
+        lines.push('');
+        lines.push(`
+function loadScene(index) {
+  game.entities = [];
+  var scene = scenes[index - 1];
+  if (scene) {
+    scene.entities.forEach(function(e) {
+      makeEntity(e.type, e.x, e.y);
+    });
+    trace("Loaded scene: " + scene.name);
+  }
+}
+`);
+        return lines.join('\n');
+    }
+    /* ── Moonscript Code Generation ─────────────────────────────── */
+    generateMoonscriptCode(project, options) {
+        const lines = [];
+        lines.push(`-- ${project.name} - TIC-80 Moonscript`);
+        lines.push('-- Generated from Nice2Dev');
+        lines.push('');
+        lines.push(`
+-- Game State
+export game = {
+  t: 0
+  state: "play"
+  cam: {x: 0, y: 0}
+  entities: {}
+  debug: ${options.platformOptions?.includeDebug ?? false}
+}
+
+-- Constants
+SCREEN_W = ${TIC80_WIDTH}
+SCREEN_H = ${TIC80_HEIGHT}
+
+-- Boot
+export BOOT = ->
+  trace "${project.name} v${project.version}"
+  load_scene 1
+
+-- Main Loop
+export TIC = ->
+  game.t += 1
+  
+  if game.state == "play"
+    update_entities!
+    check_collisions!
+    cleanup_dead!
+    
+    cls 0
+    draw_map!
+    draw_entities!
+    draw_ui!
+    
+    draw_debug! if game.debug
+
+-- Entity System
+entity_types = {}
+
+make_entity = (type_name, x, y, props) ->
+  e = {
+    type: type_name
+    x: x or 0
+    y: y or 0
+    dx: 0
+    dy: 0
+    w: 8
+    h: 8
+    spr: 0
+    flip: 0
+    dead: false
+    solid: false
+    tags: {}
+  }
+  
+  -- Apply type defaults
+  if entity_types[type_name]
+    def = entity_types[type_name]
+    for k, v in pairs def
+      e[k] = v if type(v) != "function"
+    def.init(e) if def.init
+  
+  -- Apply props
+  if props
+    for k, v in pairs props
+      e[k] = v
+  
+  table.insert game.entities, e
+  e
+
+update_entities = ->
+  for e in *game.entities
+    unless e.dead
+      def = entity_types[e.type]
+      if def and def.update
+        def.update e
+      else
+        e.x += e.dx
+        e.y += e.dy
+        e.dx *= 0.9
+        e.dy *= 0.9
+
+draw_entities = ->
+  table.sort game.entities, (a, b) -> a.y < b.y
+  for e in *game.entities
+    unless e.dead
+      def = entity_types[e.type]
+      if def and def.draw
+        def.draw e
+      else
+        spr e.spr, e.x - game.cam.x, e.y - game.cam.y, 0, 1, e.flip
+
+cleanup_dead = ->
+  for i = #game.entities, 1, -1
+    table.remove game.entities, i if game.entities[i].dead
+
+check_collisions = ->
+  for i = 1, #game.entities
+    a = game.entities[i]
+    if not a.dead and a.solid
+      for j = i + 1, #game.entities
+        b = game.entities[j]
+        if not b.dead and b.solid and collides(a, b)
+          def_a = entity_types[a.type]
+          def_b = entity_types[b.type]
+          def_a.on_collision(a, b) if def_a and def_a.on_collision
+          def_b.on_collision(b, a) if def_b and def_b.on_collision
+
+collides = (a, b) ->
+  a.x < b.x + b.w and
+  a.x + a.w > b.x and
+  a.y < b.y + b.h and
+  a.y + a.h > b.y
+
+-- Scenes
+scenes = {
+${project.scenes
+            .map((scene, i) => {
+            const sceneName = scene.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+            return `  {
+    name: "${sceneName}"
+    entities: {
+${scene.entities
+                .map((entity) => {
+                const typeName = (entity.name ?? entity.id).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+                const pos = entity.position ?? { x: 0, y: 0 };
+                const x = Math.floor((pos.x / project.settings.resolution.width) * TIC80_WIDTH);
+                const y = Math.floor((pos.y / project.settings.resolution.height) * TIC80_HEIGHT);
+                return `      {type: "${typeName}", x: ${x}, y: ${y}}`;
+            })
+                .join('\n')}
+    }
+  }`;
+        })
+            .join('\n')}
+}
+
+load_scene = (index) ->
+  game.entities = {}
+  scene = scenes[index]
+  if scene
+    for e in *scene.entities
+      make_entity e.type, e.x, e.y
+    trace "Loaded scene: " .. scene.name
+
+-- Utilities
+draw_map = -> map 0, 0, 30, 17, 0, 0, 0
+draw_ui = -> print "Nice2Dev", 2, 2, 12
+draw_debug = ->
+  rect 0, 0, 80, 16, 0
+  print "ent:" .. #game.entities, 2, 2, 12
+`);
+        return lines.join('\n');
+    }
+    /* ── Wren Code Generation ───────────────────────────────────── */
+    generateWrenCode(project, options) {
+        return `// ${project.name} - TIC-80 Wren
+// Generated from Nice2Dev
+
+class Game {
+  static t { __t }
+  static t=(v) { __t = v }
+  static state { __state }
+  static state=(v) { __state = v }
+  static entities { __entities }
+  static entities=(v) { __entities = v }
+  
+  static init() {
+    __t = 0
+    __state = "play"
+    __entities = []
+  }
+}
+
+class TIC {
+  static BOOT() {
+    TIC.trace("${project.name} v${project.version}")
+    Game.init()
+    SceneManager.loadScene(1)
+  }
+  
+  static TIC() {
+    Game.t = Game.t + 1
+    
+    if (Game.state == "play") {
+      EntityManager.update()
+      EntityManager.draw()
+      UI.draw()
+    }
+  }
+}
+
+class EntityManager {
+  static update() {
+    for (entity in Game.entities) {
+      if (!entity.dead) {
+        entity.update()
+      }
+    }
+    // Cleanup dead
+    Game.entities = Game.entities.where { |e| !e.dead }.toList
+  }
+  
+  static draw() {
+    Game.entities.sort { |a, b| a.y < b.y }
+    for (entity in Game.entities) {
+      if (!entity.dead) {
+        entity.draw()
+      }
+    }
+  }
+}
+
+class Entity {
+  x { _x }
+  x=(v) { _x = v }
+  y { _y }
+  y=(v) { _y = v }
+  dead { _dead }
+  dead=(v) { _dead = v }
+  spr { _spr }
+  
+  construct new(x, y, spr) {
+    _x = x
+    _y = y
+    _spr = spr
+    _dead = false
+  }
+  
+  update() {
+    // Override in subclass
+  }
+  
+  draw() {
+    TIC.spr(_spr, _x, _y)
+  }
+  
+  kill() {
+    _dead = true
+  }
+}
+
+class SceneManager {
+  static scenes { [
+${project.scenes
+            .map((scene) => {
+            const sceneName = scene.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+            return `    Scene.new("${sceneName}", [
+${scene.entities
+                .map((entity) => {
+                const pos = entity.position ?? { x: 0, y: 0 };
+                const x = Math.floor((pos.x / project.settings.resolution.width) * TIC80_WIDTH);
+                const y = Math.floor((pos.y / project.settings.resolution.height) * TIC80_HEIGHT);
+                return `      [${x}, ${y}, 1]`;
+            })
+                .join(',\n')}
+    ])`;
+        })
+            .join(',\n')}
+  ] }
+  
+  static loadScene(index) {
+    Game.entities = []
+    var scene = scenes[index - 1]
+    if (scene != null) {
+      for (data in scene.entities) {
+        Game.entities.add(Entity.new(data[0], data[1], data[2]))
+      }
+      TIC.trace("Loaded: %(scene.name)")
+    }
+  }
+}
+
+class Scene {
+  name { _name }
+  entities { _entities }
+  
+  construct new(name, entities) {
+    _name = name
+    _entities = entities
+  }
+}
+
+class UI {
+  static draw() {
+    TIC.print("Nice2Dev", 2, 2, 12)
+  }
+}
+`;
+    }
+    /* ── Data Sections ──────────────────────────────────────────── */
+    generateSpritesSection(project) {
+        // TIC-80 sprites: each line represents 8 pixels (1 byte = 2 pixels)
+        // 256 sprites in 16x16 grid = 128x128 pixels
+        const lines = [];
+        lines.push('-- <TILES>');
+        // Generate basic placeholder sprites
+        for (let sprRow = 0; sprRow < 16; sprRow++) {
+            for (let py = 0; py < 8; py++) {
+                let line = '-- ';
+                for (let sprCol = 0; sprCol < 16; sprCol++) {
+                    const sprIndex = sprRow * 16 + sprCol;
+                    for (let px = 0; px < 8; px++) {
+                        let pixel = 0;
+                        // Sprite 1: Player
+                        if (sprIndex === 1) {
+                            if (py >= 1 && py <= 6 && px >= 1 && px <= 6) {
+                                pixel =
+                                    py === 2 && (px === 2 || px === 5)
+                                        ? 9 // eyes
+                                        : py === 4 && px >= 2 && px <= 5
+                                            ? 2 // mouth
+                                            : 4; // body
+                            }
+                        }
+                        // Sprite 17: Enemy
+                        else if (sprIndex === 17) {
+                            if (py >= 1 && py <= 6 && px >= 1 && px <= 6) {
+                                pixel = 2; // red
+                                if (py === 2 && (px === 2 || px === 5)) {
+                                    pixel = 12;
+                                } // eyes
+                            }
+                        }
+                        // Sprite 33: Item
+                        else if (sprIndex === 33) {
+                            if (px >= 2 && px <= 5 && py >= 1 && py <= 6) {
+                                pixel = 4;
+                            } // yellow
+                            if (py >= 2 && py <= 5 && (px === 1 || px === 6)) {
+                                pixel = 4;
+                            }
+                            if (px >= 3 && px <= 4 && py >= 3 && py <= 4) {
+                                pixel = 3;
+                            } // orange center
+                        }
+                        line += pixel.toString(16);
+                    }
+                }
+                lines.push(line);
+            }
+        }
+        lines.push('-- </TILES>');
+        return lines.join('\n');
+    }
+    generateMapSection(project) {
+        const lines = [];
+        lines.push('-- <MAP>');
+        // 240x136 / 8 = 30x17 tiles
+        for (let y = 0; y < 136; y++) {
+            let line = '-- ';
+            for (let x = 0; x < 240; x++) {
+                line += '0';
+            }
+            lines.push(line);
+        }
+        lines.push('-- </MAP>');
+        return lines.join('\n');
+    }
+    generateWavesSection(project, options) {
+        return `-- <WAVES>
+-- 000:00000000ffffffff00000000ffffffff
+-- 001:0123456789abcdeffedcba9876543210
+-- 002:0123456789abcdef0123456789abcdef
+-- 003:fedcba9876543210fedcba9876543210
+-- </WAVES>`;
+    }
+    generateSfxSection(project) {
+        return `-- <SFX>
+-- 000:000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000304000000000
+-- </SFX>`;
+    }
+    generateMusicSection(project) {
+        return `-- <PATTERNS>
+-- 000:400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+-- </PATTERNS>
+
+-- <TRACKS>
+-- 000:180000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+-- </TRACKS>`;
+    }
+    generatePaletteSection() {
+        return `-- <PALETTE>
+-- 000:1a1c2c5d275db13e53ef7d57ffcd75a7f07038b764257179293 66f3b5dc941a6f673eff7f4f4f494b0c2566c86333c57
+-- </PALETTE>`;
+    }
+    /* ── Color Utility ──────────────────────────────────────────── */
+    getClosestTic80Color(hex) {
+        const cleanHex = hex.replace('#', '').toLowerCase();
+        const r = parseInt(cleanHex.substring(0, 2), 16);
+        const g = parseInt(cleanHex.substring(2, 4), 16);
+        const b = parseInt(cleanHex.substring(4, 6), 16);
+        let closestIndex = 0;
+        let closestDist = Infinity;
+        for (let i = 0; i < TIC80_PALETTE.length; i++) {
+            const palHex = TIC80_PALETTE[i].replace('#', '');
+            const pr = parseInt(palHex.substring(0, 2), 16);
+            const pg = parseInt(palHex.substring(2, 4), 16);
+            const pb = parseInt(palHex.substring(4, 6), 16);
+            const dist = Math.sqrt(Math.pow(r - pr, 2) + Math.pow(g - pg, 2) + Math.pow(b - pb, 2));
+            if (dist < closestDist) {
+                closestDist = dist;
+                closestIndex = i;
+            }
+        }
+        return closestIndex;
+    }
+    /* ── README ─────────────────────────────────────────────────── */
+    async generateReadme(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        const language = platformOpts.language ?? 'lua';
+        const safeName = (options.projectName ?? project.name)
+            .toLowerCase()
+            .replace(/[^a-z0-9_]/g, '_');
+        const readme = `# ${project.name} - TIC-80 Export
+
+Generated from Nice2Dev project v${project.version}
+
+## Requirements
+
+- TIC-80 (Free: https://tic80.com/)
+
+## Installation
+
+### Method 1: Load TIC file
+1. Open TIC-80
+2. Type: \`load ${safeName}\`
+3. Press F5 or type \`run\`
+
+### Method 2: Copy source
+1. Open TIC-80
+2. Press Escape to open code editor
+3. Copy contents of \`${safeName}.${language === 'javascript' ? 'js' : language === 'moonscript' ? 'moon' : language === 'wren' ? 'wren' : 'lua'}\`
+4. Paste into editor
+5. Press F5 to run
+
+## Files
+
+- \`${safeName}.tic\` - TIC-80 cartridge (includes sprites, map, sfx)
+- \`${safeName}.${language === 'javascript' ? 'js' : language === 'moonscript' ? 'moon' : language === 'wren' ? 'wren' : 'lua'}\` - Source code
+
+## TIC-80 Specs
+
+- **Display**: 240x136 pixels
+- **Colors**: 16 color palette
+- **Sprites**: 256 8x8 sprites
+- **Map**: 240x136 tile map
+- **Sound**: 4 channels, 64 SFX
+- **Music**: 8 tracks, 64 patterns
+- **Languages**: Lua, Moonscript, JavaScript, Wren, Fennel, Squirrel
+
+## Controls
+
+- Arrow Keys: D-Pad
+- Z / A / J: A button
+- X / S / K: B button
+- Enter: Start
+- Escape: Menu
+
+## Code Structure (${language})
+
+${language === 'lua'
+            ? `\`\`\`lua
+function BOOT()  -- Called once at startup
+function TIC()   -- Called every frame (60 FPS)
+function BDR()   -- Called before each scanline
+function OVR()   -- Called after frame for overlays
+\`\`\`
+`
+            : language === 'javascript'
+                ? `\`\`\`javascript
+function BOOT() { }  // Called once at startup
+function TIC() { }   // Called every frame (60 FPS)
+function BDR() { }   // Called before each scanline
+\`\`\`
+`
+                : language === 'moonscript'
+                    ? `\`\`\`moonscript
+export BOOT = ->  -- Called once at startup
+export TIC = ->   -- Called every frame (60 FPS)
+export BDR = ->   -- Called before each scanline
+\`\`\`
+`
+                    : `\`\`\`wren
+class TIC {
+  static BOOT() { }  // Called once at startup
+  static TIC() { }   // Called every frame (60 FPS)
+}
+\`\`\`
+`}
+
+## Scenes
+
+${project.scenes.map((s, i) => `- Scene ${i + 1}: ${s.name} (${s.entities.length} entities)`).join('\n')}
+
+Load scene: \`load_scene(1)\`
+
+## Useful TIC-80 Functions
+
+\`\`\`
+cls(color)           - Clear screen
+spr(id, x, y)        - Draw sprite
+map(x, y, w, h)      - Draw map
+print(text, x, y, c) - Print text
+btn(id)              - Check button
+sfx(id)              - Play sound
+music(track)         - Play music
+pix(x, y, c)         - Draw pixel
+rect(x, y, w, h, c)  - Draw rectangle
+trace(msg)           - Debug print
+\`\`\`
+
+## Debug Mode
+
+${platformOpts.includeDebug ? 'Debug mode is enabled. Shows entity count and hitboxes.' : 'Debug mode is disabled. Set `game.debug = true` to enable.'}
+
+## Resources
+
+- TIC-80 Wiki: https://github.com/nesbox/TIC-80/wiki
+- TIC-80 API: https://github.com/nesbox/TIC-80/wiki/API
+- TIC-80 Community: https://tic80.com/play
+
+## Export Formats
+
+TIC-80 can export to:
+- HTML (Web)
+- Native executables
+- .tic cartridge
+`;
+        this.addTextFile('README.md', readme);
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createTic80Exporter() {
+    return new Tic80Exporter();
+}
+
+exports.Tic80Exporter = Tic80Exporter;
+exports.createTic80Exporter = createTic80Exporter;
+//# sourceMappingURL=Tic80Exporter.js.map