exportArduino.js

(function () {
  "use strict";

  function arduinoDisplayFoundation() {
    return [
      "#include <SPI.h>",
      "",
      "// SevenSeg Quest Maker display foundation",
      "// Target: Arduino Nano / ATmega328P",
      "// Hardware SPI: MOSI = D11, SCK = D13, CS/LOAD = D10",
      "// Display: 3 daisy chained MAX7219 chips, each driving one 8-digit row.",
      "// Logical display: 8 columns x 3 rows, cell index = y * 8 + x.",
      "",
      "const uint8_t MAX_CS = 10;",
      "const uint8_t DISPLAY_COLS = 8;",
      "const uint8_t DISPLAY_ROWS = 3;",
      "const uint8_t DISPLAY_CELLS = 24;",
      "const uint8_t MAX7219_COUNT = 3;",
      "",
      "const uint8_t MAX7219_NOOP = 0x00;",
      "const uint8_t MAX7219_DIGIT0 = 0x01;",
      "const uint8_t MAX7219_DECODE_MODE = 0x09;",
      "const uint8_t MAX7219_INTENSITY = 0x0A;",
      "const uint8_t MAX7219_SCAN_LIMIT = 0x0B;",
      "const uint8_t MAX7219_SHUTDOWN = 0x0C;",
      "const uint8_t MAX7219_DISPLAY_TEST = 0x0F;",
      "",
      "// Official beta hardware: A0 BrightnessPot controls MAX7219 intensity 0..15.",
      "const uint8_t DISPLAY_BRIGHTNESS_POT_PIN = A0;",
      "uint8_t lastDisplayBrightness = 255;",
      "",
      "// Hardware mapping switches.",
      "// This default follows the working 003_animation sketch: Module 1 is sent last.",
      "const bool MIRROR_DIGIT_X = true;",
      "const bool ROW_0_IS_CLOSEST_MODULE = true;",
      "",
      "uint8_t cellIndex(uint8_t x, uint8_t y) {",
      "  return y * DISPLAY_COLS + x;",
      "}",
      "",
      "void maxTransfer(uint8_t chipIndex, uint8_t registerAddress, uint8_t data) {",
      "  if (chipIndex >= MAX7219_COUNT) {",
      "    return;",
      "  }",
      "",
      "  digitalWrite(MAX_CS, LOW);",
      "",
      "  // MAX7219 daisy chain rule: send farthest module first, closest module last.",
      "  // The working animation sketch sends Module 3, then Module 2, then Module 1.",
      "  for (uint8_t slot = 0; slot < MAX7219_COUNT; slot++) {",
      "    uint8_t chip = ROW_0_IS_CLOSEST_MODULE ? (MAX7219_COUNT - 1 - slot) : slot;",
      "    if (chip == chipIndex) {",
      "      SPI.transfer(registerAddress);",
      "      SPI.transfer(data);",
      "    } else {",
      "      SPI.transfer(MAX7219_NOOP);",
      "      SPI.transfer(0x00);",
      "    }",
      "  }",
      "",
      "  digitalWrite(MAX_CS, HIGH);",
      "}",
      "",
      "void maxAll(uint8_t registerAddress, uint8_t data) {",
      "  digitalWrite(MAX_CS, LOW);",
      "",
      "  for (uint8_t chip = 0; chip < MAX7219_COUNT; chip++) {",
      "    SPI.transfer(registerAddress);",
      "    SPI.transfer(data);",
      "  }",
      "",
      "  digitalWrite(MAX_CS, HIGH);",
      "}",
      "",
      "uint8_t readDisplayBrightness() {",
      "  uint8_t brightness = analogRead(DISPLAY_BRIGHTNESS_POT_PIN) / 64;",
      "  if (brightness > 15) {",
      "    brightness = 15;",
      "  }",
      "  return brightness;",
      "}",
      "",
      "void updateDisplayBrightness() {",
      "  uint8_t brightness = readDisplayBrightness();",
      "  if (brightness != lastDisplayBrightness) {",
      "    lastDisplayBrightness = brightness;",
      "    maxAll(MAX7219_INTENSITY, brightness);",
      "  }",
      "}",
      "",
      "void clearDisplay() {",
      "  for (uint8_t digit = 0; digit < DISPLAY_COLS; digit++) {",
      "    maxAll(MAX7219_DIGIT0 + digit, 0x00);",
      "  }",
      "}",
      "",
      "void initDisplay() {",
      "  pinMode(MAX_CS, OUTPUT);",
      "  pinMode(DISPLAY_BRIGHTNESS_POT_PIN, INPUT);",
      "  digitalWrite(MAX_CS, HIGH);",
      "",
      "  SPI.begin();",
      "  SPI.setBitOrder(MSBFIRST);",
      "",
      "  maxAll(MAX7219_DISPLAY_TEST, 0x00);",
      "  maxAll(MAX7219_SHUTDOWN, 0x01);",
      "  maxAll(MAX7219_DECODE_MODE, 0x00);",
      "  maxAll(MAX7219_SCAN_LIMIT, 0x07);",
      "  updateDisplayBrightness();",
      "  clearDisplay();",
      "}",
      "",
      "void setRawDigit(uint8_t index, uint8_t segments) {",
      "  if (index >= DISPLAY_CELLS) {",
      "    return;",
      "  }",
      "",
      "  uint8_t y = index / DISPLAY_COLS;",
      "  uint8_t x = index % DISPLAY_COLS;",
      "  uint8_t chipIndex = y;",
      "  uint8_t digitX = MIRROR_DIGIT_X ? (DISPLAY_COLS - 1 - x) : x;",
      "  uint8_t digitRegister = MAX7219_DIGIT0 + digitX;",
      "",
      "  // If digits appear mirrored left-to-right, set MIRROR_DIGIT_X to true.",
      "  // If rows appear upside down, set ROW_0_IS_CLOSEST_MODULE to false.",
      "  maxTransfer(chipIndex, digitRegister, segments);",
      "}",
      "",
      "void setCell(uint8_t x, uint8_t y, uint8_t segments) {",
      "  if (x >= DISPLAY_COLS || y >= DISPLAY_ROWS) {",
      "    return;",
      "  }",
      "",
      "  setRawDigit(cellIndex(x, y), segments);",
      "}",
      "",
      "void renderFrameRaw24(const uint8_t frame[DISPLAY_CELLS]) {",
      "  for (uint8_t index = 0; index < DISPLAY_CELLS; index++) {",
      "    setRawDigit(index, frame[index]);",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function cStringLiteral(text) {
    return String(text || "")
      .replace(/\\/g, "\\\\")
      .replace(/"/g, '\\"')
      .replace(/\r/g, "\\r")
      .replace(/\n/g, "\\n");
  }

  function hexByte(value) {
    return "0x" + Math.max(0, Math.min(255, Math.round(Number(value) || 0)))
      .toString(16)
      .toUpperCase()
      .padStart(2, "0");
  }

  function textGlyphsForProject(project) {
    var model = window.SevenSegModel;
    var safeProject = project || model.defaultProject || {};

    if (model && typeof model.normalizeTextGlyphs === "function") {
      return model.normalizeTextGlyphs(safeProject);
    }

    return {
      " ": 0x00,
      "0": 0x7E,
      "1": 0x30,
      "2": 0x6D,
      "3": 0x79,
      "4": 0x33,
      "5": 0x5B,
      "6": 0x5F,
      "7": 0x70,
      "8": 0x7F,
      "9": 0x7B
    };
  }

  function generateTextTestIno(text, project) {
    var model = window.SevenSegModel;
    var normalizedText = model.normalizeFrame24(text);

    return [
      arduinoDisplayFoundation(),
      arduinoSegmentForCharFunction(project),
      "const char startingText[DISPLAY_CELLS + 1] = \"" + cStringLiteral(normalizedText) + "\";",
      "char serialText[DISPLAY_CELLS + 1];",
      "uint8_t serialTextIndex = 0;",
      "",
      "void renderText24(const char text[]) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "",
      "  for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "    char c = text[i];",
      "    if (c == '\\0') {",
      "      c = ' ';",
      "    }",
      "    frame[i] = segmentForChar(c);",
      "  }",
      "",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void finishSerialText() {",
      "  if (serialTextIndex == 0) {",
      "    return;",
      "  }",
      "",
      "  while (serialTextIndex < DISPLAY_CELLS) {",
      "    serialText[serialTextIndex] = ' ';",
      "    serialTextIndex++;",
      "  }",
      "",
      "  serialText[DISPLAY_CELLS] = '\\0';",
      "  renderText24(serialText);",
      "  Serial.print(F(\"Display text: \"));",
      "  Serial.println(serialText);",
      "  serialTextIndex = 0;",
      "}",
      "",
      "void readSerialText() {",
      "  while (Serial.available() > 0) {",
      "    char c = (char)Serial.read();",
      "",
      "    if (c == '\\r' || c == '\\n') {",
      "      finishSerialText();",
      "    } else if (serialTextIndex < DISPLAY_CELLS) {",
      "      serialText[serialTextIndex] = c;",
      "      serialTextIndex++;",
      "    }",
      "  }",
      "}",
      "",
      "void setup() {",
      "  Serial.begin(9600);",
      "  initDisplay();",
      "  renderText24(startingText);",
      "  Serial.println(F(\"SevenSeg Text Test ready. Type 1-24 characters and press Enter.\"));",
      "}",
      "",
      "void loop() {",
      "  updateDisplayBrightness();",
      "  readSerialText();",
      "}",
      ""
    ].join("\n");
  }

  function arduinoSegmentForCharFunction(project) {
    var glyphs = textGlyphsForProject(project);
    var characters = window.SevenSegModel && window.SevenSegModel.TEXT_GLYPH_CHARACTERS ?
      window.SevenSegModel.TEXT_GLYPH_CHARACTERS.split("") :
      " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-_.+#".split("");
    var lines = [
      "uint8_t segmentForChar(char c) {",
      "  if (c >= 'a' && c <= 'z') {",
      "    c = c - 32;",
      "  }",
      "",
      "  // Segment byte order copied from the working animation tool:",
      "  // bit6=a, bit5=b, bit4=c, bit3=d, bit2=e, bit1=f, bit0=g, bit7=dp.",
      "  // This table is generated from project.settings.textGlyphs.",
      "  switch (c) {",
    ];

    characters.forEach(function (character) {
      var label = character === "'" ? "\\'" : character;
      lines.push("    case '" + label + "': return " + hexByte(glyphs[character]) + ";");
    });
    lines.push("    default: return 0x00;");
    lines.push("  }");
    lines.push("}");
    lines.push("");
    return lines.join("\n");
  }

  function generateGlyphDataTestIno(project) {
    return [
      arduinoDisplayFoundation(),
      arduinoSegmentForCharFunction(project),
      "// Compact glyph table for raw graphic/compression tests.",
      "// These are temporary test patterns, not final game glyph meanings.",
      "const uint8_t customGlyphTable[8] = {",
      "  0x01, 0x08, 0x09, 0x41, 0x22, 0x14, 0x36, 0x80",
      "};",
      "",
      "uint8_t numberOffset = 0;",
      "uint8_t letterOffset = 0;",
      "uint8_t glyphOffset = 0;",
      "uint8_t bitIndex = 0;",
      "",
      "void printHelp() {",
      "  Serial.println();",
      "  Serial.println(F(\"SevenSeg Glyph/Data Test\"));",
      "  Serial.println(F(\"Commands:\"));",
      "  Serial.println(F(\"  n = number mode, advances 0-9 test\"));",
      "  Serial.println(F(\"  l = letter mode, advances A-Z test\"));",
      "  Serial.println(F(\"  g = glyph-table mode, advances 8 raw glyphs\"));",
      "  Serial.println(F(\"  b = bit-by-bit mode, advances segments and decimal point\"));",
      "  Serial.println(F(\"  c = clear\"));",
      "  Serial.println(F(\"  h = help\"));",
      "  Serial.println(F(\"All modes write all 24 cells.\"));",
      "}",
      "",
      "void renderNumberMode() {",
      "  for (uint8_t index = 0; index < DISPLAY_CELLS; index++) {",
      "    char c = '0' + ((index + numberOffset) % 10);",
      "    setRawDigit(index, segmentForChar(c));",
      "  }",
      "  numberOffset = (numberOffset + 1) % 10;",
      "  Serial.println(F(\"Number mode\"));",
      "}",
      "",
      "void renderLetterMode() {",
      "  for (uint8_t index = 0; index < DISPLAY_CELLS; index++) {",
      "    char c = 'A' + ((index + letterOffset) % 26);",
      "    setRawDigit(index, segmentForChar(c));",
      "  }",
      "  letterOffset = (letterOffset + 1) % 26;",
      "  Serial.println(F(\"Letter mode\"));",
      "}",
      "",
      "void renderGlyphTableMode() {",
      "  for (uint8_t index = 0; index < DISPLAY_CELLS; index++) {",
      "    uint8_t glyphIndex = (index + glyphOffset) % 8;",
      "    setRawDigit(index, customGlyphTable[glyphIndex]);",
      "  }",
      "  glyphOffset = (glyphOffset + 1) % 8;",
      "  Serial.println(F(\"Glyph-table mode\"));",
      "}",
      "",
      "void renderBitByBitMode() {",
      "  uint8_t value = (uint8_t)(1 << bitIndex);",
      "  for (uint8_t index = 0; index < DISPLAY_CELLS; index++) {",
      "    setRawDigit(index, value);",
      "  }",
      "  Serial.print(F(\"Bit-by-bit mode, bit \"));",
      "  Serial.println(bitIndex);",
      "  bitIndex = (bitIndex + 1) % 8;",
      "}",
      "",
      "void handleCommand(char command) {",
      "  if (command >= 'A' && command <= 'Z') {",
      "    command = command + 32;",
      "  }",
      "",
      "  switch (command) {",
      "    case 'n':",
      "      renderNumberMode();",
      "      break;",
      "    case 'l':",
      "      renderLetterMode();",
      "      break;",
      "    case 'g':",
      "      renderGlyphTableMode();",
      "      break;",
      "    case 'b':",
      "      renderBitByBitMode();",
      "      break;",
      "    case 'c':",
      "      clearDisplay();",
      "      Serial.println(F(\"Clear\"));",
      "      break;",
      "    case 'h':",
      "      printHelp();",
      "      break;",
      "    case '\\r':",
      "    case '\\n':",
      "      break;",
      "    default:",
      "      Serial.println(F(\"Unknown command. Type h for help.\"));",
      "      break;",
      "  }",
      "}",
      "",
      "void setup() {",
      "  Serial.begin(9600);",
      "  initDisplay();",
      "  printHelp();",
      "  renderNumberMode();",
      "}",
      "",
      "void loop() {",
      "  updateDisplayBrightness();",
      "  while (Serial.available() > 0) {",
      "    handleCommand((char)Serial.read());",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function normalizedRoomFrame(room) {
    var model = window.SevenSegModel;
    var source = room && room.data && typeof room.data.pocV1Frame === "string" ?
      room.data.pocV1Frame :
      room.frame || "";
    var frame = model.normalizeFrame24(source);
    var clean = "";

    for (var i = 0; i < model.DISPLAY_CELLS; i += 1) {
      var c = frame.charAt(i);
      clean += c === "#" || c === "8" || c === "." ? c : " ";
    }

    return clean;
  }

  function generateRoomData(project) {
    var lines = [
      "struct Room {",
      "  uint8_t x;",
      "  uint8_t y;",
      "  char frame[DISPLAY_CELLS + 1];",
      "};",
      "",
      "const Room rooms[] = {"
    ];

    for (var i = 0; i < project.rooms.length; i += 1) {
      var room = project.rooms[i];
      lines.push(
        "  { " + room.x + ", " + room.y + ", \"" + cStringLiteral(normalizedRoomFrame(room)) + "\" }" +
        (i < project.rooms.length - 1 ? "," : "")
      );
    }

    lines.push(
      "};",
      "",
      "const uint16_t ROOM_COUNT = sizeof(rooms) / sizeof(rooms[0]);"
    );

    return lines.join("\n");
  }

  function segmentByteForMapChar(c) {
    switch (c) {
      case "#": return 0x7F;
      case "0": return 0x7E;
      case "1": return 0x30;
      case "2": return 0x6D;
      case "3": return 0x79;
      case "4": return 0x33;
      case "5": return 0x5B;
      case "6": return 0x5F;
      case "7": return 0x70;
      case "8": return 0x7F;
      case "9": return 0x7B;
      case "-": return 0x01;
      case ".": return 0x00;
      case " ": return 0x00;
      default: return 0x00;
    }
  }

  function compressedPalette(project) {
    var palette = [" ", ".", "#"];
    var seen = { " ": true, ".": true, "#": true };

    for (var i = 0; i < project.rooms.length; i += 1) {
      var frame = normalizedRoomFrame(project.rooms[i]);

      for (var index = 0; index < frame.length; index += 1) {
        var c = frame.charAt(index);

        if (!seen[c]) {
          seen[c] = true;
          palette.push(c);
        }
      }
    }

    while (palette.length < 8) {
      palette.push(" ");
    }

    return palette.slice(0, 8);
  }

  function paletteIndexMap(palette) {
    var map = {};

    for (var i = 0; i < palette.length; i += 1) {
      if (map[palette[i]] === undefined) {
        map[palette[i]] = i;
      }
    }

    return map;
  }

  function packFrame3Bit(frame, indexByChar) {
    var bytes = [];

    for (var b = 0; b < 9; b += 1) {
      bytes.push(0);
    }

    for (var cell = 0; cell < 24; cell += 1) {
      var glyph = indexByChar[frame.charAt(cell)];

      if (glyph === undefined) {
        glyph = 0;
      }

      var bitOffset = cell * 3;
      var byteIndex = Math.floor(bitOffset / 8);
      var shift = bitOffset % 8;

      bytes[byteIndex] |= (glyph << shift) & 0xFF;
      if (shift > 5) {
        bytes[byteIndex + 1] |= glyph >> (8 - shift);
      }
    }

    return bytes;
  }

  function byteList(values) {
    return values.map(function (value) {
      return "0x" + value.toString(16).toUpperCase().padStart(2, "0");
    }).join(", ");
  }

  function byteLines(values, perLine) {
    var lines = [];

    for (var i = 0; i < values.length; i += perLine) {
      lines.push("  " + byteList(values.slice(i, i + perLine)) + (i + perLine < values.length ? "," : ""));
    }

    return lines.join("\n");
  }

  function generateWorldDataModesTestIno() {
    var compression = window.SevenSegWorldCompression;

    if (!compression) {
      throw new Error("World compression support is unavailable.");
    }

    var palettes = [
      [0x00, 0x7F],
      [0x00, 0x01, 0x30, 0x7E],
      [0x00, 0x30, 0x6D, 0x79, 0x33, 0x5B, 0x5F, 0x70],
      [
        0x00, 0x7E, 0x30, 0x6D, 0x79, 0x33, 0x5B, 0x5F,
        0x70, 0x7F, 0x7B, 0x77, 0x1F, 0x4E, 0x3D, 0x4F
      ]
    ];
    var roomCells = [
      new Array(24).fill(0).map(function (value, index) {
        return (index + Math.floor(index / 8)) % 2;
      }),
      new Array(24).fill(0).map(function (value, index) {
        return index % 4;
      }),
      new Array(24).fill(0).map(function (value, index) {
        return (index + 1) % 8;
      }),
      new Array(24).fill(0).map(function (value, index) {
        return index % 16;
      })
    ];
    var rawRoom = [
      0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,
      0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
      0xFE, 0xB0, 0xED, 0xF9, 0xB3, 0xDB, 0xDF, 0xF0
    ];
    var paletteSegments = [];
    var roomData = [];
    var descriptors = [];
    var paletteOffset = 0;

    [1, 2, 3, 4].forEach(function (bitsPerCell, index) {
      var packed = compression.packPaletteRoom(roomCells[index], bitsPerCell);

      descriptors.push({
        dataOffset: roomData.length,
        modeBits: bitsPerCell,
        paletteOffset: paletteOffset
      });
      roomData = roomData.concat(packed);
      paletteSegments = paletteSegments.concat(palettes[index]);
      paletteOffset += palettes[index].length;
    });

    descriptors.push({
      dataOffset: roomData.length,
      modeBits: 8,
      paletteOffset: 0
    });
    roomData = roomData.concat(compression.packRawRoom(rawRoom));

    var descriptorLines = descriptors.map(function (descriptor, index) {
      return "  { " + descriptor.dataOffset + ", " +
        descriptor.modeBits + ", " + descriptor.paletteOffset + " }" +
        (index < descriptors.length - 1 ? "," : "");
    });

    return [
      arduinoDisplayFoundation(),
      "",
      "// Standalone PROGMEM decoder test for all approved room data modes.",
      "// D5 = next room, D4 = previous room, A0 = MAX7219 brightness.",
      "const uint8_t NEXT_BUTTON_PIN = 5;",
      "const uint8_t PREVIOUS_BUTTON_PIN = 4;",
      "const uint8_t BRIGHTNESS_POT_PIN = A0;",
      "const uint8_t TEST_ROOM_COUNT = 5;",
      "const unsigned long BUTTON_DEBOUNCE_MS = 30;",
      "const unsigned long BUTTON_HOLD_MS = 500;",
      "const unsigned long BUTTON_REPEAT_MS = 200;",
      "",
      "struct RoomDescriptor {",
      "  uint16_t dataOffset;",
      "  uint8_t modeBits;",
      "  uint8_t paletteOffset;",
      "};",
      "",
      "const uint8_t paletteSegments[] PROGMEM = {",
      byteLines(paletteSegments, 16),
      "};",
      "",
      "const uint8_t roomData[] PROGMEM = {",
      byteLines(roomData, 16),
      "};",
      "",
      "const RoomDescriptor testRooms[TEST_ROOM_COUNT] PROGMEM = {",
      descriptorLines.join("\n"),
      "};",
      "",
      "uint8_t decodedFrame[DISPLAY_CELLS];",
      "uint8_t activeRoom = 0;",
      "uint8_t lastBrightness = 255;",
      "unsigned long lastBrightnessRead = 0;",
      "bool nextLastReading = HIGH;",
      "bool nextStableState = HIGH;",
      "unsigned long nextLastChange = 0;",
      "unsigned long nextHoldStart = 0;",
      "unsigned long nextLastRepeat = 0;",
      "bool previousLastReading = HIGH;",
      "bool previousStableState = HIGH;",
      "unsigned long previousLastChange = 0;",
      "unsigned long previousHoldStart = 0;",
      "unsigned long previousLastRepeat = 0;",
      "",
      "uint16_t roomDataOffset(uint8_t roomIndex) {",
      "  return pgm_read_word(&testRooms[roomIndex].dataOffset);",
      "}",
      "",
      "uint8_t roomModeBits(uint8_t roomIndex) {",
      "  return pgm_read_byte(&testRooms[roomIndex].modeBits);",
      "}",
      "",
      "uint8_t roomPaletteOffset(uint8_t roomIndex) {",
      "  return pgm_read_byte(&testRooms[roomIndex].paletteOffset);",
      "}",
      "",
      "uint8_t decodeRoomCell(uint8_t roomIndex, uint8_t cell) {",
      "  uint16_t dataOffset = roomDataOffset(roomIndex);",
      "  uint8_t modeBits = roomModeBits(roomIndex);",
      "",
      "  if (modeBits == 8) {",
      "    return pgm_read_byte(&roomData[dataOffset + cell]);",
      "  }",
      "",
      "  uint16_t bitOffset = (uint16_t)cell * modeBits;",
      "  uint16_t byteOffset = dataOffset + bitOffset / 8;",
      "  uint8_t shift = bitOffset % 8;",
      "  uint8_t glyphIndex = pgm_read_byte(&roomData[byteOffset]) >> shift;",
      "",
      "  if (shift + modeBits > 8) {",
      "    glyphIndex |= pgm_read_byte(&roomData[byteOffset + 1]) << (8 - shift);",
      "  }",
      "",
      "  glyphIndex &= (1 << modeBits) - 1;",
      "  return pgm_read_byte(&paletteSegments[roomPaletteOffset(roomIndex) + glyphIndex]);",
      "}",
      "",
      "void decodeActiveRoom() {",
      "  for (uint8_t cell = 0; cell < DISPLAY_CELLS; cell++) {",
      "    decodedFrame[cell] = decodeRoomCell(activeRoom, cell);",
      "  }",
      "}",
      "",
      "void printActiveMode() {",
      "  Serial.print(F(\"Room \"));",
      "  Serial.print(activeRoom + 1);",
      "  Serial.print(F(\"/5: \"));",
      "",
      "  switch (activeRoom) {",
      "    case 0: Serial.println(F(\"1-bit palette\")); break;",
      "    case 1: Serial.println(F(\"2-bit palette\")); break;",
      "    case 2: Serial.println(F(\"3-bit palette\")); break;",
      "    case 3: Serial.println(F(\"4-bit palette\")); break;",
      "    default: Serial.println(F(\"raw segment bytes\")); break;",
      "  }",
      "}",
      "",
      "void showActiveRoom() {",
      "  decodeActiveRoom();",
      "  renderFrameRaw24(decodedFrame);",
      "  printActiveMode();",
      "}",
      "",
      "void updateBrightness() {",
      "  unsigned long now = millis();",
      "  if (now - lastBrightnessRead < 40) return;",
      "  lastBrightnessRead = now;",
      "",
      "  uint16_t rawBrightness = analogRead(BRIGHTNESS_POT_PIN);",
      "  uint8_t brightness = rawBrightness * 16 / 1024;",
      "  if (brightness > 15) brightness = 15;",
      "  if (brightness != lastBrightness) {",
      "    lastBrightness = brightness;",
      "    maxAll(MAX7219_INTENSITY, brightness);",
      "    Serial.print(F(\"Brightness A0=\"));",
      "    Serial.print(rawBrightness);",
      "    Serial.print(F(\" level=\"));",
      "    Serial.print(brightness);",
      "    Serial.println(F(\"/15\"));",
      "  }",
      "}",
      "",
      "bool buttonClickOrRepeat(",
      "    uint8_t pin,",
      "    bool &lastReading,",
      "    bool &stableState,",
      "    unsigned long &lastChange,",
      "    unsigned long &holdStart,",
      "    unsigned long &lastRepeat) {",
      "  unsigned long now = millis();",
      "  bool reading = digitalRead(pin);",
      "",
      "  if (reading != lastReading) {",
      "    lastReading = reading;",
      "    lastChange = now;",
      "  }",
      "",
      "  if (now - lastChange >= BUTTON_DEBOUNCE_MS &&",
      "      reading != stableState) {",
      "    stableState = reading;",
      "    if (reading == LOW) {",
      "      holdStart = now;",
      "      lastRepeat = now;",
      "      return true;",
      "    }",
      "  }",
      "",
      "  if (stableState == LOW &&",
      "      now - holdStart >= BUTTON_HOLD_MS &&",
      "      now - lastRepeat >= BUTTON_REPEAT_MS) {",
      "    lastRepeat = now;",
      "    return true;",
      "  }",
      "",
      "  return false;",
      "}",
      "",
      "void setup() {",
      "  Serial.begin(9600);",
      "  pinMode(NEXT_BUTTON_PIN, INPUT_PULLUP);",
      "  pinMode(PREVIOUS_BUTTON_PIN, INPUT_PULLUP);",
      "  pinMode(BRIGHTNESS_POT_PIN, INPUT);",
      "  initDisplay();",
      "  updateBrightness();",
      "  Serial.println(F(\"SevenSeg world data modes test\"));",
      "  Serial.println(F(\"D5 next, D4 previous, A0 brightness\"));",
      "  showActiveRoom();",
      "}",
      "",
      "void loop() {",
      "  updateBrightness();",
      "",
      "  if (buttonClickOrRepeat(",
      "      NEXT_BUTTON_PIN, nextLastReading, nextStableState,",
      "      nextLastChange, nextHoldStart, nextLastRepeat)) {",
      "    activeRoom = (activeRoom + 1) % TEST_ROOM_COUNT;",
      "    showActiveRoom();",
      "  } else if (buttonClickOrRepeat(",
      "      PREVIOUS_BUTTON_PIN, previousLastReading, previousStableState,",
      "      previousLastChange, previousHoldStart, previousLastRepeat)) {",
      "    activeRoom = (activeRoom + TEST_ROOM_COUNT - 1) % TEST_ROOM_COUNT;",
      "    showActiveRoom();",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function generateGateChestTestIno(project) {
    var safeProject = project || window.SevenSegModel.defaultProject;

    return [
      arduinoDisplayFoundation(),
      arduinoSegmentForCharFunction(safeProject),
      "// Standalone Minimal RPG gate/chest hardware test.",
      "// A4 = facing direction pot. D5 = move forward. D4 = move backward.",
      "// A0 = MAX7219 brightness. This test does not include battle.",
      "",
      "const uint8_t FACING_POT_PIN = A4;",
      "const uint8_t MOVE_FORWARD_PIN = 5;",
      "const uint8_t MOVE_BACKWARD_PIN = 4;",
      "const unsigned long DEBOUNCE_MS = 40;",
      "const unsigned long HOLD_REPEAT_START_MS = 500;",
      "const unsigned long HOLD_REPEAT_INTERVAL_MS = 200;",
      "const uint8_t ROOM_A = 0;",
      "const uint8_t ROOM_B = 1;",
      "",
      "uint8_t currentRoom = ROOM_A;",
      "uint8_t playerX = 0;",
      "uint8_t playerY = 1;",
      "uint8_t gold = 0;",
      "uint8_t potionCount = 0;",
      "bool hasAncientKey = false;",
      "bool gateOpened = false;",
      "bool swordObtained = false;",
      "bool chestGoldOpened = false;",
      "bool chestKeyOpened = false;",
      "bool chestSwordOpened = false;",
      "bool chestPotionOpened = false;",
      "",
      "bool lastForwardReading = HIGH;",
      "bool stableForwardState = HIGH;",
      "unsigned long lastForwardChange = 0;",
      "unsigned long forwardHoldStart = 0;",
      "unsigned long lastForwardRepeat = 0;",
      "bool lastBackwardReading = HIGH;",
      "bool stableBackwardState = HIGH;",
      "unsigned long lastBackwardChange = 0;",
      "unsigned long backwardHoldStart = 0;",
      "unsigned long lastBackwardRepeat = 0;",
      "",
      "void renderText24(const char text[]) {",
      "  for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "    char c = text[i];",
      "    if (c == '\\0') c = ' ';",
      "    if (c >= 'a' && c <= 'z') c = c - 32;",
      "    setRawDigit(i, segmentForChar(c));",
      "  }",
      "}",
      "",
      "void waitButtonsReleased() {",
      "  while (digitalRead(MOVE_FORWARD_PIN) == LOW || digitalRead(MOVE_BACKWARD_PIN) == LOW) {",
      "    updateDisplayBrightness();",
      "  }",
      "  delay(30);",
      "}",
      "",
      "void waitAnyMoveButton() {",
      "  waitButtonsReleased();",
      "  while (digitalRead(MOVE_FORWARD_PIN) == HIGH && digitalRead(MOVE_BACKWARD_PIN) == HIGH) {",
      "    updateDisplayBrightness();",
      "  }",
      "  delay(30);",
      "  waitButtonsReleased();",
      "}",
      "",
      "void showMessagePaged(const char text[]) {",
      "  uint8_t offset = 0;",
      "  char page[DISPLAY_CELLS + 1];",
      "  bool hasMore = true;",
      "",
      "  while (hasMore) {",
      "    bool ended = false;",
      "    for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "      char c = ended ? '\\0' : text[offset + i];",
      "      if (c == '\\0') {",
      "        ended = true;",
      "        page[i] = ' ';",
      "      } else {",
      "        page[i] = c;",
      "      }",
      "    }",
      "    hasMore = !ended && text[offset + DISPLAY_CELLS] != '\\0';",
      "    page[DISPLAY_CELLS] = '\\0';",
      "    renderText24(page);",
      "    waitAnyMoveButton();",
      "    offset += DISPLAY_CELLS;",
      "  }",
      "}",
      "",
      "bool buttonClickOrRepeat(uint8_t pin, bool &lastReading, bool &stableState, unsigned long &lastChange, unsigned long &holdStart, unsigned long &lastRepeat) {",
      "  bool reading = digitalRead(pin);",
      "  unsigned long now = millis();",
      "",
      "  if (reading != lastReading) {",
      "    lastReading = reading;",
      "    lastChange = now;",
      "  }",
      "",
      "  if (now - lastChange >= DEBOUNCE_MS && reading != stableState) {",
      "    stableState = reading;",
      "    if (reading == LOW) {",
      "      holdStart = now;",
      "      lastRepeat = now;",
      "      return true;",
      "    }",
      "  }",
      "",
      "  if (reading == LOW && stableState == LOW && now - holdStart >= HOLD_REPEAT_START_MS && now - lastRepeat >= HOLD_REPEAT_INTERVAL_MS) {",
      "    lastRepeat = now;",
      "    return true;",
      "  }",
      "",
      "  return false;",
      "}",
      "",
      "void facingDirection(int8_t &dx, int8_t &dy) {",
      "  uint16_t pot = analogRead(FACING_POT_PIN);",
      "  if (pot < 184) { dx = -1; dy = 0; }",
      "  else if (pot < 358) { dx = -1; dy = -1; }",
      "  else if (pot < 552) { dx = 0; dy = -1; }",
      "  else if (pot < 736) { dx = 1; dy = -1; }",
      "  else { dx = 1; dy = 0; }",
      "}",
      "",
      "bool isRoomAWall(uint8_t x, uint8_t y) {",
      "  return x == 7 && y != 1;",
      "}",
      "",
      "bool isRoomAGate(uint8_t x, uint8_t y) {",
      "  return x == 7 && y == 1;",
      "}",
      "",
      "char chestCharAt(uint8_t room, uint8_t x, uint8_t y) {",
      "  if (room != ROOM_A) return ' ';",
      "  if (x == 2 && y == 0 && !chestGoldOpened) return 'C';",
      "  if (x == 3 && y == 1 && !chestKeyOpened) return 'C';",
      "  if (x == 2 && y == 2 && !chestSwordOpened) return 'C';",
      "  if (x == 5 && y == 1 && !chestPotionOpened) return 'C';",
      "  return ' ';",
      "}",
      "",
      "char mapCharAt(uint8_t room, uint8_t x, uint8_t y) {",
      "  char chest = chestCharAt(room, x, y);",
      "  if (chest != ' ') return chest;",
      "  if (room == ROOM_A && isRoomAWall(x, y)) return '8';",
      "  if (room == ROOM_A && isRoomAGate(x, y)) return '1';",
      "  return ' ';",
      "}",
      "",
      "void renderWorld() {",
      "  for (uint8_t y = 0; y < DISPLAY_ROWS; y++) {",
      "    for (uint8_t x = 0; x < DISPLAY_COLS; x++) {",
      "      char c = mapCharAt(currentRoom, x, y);",
      "      if (x == playerX && y == playerY) c = '1';",
      "      setCell(x, y, segmentForChar(c));",
      "    }",
      "  }",
      "}",
      "",
      "void openChestAtPlayer() {",
      "  if (currentRoom != ROOM_A) return;",
      "",
      "  if (playerX == 2 && playerY == 0 && !chestGoldOpened) {",
      "    chestGoldOpened = true;",
      "    gold += 10;",
      "    showMessagePaged(\"FOUND 10 GOLD\");",
      "  } else if (playerX == 3 && playerY == 1 && !chestKeyOpened) {",
      "    chestKeyOpened = true;",
      "    hasAncientKey = true;",
      "    gateOpened = true;",
      "    showMessagePaged(\"YOU NOW HOLD THE ANCHENT KEY\");",
      "  } else if (playerX == 2 && playerY == 2 && !chestSwordOpened) {",
      "    chestSwordOpened = true;",
      "    swordObtained = true;",
      "    showMessagePaged(\"SWORD ATK PLUS 4\");",
      "  } else if (playerX == 5 && playerY == 1 && !chestPotionOpened) {",
      "    chestPotionOpened = true;",
      "    potionCount += 1;",
      "    showMessagePaged(\"POTION PLUS 1\");",
      "  }",
      "}",
      "",
      "void showState() {",
      "  char page[DISPLAY_CELLS + 1] = \"G00 P0 K0 S0 GATE0     \";",
      "  page[1] = (char)('0' + (gold / 10) % 10);",
      "  page[2] = (char)('0' + gold % 10);",
      "  page[5] = (char)('0' + potionCount);",
      "  page[8] = hasAncientKey ? '1' : '0';",
      "  page[11] = swordObtained ? '1' : '0';",
      "  page[17] = gateOpened ? '1' : '0';",
      "  renderText24(page);",
      "  waitAnyMoveButton();",
      "}",
      "",
      "void tryMove(int8_t dx, int8_t dy) {",
      "  int8_t nx = (int8_t)playerX + dx;",
      "  int8_t ny = (int8_t)playerY + dy;",
      "",
      "  if (ny < 0 || ny >= DISPLAY_ROWS) return;",
      "",
      "  if (currentRoom == ROOM_A && nx == 7 && ny == 1) {",
      "    if (!hasAncientKey) {",
      "      showMessagePaged(\"GATE LOCKED FIND KEY\");",
      "      renderWorld();",
      "      return;",
      "    }",
      "    currentRoom = ROOM_B;",
      "    playerX = 0;",
      "    playerY = 1;",
      "    gateOpened = true;",
      "    showMessagePaged(\"GATE OPEN SECTION TWO\");",
      "    renderWorld();",
      "    return;",
      "  }",
      "",
      "  if (currentRoom == ROOM_B && nx < 0 && ny == 1) {",
      "    currentRoom = ROOM_A;",
      "    playerX = 6;",
      "    playerY = 1;",
      "    renderWorld();",
      "    return;",
      "  }",
      "",
      "  if (nx < 0 || nx >= DISPLAY_COLS) return;",
      "  if (currentRoom == ROOM_A && isRoomAWall((uint8_t)nx, (uint8_t)ny)) {",
      "    showMessagePaged(\"WALL\");",
      "    renderWorld();",
      "    return;",
      "  }",
      "",
      "  playerX = (uint8_t)nx;",
      "  playerY = (uint8_t)ny;",
      "  openChestAtPlayer();",
      "  renderWorld();",
      "}",
      "",
      "void setup() {",
      "  pinMode(MOVE_FORWARD_PIN, INPUT_PULLUP);",
      "  pinMode(MOVE_BACKWARD_PIN, INPUT_PULLUP);",
      "  pinMode(FACING_POT_PIN, INPUT);",
      "  initDisplay();",
      "  showMessagePaged(\"GATE CHEST TEST\");",
      "  renderWorld();",
      "}",
      "",
      "void loop() {",
      "  updateDisplayBrightness();",
      "",
      "  if (digitalRead(MOVE_FORWARD_PIN) == LOW && digitalRead(MOVE_BACKWARD_PIN) == LOW) {",
      "    showState();",
      "    renderWorld();",
      "    return;",
      "  }",
      "",
      "  bool forwardMove = buttonClickOrRepeat(MOVE_FORWARD_PIN, lastForwardReading, stableForwardState, lastForwardChange, forwardHoldStart, lastForwardRepeat);",
      "  bool backwardMove = buttonClickOrRepeat(MOVE_BACKWARD_PIN, lastBackwardReading, stableBackwardState, lastBackwardChange, backwardHoldStart, lastBackwardRepeat);",
      "",
      "  if (forwardMove) {",
      "    int8_t dx = 0;",
      "    int8_t dy = 0;",
      "    facingDirection(dx, dy);",
      "    tryMove(dx, dy);",
      "  } else if (backwardMove) {",
      "    int8_t dx = 0;",
      "    int8_t dy = 0;",
      "    facingDirection(dx, dy);",
      "    tryMove(-dx, -dy);",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function generateRewardLevelTestIno(project) {
    var safeProject = project || window.SevenSegModel.defaultProject;

    return [
      arduinoDisplayFoundation(),
      arduinoSegmentForCharFunction(safeProject),
      "// Standalone Minimal RPG reward/level hardware test.",
      "// D5 = next reward step. D4 = reset test. A0 = MAX7219 brightness.",
      "// This test does not include world movement, battle AI, or EEPROM.",
      "",
      "const uint8_t NEXT_BUTTON_PIN = 5;",
      "const uint8_t RESET_BUTTON_PIN = 4;",
      "const unsigned long DEBOUNCE_MS = 40;",
      "const unsigned long HOLD_REPEAT_START_MS = 500;",
      "const unsigned long HOLD_REPEAT_INTERVAL_MS = 200;",
      "",
      "uint8_t stepIndex = 0;",
      "uint8_t heroLevel = 1;",
      "uint8_t heroCurrentHp = 30;",
      "uint8_t heroMaxHp = 30;",
      "uint8_t heroAttack = 6;",
      "uint8_t potionCount = 0;",
      "uint16_t heroXp = 0;",
      "uint16_t heroXpNext = 20;",
      "const uint16_t XP_PER_FIGHT = 10;",
      "const uint16_t XP_NEXT_LEVEL = 20;",
      "const uint8_t LEVEL_UP_HP_BONUS = 5;",
      "const uint8_t SWORD_ATTACK_BONUS = 4;",
      "const uint8_t POTION_HEAL = 10;",
      "",
      "bool lastNextReading = HIGH;",
      "bool stableNextState = HIGH;",
      "unsigned long lastNextChange = 0;",
      "unsigned long nextHoldStart = 0;",
      "unsigned long lastNextRepeat = 0;",
      "bool lastResetReading = HIGH;",
      "bool stableResetState = HIGH;",
      "unsigned long lastResetChange = 0;",
      "unsigned long resetHoldStart = 0;",
      "unsigned long lastResetRepeat = 0;",
      "",
      "void renderText24(const char text[]) {",
      "  for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "    char c = text[i];",
      "    if (c == '\\0') c = ' ';",
      "    if (c >= 'a' && c <= 'z') c = c - 32;",
      "    setRawDigit(i, segmentForChar(c));",
      "  }",
      "}",
      "",
      "void waitButtonsReleased() {",
      "  while (digitalRead(NEXT_BUTTON_PIN) == LOW || digitalRead(RESET_BUTTON_PIN) == LOW) {",
      "    updateDisplayBrightness();",
      "  }",
      "  delay(30);",
      "}",
      "",
      "void waitAnyButton() {",
      "  waitButtonsReleased();",
      "  while (digitalRead(NEXT_BUTTON_PIN) == HIGH && digitalRead(RESET_BUTTON_PIN) == HIGH) {",
      "    updateDisplayBrightness();",
      "  }",
      "  delay(30);",
      "  waitButtonsReleased();",
      "}",
      "",
      "void showMessagePaged(const char text[]) {",
      "  uint8_t offset = 0;",
      "  char page[DISPLAY_CELLS + 1];",
      "  bool hasMore = true;",
      "",
      "  while (hasMore) {",
      "    bool ended = false;",
      "    for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "      char c = ended ? '\\0' : text[offset + i];",
      "      if (c == '\\0') {",
      "        ended = true;",
      "        page[i] = ' ';",
      "      } else {",
      "        page[i] = c;",
      "      }",
      "    }",
      "    hasMore = !ended && text[offset + DISPLAY_CELLS] != '\\0';",
      "    page[DISPLAY_CELLS] = '\\0';",
      "    renderText24(page);",
      "    waitAnyButton();",
      "    offset += DISPLAY_CELLS;",
      "  }",
      "}",
      "",
      "bool buttonClickOrRepeat(uint8_t pin, bool &lastReading, bool &stableState, unsigned long &lastChange, unsigned long &holdStart, unsigned long &lastRepeat) {",
      "  bool reading = digitalRead(pin);",
      "  unsigned long now = millis();",
      "",
      "  if (reading != lastReading) {",
      "    lastReading = reading;",
      "    lastChange = now;",
      "  }",
      "",
      "  if (now - lastChange >= DEBOUNCE_MS && reading != stableState) {",
      "    stableState = reading;",
      "    if (reading == LOW) {",
      "      holdStart = now;",
      "      lastRepeat = now;",
      "      return true;",
      "    }",
      "  }",
      "",
      "  if (reading == LOW && stableState == LOW && now - holdStart >= HOLD_REPEAT_START_MS && now - lastRepeat >= HOLD_REPEAT_INTERVAL_MS) {",
      "    lastRepeat = now;",
      "    return true;",
      "  }",
      "",
      "  return false;",
      "}",
      "",
      "void twoDigits(char page[], uint8_t index, uint16_t value) {",
      "  if (value > 99) value = 99;",
      "  page[index] = (char)('0' + (value / 10));",
      "  page[index + 1] = (char)('0' + (value % 10));",
      "}",
      "",
      "void renderStats() {",
      "  char page[DISPLAY_CELLS + 1] = \"L0 XP00 HP00 A00 P0     \";",
      "  page[1] = (char)('0' + heroLevel);",
      "  twoDigits(page, 5, heroXp);",
      "  twoDigits(page, 10, heroCurrentHp);",
      "  twoDigits(page, 14, heroAttack);",
      "  page[18] = (char)('0' + potionCount);",
      "  renderText24(page);",
      "}",
      "",
      "void resetRewardTest() {",
      "  stepIndex = 0;",
      "  heroLevel = 1;",
      "  heroCurrentHp = 30;",
      "  heroMaxHp = 30;",
      "  heroAttack = 6;",
      "  potionCount = 0;",
      "  heroXp = 0;",
      "  heroXpNext = XP_NEXT_LEVEL;",
      "  showMessagePaged(\"REWARD LEVEL TEST\");",
      "  renderStats();",
      "}",
      "",
      "void applyFightReward() {",
      "  heroXp += XP_PER_FIGHT;",
      "  bool leveledUp = false;",
      "  while (heroXp >= heroXpNext && heroLevel < 9) {",
      "    heroXp -= heroXpNext;",
      "    heroLevel++;",
      "    heroXpNext += 10;",
      "    heroMaxHp += LEVEL_UP_HP_BONUS;",
      "    heroCurrentHp = heroMaxHp;",
      "    leveledUp = true;",
      "  }",
      "  if (leveledUp) {",
      "    showMessagePaged(\"LEVEL UP HP PLUS 5\");",
      "  } else {",
      "    showMessagePaged(\"XP PLUS 10\");",
      "  }",
      "  renderStats();",
      "}",
      "",
      "void applyNextStep() {",
      "  stepIndex += 1;",
      "",
      "  if (stepIndex == 1 || stepIndex == 2) {",
      "    applyFightReward();",
      "  } else if (stepIndex == 3) {",
      "    heroAttack += SWORD_ATTACK_BONUS;",
      "    showMessagePaged(\"SWORD ATK PLUS 4\");",
      "    renderStats();",
      "  } else if (stepIndex == 4) {",
      "    potionCount += 1;",
      "    showMessagePaged(\"POTION PLUS 1\");",
      "    renderStats();",
      "  } else if (stepIndex == 5) {",
      "    if (heroCurrentHp > 10) heroCurrentHp -= 10;",
      "    showMessagePaged(\"DAMAGE 10\");",
      "    renderStats();",
      "  } else if (stepIndex == 6) {",
      "    if (potionCount > 0) {",
      "      potionCount -= 1;",
      "      heroCurrentHp += POTION_HEAL;",
      "      if (heroCurrentHp > heroMaxHp) heroCurrentHp = heroMaxHp;",
      "      showMessagePaged(\"USE POTION HP PLUS 10\");",
      "    } else {",
      "      showMessagePaged(\"NO POTION\");",
      "    }",
      "    renderStats();",
      "  } else {",
      "    showMessagePaged(\"TEST DONE D4 RESET\");",
      "    renderStats();",
      "  }",
      "}",
      "",
      "void setup() {",
      "  pinMode(NEXT_BUTTON_PIN, INPUT_PULLUP);",
      "  pinMode(RESET_BUTTON_PIN, INPUT_PULLUP);",
      "  initDisplay();",
      "  resetRewardTest();",
      "}",
      "",
      "void loop() {",
      "  updateDisplayBrightness();",
      "",
      "  if (buttonClickOrRepeat(NEXT_BUTTON_PIN, lastNextReading, stableNextState, lastNextChange, nextHoldStart, lastNextRepeat)) {",
      "    applyNextStep();",
      "  } else if (buttonClickOrRepeat(RESET_BUTTON_PIN, lastResetReading, stableResetState, lastResetChange, resetHoldStart, lastResetRepeat)) {",
      "    resetRewardTest();",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function generateBossEndingTestIno(project) {
    var safeProject = project || window.SevenSegModel.defaultProject;

    return [
      arduinoDisplayFoundation(),
      arduinoSegmentForCharFunction(safeProject),
      "// Standalone Minimal RPG boss-ending hardware test.",
      "// D5 = hit boss / continue text. D4 = reset test. A0 = MAX7219 brightness.",
      "// This test proves final boss defeated flag and ending text only.",
      "",
      "const uint8_t HIT_BUTTON_PIN = 5;",
      "const uint8_t RESET_BUTTON_PIN = 4;",
      "const unsigned long DEBOUNCE_MS = 40;",
      "const unsigned long HOLD_REPEAT_START_MS = 500;",
      "const unsigned long HOLD_REPEAT_INTERVAL_MS = 200;",
      "const uint8_t BOSS_MAX_HP = 20;",
      "const uint8_t HERO_ATTACK = 10;",
      "",
      "uint8_t bossHp = BOSS_MAX_HP;",
      "bool bossDefeated = false;",
      "bool endingShown = false;",
      "",
      "bool lastHitReading = HIGH;",
      "bool stableHitState = HIGH;",
      "unsigned long lastHitChange = 0;",
      "unsigned long hitHoldStart = 0;",
      "unsigned long lastHitRepeat = 0;",
      "bool lastResetReading = HIGH;",
      "bool stableResetState = HIGH;",
      "unsigned long lastResetChange = 0;",
      "unsigned long resetHoldStart = 0;",
      "unsigned long lastResetRepeat = 0;",
      "",
      "void renderText24(const char text[]) {",
      "  for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "    char c = text[i];",
      "    if (c == '\\0') c = ' ';",
      "    if (c >= 'a' && c <= 'z') c = c - 32;",
      "    setRawDigit(i, segmentForChar(c));",
      "  }",
      "}",
      "",
      "void waitButtonsReleased() {",
      "  while (digitalRead(HIT_BUTTON_PIN) == LOW || digitalRead(RESET_BUTTON_PIN) == LOW) {",
      "    updateDisplayBrightness();",
      "  }",
      "  delay(30);",
      "}",
      "",
      "void waitAnyButton() {",
      "  waitButtonsReleased();",
      "  while (digitalRead(HIT_BUTTON_PIN) == HIGH && digitalRead(RESET_BUTTON_PIN) == HIGH) {",
      "    updateDisplayBrightness();",
      "  }",
      "  delay(30);",
      "  waitButtonsReleased();",
      "}",
      "",
      "void showMessagePaged(const char text[]) {",
      "  uint8_t offset = 0;",
      "  char page[DISPLAY_CELLS + 1];",
      "  bool hasMore = true;",
      "",
      "  while (hasMore) {",
      "    bool ended = false;",
      "    for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "      char c = ended ? '\\0' : text[offset + i];",
      "      if (c == '\\0') {",
      "        ended = true;",
      "        page[i] = ' ';",
      "      } else {",
      "        page[i] = c;",
      "      }",
      "    }",
      "    hasMore = !ended && text[offset + DISPLAY_CELLS] != '\\0';",
      "    page[DISPLAY_CELLS] = '\\0';",
      "    renderText24(page);",
      "    waitAnyButton();",
      "    offset += DISPLAY_CELLS;",
      "  }",
      "}",
      "",
      "bool buttonClickOrRepeat(uint8_t pin, bool &lastReading, bool &stableState, unsigned long &lastChange, unsigned long &holdStart, unsigned long &lastRepeat) {",
      "  bool reading = digitalRead(pin);",
      "  unsigned long now = millis();",
      "",
      "  if (reading != lastReading) {",
      "    lastReading = reading;",
      "    lastChange = now;",
      "  }",
      "",
      "  if (now - lastChange >= DEBOUNCE_MS && reading != stableState) {",
      "    stableState = reading;",
      "    if (reading == LOW) {",
      "      holdStart = now;",
      "      lastRepeat = now;",
      "      return true;",
      "    }",
      "  }",
      "",
      "  if (reading == LOW && stableState == LOW && now - holdStart >= HOLD_REPEAT_START_MS && now - lastRepeat >= HOLD_REPEAT_INTERVAL_MS) {",
      "    lastRepeat = now;",
      "    return true;",
      "  }",
      "",
      "  return false;",
      "}",
      "",
      "void twoDigits(char page[], uint8_t index, uint8_t value) {",
      "  if (value > 99) value = 99;",
      "  page[index] = (char)('0' + (value / 10));",
      "  page[index + 1] = (char)('0' + (value % 10));",
      "}",
      "",
      "void renderBossState() {",
      "  char page[DISPLAY_CELLS + 1] = \"BOSS HP00 FLAG0        \";",
      "  twoDigits(page, 7, bossHp);",
      "  page[14] = bossDefeated ? '1' : '0';",
      "  renderText24(page);",
      "}",
      "",
      "void blinkBossDefeated() {",
      "  for (uint8_t i = 0; i < 3; i++) {",
      "    renderText24(\"BOSS DEFEATED          \");",
      "    delay(180);",
      "    clearDisplay();",
      "    delay(150);",
      "  }",
      "}",
      "",
      "void resetBossTest() {",
      "  bossHp = BOSS_MAX_HP;",
      "  bossDefeated = false;",
      "  endingShown = false;",
      "  showMessagePaged(\"BOSS ENDING TEST\");",
      "  renderBossState();",
      "}",
      "",
      "void showEnding() {",
      "  bossDefeated = true;",
      "  endingShown = true;",
      "  blinkBossDefeated();",
      "  showMessagePaged(\"YOU HAVE SAVED THE WORLD THANK YOU\");",
      "  renderText24(\"END FLAG1               \");",
      "}",
      "",
      "void hitBoss() {",
      "  if (bossDefeated) {",
      "    renderText24(\"END FLAG1               \");",
      "    return;",
      "  }",
      "",
      "  if (bossHp > HERO_ATTACK) {",
      "    bossHp -= HERO_ATTACK;",
      "    showMessagePaged(\"HIT BOSS 10\");",
      "    renderBossState();",
      "  } else {",
      "    bossHp = 0;",
      "    showEnding();",
      "  }",
      "}",
      "",
      "void setup() {",
      "  pinMode(HIT_BUTTON_PIN, INPUT_PULLUP);",
      "  pinMode(RESET_BUTTON_PIN, INPUT_PULLUP);",
      "  initDisplay();",
      "  resetBossTest();",
      "}",
      "",
      "void loop() {",
      "  updateDisplayBrightness();",
      "",
      "  if (buttonClickOrRepeat(HIT_BUTTON_PIN, lastHitReading, stableHitState, lastHitChange, hitHoldStart, lastHitRepeat)) {",
      "    hitBoss();",
      "  } else if (buttonClickOrRepeat(RESET_BUTTON_PIN, lastResetReading, stableResetState, lastResetChange, resetHoldStart, lastResetRepeat)) {",
      "    resetBossTest();",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function compressedWorldDimensions(project) {
    var width = 1;
    var height = 1;

    for (var i = 0; i < project.rooms.length; i += 1) {
      width = Math.max(width, Number(project.rooms[i].x) + 1);
      height = Math.max(height, Number(project.rooms[i].y) + 1);
    }

    return {
      width: Math.max(1, Math.min(window.SevenSegModel.ROOM_X_COUNT, width)),
      height: Math.max(1, Math.min(window.SevenSegModel.ROOM_Y_MAX - window.SevenSegModel.ROOM_Y_MIN + 1, height))
    };
  }

  function buildCompressedWorld(project) {
    var model = window.SevenSegModel;
    var dimensions = compressedWorldDimensions(project);
    var palette = compressedPalette(project);
    var indexByChar = paletteIndexMap(palette);
    var roomsByKey = {};
    var packed = [];
    var blockFlags = 0;

    for (var p = 0; p < palette.length; p += 1) {
      if (palette[p] === "#" || palette[p] === "8") {
        blockFlags |= (1 << p);
      }
    }

    for (var i = 0; i < project.rooms.length; i += 1) {
      roomsByKey[project.rooms[i].x + "," + project.rooms[i].y] = normalizedRoomFrame(project.rooms[i]);
    }

    for (var y = 0; y < dimensions.height; y += 1) {
      for (var x = 0; x < dimensions.width; x += 1) {
        var key = x + "," + y;
        var frame = roomsByKey[key] || model.normalizeFrame24("");
        packed = packed.concat(packFrame3Bit(frame, indexByChar));
      }
    }

    return {
      width: dimensions.width,
      height: dimensions.height,
      roomCount: dimensions.width * dimensions.height,
      bytesPerRoom: 9,
      paletteSegments: palette.map(segmentByteForMapChar),
      paletteBlockFlags: blockFlags,
      packedRoomBytes: packed
    };
  }

  function emitCompressedWorldTables(data) {
    return [
      "// Dense 3-bit compressed worldmap test data.",
      "// First compression milestone: one global 8-glyph palette, all data in PROGMEM.",
      "// Each room uses 24 cells * 3 bits = 72 bits = 9 bytes.",
      "const uint8_t WORLD_WIDTH = " + data.width + ";",
      "const uint8_t WORLD_HEIGHT = " + data.height + ";",
      "const uint16_t ROOM_COUNT = (uint16_t)WORLD_WIDTH * WORLD_HEIGHT;",
      "const uint8_t ROOM_DATA_BYTES = " + data.bytesPerRoom + ";",
      "",
      "const uint8_t globalGlyphSegments[8] PROGMEM = { " + byteList(data.paletteSegments) + " };",
      "const uint8_t globalGlyphBlockFlags PROGMEM = " + data.paletteBlockFlags + ";",
      "const uint8_t worldRoomData[] PROGMEM = {",
      byteLines(data.packedRoomBytes, 18),
      "};",
      ""
    ].join("\n");
  }

  function generateCompressedWorldmapData(project) {
    return emitCompressedWorldTables(buildCompressedWorld(project));
  }

  function generateCompressedWorldDecoder() {
    return [
      "uint8_t roomXFromIndex(uint16_t roomIndex) {",
      "  return (uint8_t)(roomIndex % WORLD_WIDTH);",
      "}",
      "",
      "uint8_t roomYFromIndex(uint16_t roomIndex) {",
      "  return (uint8_t)(roomIndex / WORLD_WIDTH);",
      "}",
      "",
      "uint8_t glyphSegments(uint8_t glyphIndex) {",
      "  if (glyphIndex > 7) glyphIndex = 0;",
      "  return pgm_read_byte(&globalGlyphSegments[glyphIndex]);",
      "}",
      "",
      "bool glyphBlocks(uint8_t glyphIndex) {",
      "  uint8_t flags = pgm_read_byte(&globalGlyphBlockFlags);",
      "  return (flags & (1 << glyphIndex)) != 0;",
      "}",
      "",
      "int16_t findRoomIndex(int8_t x, int8_t y) {",
      "  if (x < 0 || y < 0 || x >= WORLD_WIDTH || y >= WORLD_HEIGHT) {",
      "    return -1;",
      "  }",
      "",
      "  return (int16_t)((uint16_t)y * WORLD_WIDTH + (uint8_t)x);",
      "}",
      "",
      "uint8_t roomCellGlyph(uint16_t roomIndex, uint8_t x, uint8_t y) {",
      "  if (roomIndex >= ROOM_COUNT || x >= DISPLAY_COLS || y >= DISPLAY_ROWS) {",
      "    return 0;",
      "  }",
      "",
      "  uint8_t cell = cellIndex(x, y);",
      "  uint16_t bitOffset = (uint16_t)cell * 3;",
      "  uint16_t byteOffset = roomIndex * ROOM_DATA_BYTES + bitOffset / 8;",
      "  uint8_t shift = bitOffset % 8;",
      "  uint8_t value = pgm_read_byte(&worldRoomData[byteOffset]) >> shift;",
      "",
      "  if (shift > 5) {",
      "    value |= pgm_read_byte(&worldRoomData[byteOffset + 1]) << (8 - shift);",
      "  }",
      "",
      "  return value & 0x07;",
      "}",
      ""
    ].join("\n");
  }

  function minimalRpgData(project) {
    return project && project.gameFlow && project.gameFlow.data &&
      project.gameFlow.data.minimalRpg && typeof project.gameFlow.data.minimalRpg === "object" ?
      project.gameFlow.data.minimalRpg :
      {};
  }

  function denseRoomIndexMap(project) {
    var dimensions = compressedWorldDimensions(project);
    var map = {};

    (project.rooms || []).forEach(function (room) {
      var x = Number(room && room.x);
      var y = Number(room && room.y);

      if (Number.isFinite(x) && Number.isFinite(y) && x >= 0 && y >= 0) {
        map[room.id] = y * dimensions.width + x;
      }
    });

    return map;
  }

  function sectionIndexMap(project) {
    var map = {};

    (project.sections || []).forEach(function (section, index) {
      if (section && section.id) {
        map[section.id] = index;
      }
    });

    return map;
  }

  function flagBitForId(flagId) {
    switch (flagId) {
      case "hasAncientKey": return 0;
      case "gateOpened": return 1;
      case "bossDefeated": return 2;
      default: return 255;
    }
  }

  function chestFlagBitForId(chestId) {
    switch (chestId) {
      case "chest_gold_1": return 0;
      case "chest_gold_2": return 1;
      case "chest_gold_3": return 2;
      case "chest_gold_4": return 3;
      case "chest_key": return 4;
      case "chest_sword": return 5;
      case "chest_potion_1": return 6;
      case "chest_potion_2": return 7;
      default: return 255;
    }
  }

  function lootKindCode(kind) {
    switch (kind) {
      case "gold10": return 1;
      case "ancientKey": return 2;
      case "sword": return 3;
      case "potion": return 4;
      default: return 0;
    }
  }

  function cArrayRows(rows) {
    if (!rows.length) {
      return "  0";
    }

    return rows.map(function (row, index) {
      return "  " + row + (index < rows.length - 1 ? "," : "");
    }).join("\n");
  }

  function generateMinimalRpgPackedData(project) {
    var safeProject = project || window.SevenSegModel.defaultProject;
    var dimensions = compressedWorldDimensions(safeProject);
    var minimal = minimalRpgData(safeProject);
    var rooms = denseRoomIndexMap(safeProject);
    var sections = sectionIndexMap(safeProject);
    var roomSections = new Array(dimensions.width * dimensions.height).fill(0);
    var chests = Array.isArray(minimal.chests) ? minimal.chests : [];
    var gates = Array.isArray(minimal.gates) ? minimal.gates : [];
    var walls = Array.isArray(minimal.walls) ? minimal.walls.filter(function (wall) {
      return wall && wall.fromRoomId && wall.toRoomId;
    }) : [];
    var texts = Array.isArray(safeProject.texts) ? safeProject.texts : [];
    var enemies = Array.isArray(safeProject.enemies) ? safeProject.enemies : [];
    var encounters = Array.isArray(safeProject.encounterGroups) ? safeProject.encounterGroups : [];
    var items = Array.isArray(safeProject.items) ? safeProject.items : [];
    var equipment = Array.isArray(safeProject.equipment) ? safeProject.equipment : [];
    var heroes = Array.isArray(safeProject.heroes) ? safeProject.heroes : [];
    var battleRules = safeProject.battleRules && typeof safeProject.battleRules === "object" ? safeProject.battleRules : {};
    var calcMethod = battleRules.calculationMethod || (battleRules.data && battleRules.data.calculationMethod) || "simple11";
    var calcMethodIds = [
      "dnd5e",
      "pathfinder2e",
      "gurps",
      "fate",
      "coc",
      "shadowrun5e",
      "worldofdarkness",
      "ff1",
      "dragonquest",
      "pokemon",
      "simple11"
    ];
    var calcMethodCode = calcMethodIds.indexOf(calcMethod);
    if (calcMethodCode < 0) calcMethodCode = 10;
    var textDefinitions = texts.map(function (entry, index) {
      return "const char minimalText" + index + "[] PROGMEM = \"" +
        cStringLiteral(entry && entry.text ? entry.text : "") + "\";";
    });
    var textPointers = texts.map(function (entry, index) {
      return "  minimalText" + index + (index < texts.length - 1 ? "," : "");
    });

    (safeProject.rooms || []).forEach(function (room) {
      var x = Number(room && room.x);
      var y = Number(room && room.y);
      var roomIndex = y * dimensions.width + x;

      if (Number.isFinite(roomIndex) && roomIndex >= 0 && roomIndex < roomSections.length) {
        roomSections[roomIndex] = sections[room.sectionId] !== undefined ? sections[room.sectionId] : 0;
      }
    });

    if (rooms.room_e02 !== undefined && rooms.room_e03 !== undefined &&
        !walls.some(function (wall) {
          return (wall.fromRoomId === "room_e02" && wall.toRoomId === "room_e03") ||
            (wall.fromRoomId === "room_e03" && wall.toRoomId === "room_e02");
        })) {
      walls.push({
        id: "wall_e02_e03",
        fromRoomId: "room_e02",
        toRoomId: "room_e03"
      });
    }

    var chestRows = chests.map(function (chest) {
      var amount = chest.lootKind === "gold10" ?
        Number(chest.amount || 10) :
        chest.lootKind === "potion" ?
          Number(chest.count || 1) :
          0;

      return "{ " +
        (rooms[chest.roomId] !== undefined ? rooms[chest.roomId] : 0) + ", " +
        Math.max(0, Math.min(7, Number(chest.x) || 0)) + ", " +
        Math.max(0, Math.min(2, Number(chest.y) || 0)) + ", " +
        lootKindCode(chest.lootKind) + ", " +
        Math.max(0, Math.min(255, Math.round(amount))) + ", " +
        chestFlagBitForId(chest.id) +
      " }";
    });
    var gateRows = gates.map(function (gate) {
      return "{ " +
        (rooms[gate.fromRoomId] !== undefined ? rooms[gate.fromRoomId] : 0) + ", " +
        (rooms[gate.toRoomId] !== undefined ? rooms[gate.toRoomId] : 0) + ", " +
        flagBitForId(gate.requiredFlag || "hasAncientKey") + ", " +
        flagBitForId("gateOpened") +
      " }";
    });
    var wallRows = walls.map(function (wall) {
      return "{ " +
        (rooms[wall.fromRoomId] !== undefined ? rooms[wall.fromRoomId] : 0) + ", " +
        (rooms[wall.toRoomId] !== undefined ? rooms[wall.toRoomId] : 0) +
      " }";
    });
    var enemyRows = enemies.map(function (enemy) {
      var stats = enemy && enemy.stats ? enemy.stats : {};
      var data = enemy && enemy.data ? enemy.data : {};

      return "{ " +
        (sections[data.sectionId] !== undefined ? sections[data.sectionId] : 0) + ", " +
        Math.max(1, Math.min(99, Number(stats.maxHP || stats.maxHp || stats.currentHP || 1))) + ", " +
        Math.max(1, Math.min(99, Number(stats.attackPower || stats.attack || 1))) + ", " +
        Math.max(0, Math.min(255, Number(stats.xpReward || 0))) + ", " +
        (data.finalBoss ? 1 : 0) + ", " +
        Math.max(0, Math.min(95, Number(stats.evasion || 0))) + ", " +
        Math.max(0, Math.min(99, Number(stats.defense || 0))) + ", " +
        Math.max(0, Math.min(99, Number(stats.magicDefense || 0))) + ", " +
        Math.max(5, Math.min(95, Number(stats.accuracy || 70))) + ", " +
        Math.max(0, Math.min(95, Number(stats.criticalChance || 0))) + ", " +
        Math.max(1, Math.min(99, Number(stats.level || 1))) + ", " +
        Math.max(0, Math.min(99, Number(stats.magicPower || 0))) + ", " +
        Math.max(0, Math.min(200, Number(stats.resistancePhysical === undefined ? 100 : stats.resistancePhysical))) + ", " +
        Math.max(0, Math.min(200, Number(stats.resistanceMagic === undefined ? 100 : stats.resistanceMagic))) + ", " +
        Math.max(0, Math.min(99, Number(stats.weaponPower || 0))) + ", " +
        Math.max(0, Math.min(99, Number(stats.spellPower || 0))) +
      " }";
    });
    var encounterRows = encounters.map(function (encounter) {
      var data = encounter && encounter.data ? encounter.data : {};
      var member = encounter && encounter.members && encounter.members[0] ? encounter.members[0] : {};
      var enemyIndex = enemies.findIndex(function (enemy) {
        return enemy && enemy.id === member.enemyId;
      });

      return "{ " +
        (sections[data.sectionId] !== undefined ? sections[data.sectionId] : 0) + ", " +
        (enemyIndex >= 0 ? enemyIndex : 0) + ", " +
        (data.finalBoss ? 1 : 0) + ", " +
        flagBitForId("bossDefeated") +
      " }";
    });
    var potion = items.filter(function (item) {
      return item && item.id === "item_potion";
    })[0] || {};
    var sword = equipment.filter(function (entry) {
      return entry && entry.id === "equipment_sword";
    })[0] || {};
    var potionData = potion.data || {};
    var swordData = sword.data || {};
    var heroStats = heroes[0] && heroes[0].stats ? heroes[0].stats : {};

    return [
      "// Minimal RPG packed generated data.",
      "// R07-P01 only packs data; R07-P02 wires behavior parity.",
      "const uint8_t MINIMAL_RPG_VERSION = 1;",
      "const uint8_t MINIMAL_FLAG_HAS_ANCIENT_KEY = 0;",
      "const uint8_t MINIMAL_FLAG_GATE_OPENED = 1;",
      "const uint8_t MINIMAL_FLAG_BOSS_DEFEATED = 2;",
      "const uint8_t MINIMAL_EQUIP_SWORD_OBTAINED = 0;",
      "const uint8_t MINIMAL_EQUIP_SWORD_EQUIPPED = 1;",
      "const uint8_t MINIMAL_POTION_HEAL = " +
        Math.max(1, Math.min(99, Number(potionData.healAmount || 10))) + ";",
      "const uint8_t MINIMAL_SWORD_ATTACK_BONUS = " +
        Math.max(0, Math.min(99, Number(swordData.attackPowerBonus || swordData.attack || 4))) + ";",
      "const uint8_t MINIMAL_HERO_ACCURACY = " +
        Math.max(5, Math.min(95, Number(heroStats.accuracy || 75))) + ";",
      "const uint8_t MINIMAL_HERO_DEFENSE = " +
        Math.max(0, Math.min(99, Number(heroStats.defense === undefined ? 5 : heroStats.defense))) + ";",
      "const uint8_t MINIMAL_HERO_MAGIC_DEFENSE = " +
        Math.max(0, Math.min(99, Number(heroStats.magicDefense === undefined ? 4 : heroStats.magicDefense))) + ";",
      "const uint8_t MINIMAL_HERO_EVASION = " +
        Math.max(0, Math.min(95, Number(heroStats.evasion === undefined ? 3 : heroStats.evasion))) + ";",
      "const uint8_t MINIMAL_HERO_CRITICAL_CHANCE = " +
        Math.max(0, Math.min(95, Number(heroStats.criticalChance === undefined ? 5 : heroStats.criticalChance))) + ";",
      "const uint8_t MINIMAL_HERO_MAGIC_POWER = " +
        Math.max(0, Math.min(99, Number(heroStats.magicPower === undefined ? 5 : heroStats.magicPower))) + ";",
      "const uint8_t MINIMAL_HERO_RESISTANCE_PHYSICAL = " +
        Math.max(0, Math.min(200, Number(heroStats.resistancePhysical === undefined ? 100 : heroStats.resistancePhysical))) + ";",
      "const uint8_t MINIMAL_HERO_RESISTANCE_MAGIC = " +
        Math.max(0, Math.min(200, Number(heroStats.resistanceMagic === undefined ? 100 : heroStats.resistanceMagic))) + ";",
      "const uint8_t MINIMAL_HERO_SPELL_POWER = " +
        Math.max(0, Math.min(99, Number(heroStats.spellPower === undefined ? 0 : heroStats.spellPower))) + ";",
      "const uint8_t BATTLE_CALC_METHOD = " + calcMethodCode + ";",
      "const uint8_t MINIMAL_CHEST_COUNT = " + chests.length + ";",
      "const uint8_t MINIMAL_GATE_COUNT = " + gates.length + ";",
      "const uint8_t MINIMAL_WALL_COUNT = " + walls.length + ";",
      "const uint8_t MINIMAL_TEXT_COUNT = " + texts.length + ";",
      "const uint8_t MINIMAL_ENEMY_COUNT = " + enemies.length + ";",
      "const uint8_t MINIMAL_ENCOUNTER_COUNT = " + encounters.length + ";",
      "",
      "struct MinimalChestData { uint16_t roomIndex; uint8_t x; uint8_t y; uint8_t lootKind; uint8_t amount; uint8_t flagBit; };",
      "struct MinimalGateData { uint16_t fromRoomIndex; uint16_t toRoomIndex; uint8_t requiredFlagBit; uint8_t openedFlagBit; };",
      "struct MinimalWallData { uint16_t fromRoomIndex; uint16_t toRoomIndex; };",
      "struct MinimalEnemyData { uint8_t sectionIndex; uint8_t maxHp; uint8_t attack; uint8_t xpReward; uint8_t finalBoss; uint8_t evasion; uint8_t defense; uint8_t magicDefense; uint8_t accuracy; uint8_t criticalChance; uint8_t level; uint8_t magicPower; uint8_t resistancePhysical; uint8_t resistanceMagic; uint8_t weaponPower; uint8_t spellPower; };",
      "struct MinimalEncounterData { uint8_t sectionIndex; uint8_t enemyIndex; uint8_t finalBoss; uint8_t bossFlagBit; };",
      "",
      "const uint8_t minimalRoomSections[ROOM_COUNT] PROGMEM = {",
      byteLines(roomSections, 18),
      "};",
      "",
      textDefinitions.join("\n"),
      "const char * const minimalTextTable[] PROGMEM = {",
      textPointers.length ? textPointers.join("\n") : "  0",
      "};",
      "",
      "const MinimalChestData minimalChests[] PROGMEM = {",
      cArrayRows(chestRows),
      "};",
      "",
      "const MinimalGateData minimalGates[] PROGMEM = {",
      cArrayRows(gateRows),
      "};",
      "",
      "const MinimalWallData minimalWalls[] PROGMEM = {",
      cArrayRows(wallRows),
      "};",
      "",
      "const MinimalEnemyData minimalEnemies[] PROGMEM = {",
      cArrayRows(enemyRows),
      "};",
      "",
      "const MinimalEncounterData minimalEncounters[] PROGMEM = {",
      cArrayRows(encounterRows),
      "};",
      ""
    ].join("\n");
  }

  function generateWorldmapTestIno(project) {
    var safeProject = project || window.SevenSegModel.defaultProject;
    var start = safeProject.start || { roomX: 0, roomY: 0, playerX: 0, playerY: 0 };
    var hardware = window.SevenSegModel.normalizeHardwareSettings(safeProject);

    return [
      arduinoDisplayFoundation(),
      "#include <Arduino.h>",
      "#include <avr/pgmspace.h>",
      arduinoSegmentForCharFunction(safeProject),
      "// Standalone worldmap hardware test.",
      "// Hardware controls:",
      "//   A4 potentiometer selects facing direction.",
      "//   D5 uses INPUT_PULLUP. LOW moves one step in the facing direction.",
      "//   D4 uses INPUT_PULLUP. LOW moves one step in the opposite direction.",
      "// Serial fallback still works: a=left, d=right, w=up, s=down, r=reset, h=help.",
      "// A4 measured facing points: 0.5V=W, 1.3V=NW, 2.2V=N, 3.2V=NE, 4.0V=E.",
      "// Map data is dense 3-bit compressed and stored in PROGMEM.",
      "// First compressed test uses one global 8-glyph set.",
      generateCompressedWorldmapData(safeProject),
      "",
      "const uint8_t FACING_POT_PIN = A4;",
      "const uint8_t MOVE_FORWARD_PIN = 5;",
      "const uint8_t MOVE_BACKWARD_PIN = 4;",
      "const unsigned long DEBOUNCE_MS = 40;",
      "const unsigned long HOLD_REPEAT_START_MS = 500;",
      "const unsigned long HOLD_REPEAT_INTERVAL_MS = 200;",
      "const uint16_t TRANSITION_ANIMATION_TIME_MS = " + hardware.transitionAnimationMs + ";",
      "const bool SHOW_ROOM_COORDINATES = " + (hardware.showCoordinates ? "true" : "false") + ";",
      "const uint16_t ROOM_COORDINATE_TIME_MS = " + hardware.coordinateTimeMs + ";",
      "",
      "uint16_t currentRoomIndex = 0;",
      "uint8_t playerX = " + Math.max(0, Math.min(7, Number(start.playerX) || 0)) + ";",
      "uint8_t playerY = " + Math.max(0, Math.min(2, Number(start.playerY) || 0)) + ";",
      "bool lastForwardReading = HIGH;",
      "bool stableForwardState = HIGH;",
      "unsigned long lastForwardChange = 0;",
      "unsigned long forwardHoldStart = 0;",
      "unsigned long lastForwardRepeat = 0;",
      "bool lastBackwardReading = HIGH;",
      "bool stableBackwardState = HIGH;",
      "unsigned long lastBackwardChange = 0;",
      "unsigned long backwardHoldStart = 0;",
      "unsigned long lastBackwardRepeat = 0;",
      "bool movementLockedUntilRelease = false;",
      "",
      generateCompressedWorldDecoder(),
      "void renderRoomCoordinates(uint8_t roomX, uint8_t roomY) {",
      "  if (!SHOW_ROOM_COORDINATES) return;",
      "  clearDisplay();",
      "  setCell(5, 0, segmentForChar((char)('A' + roomX)) | 0x80);",
      "  setCell(6, 0, segmentForChar((char)('0' + (roomY / 10))));",
      "  setCell(7, 0, segmentForChar((char)('0' + (roomY % 10))));",
      "  delay(ROOM_COORDINATE_TIME_MS);",
      "}",
      "",
      "uint8_t segmentLine(char segmentName) {",
      "  if (segmentName == 'a') return 0x40;",
      "  if (segmentName == 'b') return 0x20;",
      "  if (segmentName == 'c') return 0x10;",
      "  if (segmentName == 'd') return 0x08;",
      "  if (segmentName == 'e') return 0x04;",
      "  if (segmentName == 'f') return 0x02;",
      "  return 0x01;",
      "}",
      "",
      "uint16_t transitionStepDelay(uint8_t stepCount) {",
      "  if (TRANSITION_ANIMATION_TIME_MS == 0) return 0;",
      "  uint16_t stepDelay = TRANSITION_ANIMATION_TIME_MS / stepCount;",
      "  return stepDelay == 0 ? 1 : stepDelay;",
      "}",
      "",
      "void delayTransitionStep(uint16_t stepDelay) {",
      "  if (stepDelay > 0) delay(stepDelay);",
      "}",
      "",
      "void renderTransitionRow(uint8_t row, const char *segments, uint16_t stepDelay) {",
      "  clearDisplay();",
      "  for (uint8_t x = 0; x < DISPLAY_COLS; x++) {",
      "    setCell(x, row, segmentLine(segments[0]));",
      "  }",
      "  delayTransitionStep(stepDelay);",
      "  clearDisplay();",
      "  for (uint8_t x = 0; x < DISPLAY_COLS; x++) {",
      "    setCell(x, row, segmentLine(segments[1]));",
      "  }",
      "  delayTransitionStep(stepDelay);",
      "  clearDisplay();",
      "  for (uint8_t x = 0; x < DISPLAY_COLS; x++) {",
      "    setCell(x, row, segmentLine(segments[2]));",
      "  }",
      "  delayTransitionStep(stepDelay);",
      "}",
      "",
      "void renderTransitionColumn(uint8_t col, uint8_t firstSegments, uint8_t secondSegments, uint16_t stepDelay) {",
      "  clearDisplay();",
      "  for (uint8_t y = 0; y < DISPLAY_ROWS; y++) setCell(col, y, firstSegments);",
      "  delayTransitionStep(stepDelay);",
      "  clearDisplay();",
      "  for (uint8_t y = 0; y < DISPLAY_ROWS; y++) setCell(col, y, secondSegments);",
      "  delayTransitionStep(stepDelay);",
      "}",
      "",
      "void animateRoomTransition(int8_t dx, int8_t dy) {",
      "  if (TRANSITION_ANIMATION_TIME_MS == 0) return;",
      "  uint16_t stepDelay = transitionStepDelay(dy == 0 ? 16 : 9);",
      "",
      "  if (dy > 0) {",
      "    renderTransitionRow(2, \"dga\", stepDelay);",
      "    renderTransitionRow(1, \"dga\", stepDelay);",
      "    renderTransitionRow(0, \"dga\", stepDelay);",
      "  } else if (dy < 0) {",
      "    renderTransitionRow(0, \"agd\", stepDelay);",
      "    renderTransitionRow(1, \"agd\", stepDelay);",
      "    renderTransitionRow(2, \"agd\", stepDelay);",
      "  } else if (dx > 0) {",
      "    for (int8_t x = DISPLAY_COLS - 1; x >= 0; x--) renderTransitionColumn((uint8_t)x, 0x30, 0x06, stepDelay);",
      "  } else if (dx < 0) {",
      "    for (uint8_t x = 0; x < DISPLAY_COLS; x++) renderTransitionColumn(x, 0x06, 0x30, stepDelay);",
      "  }",
      "  clearDisplay();",
      "}",
      "",
      "void renderWorldmap() {",
      "  for (uint8_t y = 0; y < DISPLAY_ROWS; y++) {",
      "    for (uint8_t x = 0; x < DISPLAY_COLS; x++) {",
      "      uint8_t segments;",
      "",
      "      if (x == playerX && y == playerY) {",
      "        segments = segmentForChar('1');",
      "      } else {",
      "        segments = glyphSegments(roomCellGlyph(currentRoomIndex, x, y));",
      "      }",
      "",
      "      setCell(x, y, segments);",
      "    }",
      "  }",
      "}",
      "",
      "void resetWorldmap() {",
      "  int16_t startRoom = findRoomIndex(" + (Number(start.roomX) || 0) + ", " + (Number(start.roomY) || 0) + ");",
      "",
      "  if (startRoom < 0) {",
      "    startRoom = 0;",
      "  }",
      "",
      "  currentRoomIndex = (uint16_t)startRoom;",
      "  playerX = " + Math.max(0, Math.min(7, Number(start.playerX) || 0)) + ";",
      "  playerY = " + Math.max(0, Math.min(2, Number(start.playerY) || 0)) + ";",
      "",
      "  if (glyphBlocks(roomCellGlyph(currentRoomIndex, playerX, playerY))) {",
      "    playerX = 0;",
      "    playerY = 0;",
      "  }",
      "",
      "  renderWorldmap();",
      "}",
      "",
      "void tryMove(int8_t dx, int8_t dy) {",
      "  int8_t targetRoomX = (int8_t)roomXFromIndex(currentRoomIndex);",
      "  int8_t targetRoomY = (int8_t)roomYFromIndex(currentRoomIndex);",
      "  int8_t targetX = (int8_t)playerX + dx;",
      "  int8_t targetY = (int8_t)playerY + dy;",
      "  bool changesRoom = false;",
      "",
      "  if (targetX < 0) {",
      "    targetRoomX--;",
      "    targetX = DISPLAY_COLS - 1;",
      "    changesRoom = true;",
      "  } else if (targetX >= DISPLAY_COLS) {",
      "    targetRoomX++;",
      "    targetX = 0;",
      "    changesRoom = true;",
      "  }",
      "",
      "  if (targetY < 0) {",
      "    targetRoomY--;",
      "    targetY = DISPLAY_ROWS - 1;",
      "    changesRoom = true;",
      "  } else if (targetY >= DISPLAY_ROWS) {",
      "    targetRoomY++;",
      "    targetY = 0;",
      "    changesRoom = true;",
      "  }",
      "",
      "  int16_t targetRoomIndex = findRoomIndex(targetRoomX, targetRoomY);",
      "",
      "  if (targetRoomIndex < 0) {",
      "    Serial.println(F(\"Blocked: no room\"));",
      "    return;",
      "  }",
      "",
      "  if (glyphBlocks(roomCellGlyph((uint16_t)targetRoomIndex, (uint8_t)targetX, (uint8_t)targetY))) {",
      "    Serial.println(F(\"Blocked: wall\"));",
      "    return;",
      "  }",
      "",
      "  if (changesRoom) {",
      "    movementLockedUntilRelease = true;",
      "    animateRoomTransition(dx, dy);",
      "  }",
      "",
      "  currentRoomIndex = (uint16_t)targetRoomIndex;",
      "  playerX = (uint8_t)targetX;",
      "  playerY = (uint8_t)targetY;",
      "  if (changesRoom) {",
      "    renderRoomCoordinates(roomXFromIndex(currentRoomIndex), roomYFromIndex(currentRoomIndex));",
      "  }",
      "  renderWorldmap();",
      "}",
      "",
      "void facingDirection(int8_t &dx, int8_t &dy) {",
      "  uint16_t pot = analogRead(FACING_POT_PIN);",
      "",
      "  // Thresholds are midpoints between measured A4 direction values.",
      "  // 0.5V W ~= 102, 1.3V NW ~= 266, 2.2V N ~= 450, 3.2V NE ~= 655, 4.0V E ~= 818.",
      "  if (pot < 184) {",
      "    dx = -1;",
      "    dy = 0;",
      "  } else if (pot < 358) {",
      "    dx = -1;",
      "    dy = -1;",
      "  } else if (pot < 552) {",
      "    dx = 0;",
      "    dy = -1;",
      "  } else if (pot < 736) {",
      "    dx = 1;",
      "    dy = -1;",
      "  } else {",
      "    dx = 1;",
      "    dy = 0;",
      "  }",
      "}",
      "",
      "bool buttonClickOrRepeat(uint8_t pin, bool &lastReading, bool &stableState, unsigned long &lastChange, unsigned long &holdStart, unsigned long &lastRepeat) {",
      "  bool reading = digitalRead(pin);",
      "  unsigned long now = millis();",
      "",
      "  if (reading != lastReading) {",
      "    lastChange = now;",
      "    lastReading = reading;",
      "  }",
      "",
      "  if ((now - lastChange) >= DEBOUNCE_MS && reading != stableState) {",
      "    stableState = reading;",
      "    if (stableState == LOW) {",
      "      holdStart = now;",
      "      lastRepeat = now;",
      "      return true;",
      "    }",
      "    holdStart = 0;",
      "    lastRepeat = 0;",
      "  }",
      "",
      "  if (reading == LOW && stableState == LOW && holdStart > 0 && now - holdStart >= HOLD_REPEAT_START_MS && now - lastRepeat >= HOLD_REPEAT_INTERVAL_MS) {",
      "    lastRepeat = now;",
      "    return true;",
      "  }",
      "",
      "  return false;",
      "}",
      "",
      "void readHardwareControls() {",
      "  int8_t dx = 0;",
      "  int8_t dy = 0;",
      "  bool forwardMove = buttonClickOrRepeat(MOVE_FORWARD_PIN, lastForwardReading, stableForwardState, lastForwardChange, forwardHoldStart, lastForwardRepeat);",
      "  bool backwardMove = buttonClickOrRepeat(MOVE_BACKWARD_PIN, lastBackwardReading, stableBackwardState, lastBackwardChange, backwardHoldStart, lastBackwardRepeat);",
      "",
      "  if (movementLockedUntilRelease) {",
      "    if (stableForwardState == HIGH && stableBackwardState == HIGH) {",
      "      movementLockedUntilRelease = false;",
      "    }",
      "    return;",
      "  }",
      "",
      "  if (forwardMove) {",
      "    facingDirection(dx, dy);",
      "    tryMove(dx, dy);",
      "    if (movementLockedUntilRelease) return;",
      "  }",
      "",
      "  if (backwardMove) {",
      "    facingDirection(dx, dy);",
      "    tryMove(-dx, -dy);",
      "  }",
      "}",
      "",
      "void printHelp() {",
      "  Serial.println();",
      "  Serial.println(F(\"SevenSeg Worldmap Test\"));",
      "  Serial.println(F(\"Hardware controls:\"));",
      "  Serial.println(F(\"  A4 = facing direction pot\"));",
      "  Serial.println(F(\"  D5 LOW = step facing direction\"));",
      "  Serial.println(F(\"  D4 LOW = step opposite direction\"));",
      "  Serial.println(F(\"  Hold D5/D4 for 500ms: repeat every 200ms\"));",
      "  Serial.println(F(\"Serial fallback:\"));",
      "  Serial.println(F(\"  a = left\"));",
      "  Serial.println(F(\"  d = right\"));",
      "  Serial.println(F(\"  w = up\"));",
      "  Serial.println(F(\"  s = down\"));",
      "  Serial.println(F(\"  r = reset\"));",
      "  Serial.println(F(\"  h = help\"));",
      "}",
      "",
      "void handleCommand(char command) {",
      "  if (command >= 'A' && command <= 'Z') {",
      "    command = command + 32;",
      "  }",
      "",
      "  switch (command) {",
      "    case 'a':",
      "      tryMove(-1, 0);",
      "      break;",
      "    case 'd':",
      "      tryMove(1, 0);",
      "      break;",
      "    case 'w':",
      "      tryMove(0, -1);",
      "      break;",
      "    case 's':",
      "      tryMove(0, 1);",
      "      break;",
      "    case 'r':",
      "      resetWorldmap();",
      "      break;",
      "    case 'h':",
      "      printHelp();",
      "      break;",
      "    case '\\r':",
      "    case '\\n':",
      "      break;",
      "    default:",
      "      Serial.println(F(\"Unknown command. Type h for help.\"));",
      "      break;",
      "  }",
      "}",
      "",
      "void setup() {",
      "  Serial.begin(9600);",
      "  pinMode(MOVE_FORWARD_PIN, INPUT_PULLUP);",
      "  pinMode(MOVE_BACKWARD_PIN, INPUT_PULLUP);",
      "  initDisplay();",
      "  printHelp();",
      "  resetWorldmap();",
      "}",
      "",
      "void loop() {",
      "  updateDisplayBrightness();",
      "  readHardwareControls();",
      "  while (Serial.available() > 0) {",
      "    handleCommand((char)Serial.read());",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function numberList(values) {
    return values.map(function (value) {
      return String(Math.max(0, Math.round(Number(value) || 0)));
    }).join(", ");
  }

  function numberLines(values, perLine) {
    var lines = [];

    for (var i = 0; i < values.length; i += perLine) {
      lines.push("  " + numberList(values.slice(i, i + perLine)) + (i + perLine < values.length ? "," : ""));
    }

    return lines.join("\n");
  }

  function midiToHz(value) {
    var midi = Number(value) || 0;

    if (midi <= 0) {
      return 0;
    }

    return Math.max(1, Math.min(20000, Math.round(440 * Math.pow(2, (midi - 69) / 12))));
  }

  function hzToHalfPeriodUs(hz) {
    var safeHz = Number(hz) || 0;

    if (safeHz <= 0) {
      return 0;
    }

    return Math.max(1, Math.min(65535, Math.round(500000 / safeHz)));
  }

  function assignedMusicSongs(project) {
    var songs = Array.isArray(project && project.music) ? project.music : [];
    var assignments = project && project.settings && project.settings.musicAssignments ?
      project.settings.musicAssignments :
      {};
    var result = [];

    function findSong(id) {
      return songs.find(function (song) {
        return song && song.id === id;
      }) || null;
    }

    function addSong(song, role) {
      if (!song || result.some(function (entry) { return entry.song === song; })) {
        return;
      }
      result.push({
        song: song,
        role: role
      });
    }

    addSong(findSong(assignments.worldmapMusicId), "Worldmap");
    addSong(findSong(assignments.battleMusicId), "Battle");

    songs.forEach(function (song) {
      if (result.length < 2) {
        addSong(song, result.length === 0 ? "Worldmap" : "Battle");
      }
    });

    return result.slice(0, 2);
  }

  function songGatePercent(song) {
    var gate = Number(song && song.settings && song.settings.gate);

    if (!Number.isFinite(gate) || gate <= 0) {
      gate = 0.82;
    }
    if (gate <= 1) {
      gate *= 100;
    }

    return Math.max(20, Math.min(100, Math.round(gate)));
  }

  function songBpm(song) {
    var bpm = Number(song && song.settings && song.settings.bpm);

    return Math.max(40, Math.min(240, Math.round(Number.isFinite(bpm) && bpm > 0 ? bpm : 120)));
  }

  function songChannels(song) {
    return song && song.channels && typeof song.channels === "object" ? song.channels : {};
  }

  function songEventCount(song) {
    var channels = songChannels(song);
    var melody = Array.isArray(channels.melodyNotes) ? channels.melodyNotes : [];
    var durations = Array.isArray(channels.durations) ? channels.durations : [];

    return Math.min(192, melody.length, durations.length);
  }

  function generateMusicHardwareTestIno(project) {
    var selectedSongs = assignedMusicSongs(project || {});
    var melodyHalfUs = [];
    var bassHalfUs = [];
    var durations = [];
    var offsets = [];
    var lengths = [];
    var bpms = [];
    var gates = [];
    var names = [];

    if (!selectedSongs.length) {
      throw new Error("Import and assign at least one chiptune song first.");
    }

    selectedSongs.forEach(function (entry) {
      var song = entry.song;
      var channels = songChannels(song);
      var melody = Array.isArray(channels.melodyNotes) ? channels.melodyNotes : [];
      var bass = Array.isArray(channels.bassNotes) ? channels.bassNotes : [];
      var durs = Array.isArray(channels.durations) ? channels.durations : [];
      var count = songEventCount(song);

      if (count <= 0) {
        return;
      }

      offsets.push(melodyHalfUs.length);
      lengths.push(count);
      bpms.push(songBpm(song));
      gates.push(songGatePercent(song));
      names.push((entry.role || "Song") + ": " + String(song.name || song.id || "music").slice(0, 28));

      for (var i = 0; i < count; i += 1) {
        melodyHalfUs.push(hzToHalfPeriodUs(midiToHz(melody[i])));
        bassHalfUs.push(hzToHalfPeriodUs(midiToHz(bass[i])));
        durations.push(Math.max(1, Math.min(255, Math.round(Number(durs[i]) || 12))));
      }
    });

    if (!lengths.length) {
      throw new Error("Assigned music has no note data.");
    }

    return [
      arduinoDisplayFoundation(),
      "#include <Arduino.h>",
      "#include <avr/pgmspace.h>",
      "#include <avr/interrupt.h>",
      "",
      "// SevenSeg Quest Maker standalone music hardware test",
      "// Target: Arduino Nano / ATmega328P",
      "// D3 = melody square wave. D9 = bass square wave.",
      "// D5 = next song. D4 = previous song.",
      "// Uses Timer1 and direct port writes so audio timing is stable.",
      "// This is intentionally separate from the combined game export.",
      "",
      "const uint8_t MELODY_PIN = 3;",
      "const uint8_t BASS_PIN = 9;",
      "const uint8_t NEXT_SONG_PIN = 5;",
      "const uint8_t PREV_SONG_PIN = 4;",
      "const uint8_t TICKS_PER_BEAT = 24;",
      "const uint8_t TIMER_TICK_US = 16;",
      "const unsigned long DEBOUNCE_MS = 40;",
      "const uint8_t MELODY_BIT = _BV(PD3);",
      "const uint8_t BASS_BIT = _BV(PB1);",
      "const uint8_t SEG_BLANK = 0x00;",
      "const uint8_t SEG_1 = 0x30;",
      "const uint8_t SEG_2 = 0x6D;",
      "const uint8_t SEG_3 = 0x79;",
      "const uint8_t SEG_9 = 0x7B;",
      "const uint8_t SEG_D = 0x3D;",
      "const uint8_t SEG_S = 0x5B;",
      "",
      "const uint16_t melodyHalfUs[] PROGMEM = {",
      numberLines(melodyHalfUs, 12),
      "};",
      "const uint16_t bassHalfUs[] PROGMEM = {",
      numberLines(bassHalfUs, 12),
      "};",
      "const uint8_t durationTicks[] PROGMEM = {",
      numberLines(durations, 16),
      "};",
      "const uint16_t songOffset[] PROGMEM = { " + numberList(offsets) + " };",
      "const uint16_t songLength[] PROGMEM = { " + numberList(lengths) + " };",
      "const uint16_t songBpm[] PROGMEM = { " + numberList(bpms) + " };",
      "const uint8_t songGatePercent[] PROGMEM = { " + numberList(gates) + " };",
      "const uint8_t SONG_COUNT = " + lengths.length + ";",
      "",
      names.map(function (name, index) {
        return "const char songName" + index + "[] PROGMEM = \"" + cStringLiteral(name) + "\";";
      }).join("\n"),
      "const char * const songNames[] PROGMEM = { " + names.map(function (_name, index) {
        return "songName" + index;
      }).join(", ") + " };",
      "",
      "uint8_t currentSong = 0;",
      "uint16_t currentEvent = 0;",
      "unsigned long eventStartMs = 0;",
      "unsigned long eventDurationMs = 1;",
      "unsigned long eventGateMs = 1;",
      "volatile uint16_t melodyHalfPeriodUs = 0;",
      "volatile uint16_t bassHalfPeriodUs = 0;",
      "volatile uint16_t melodyCounterUs = 0;",
      "volatile uint16_t bassCounterUs = 0;",
      "volatile uint8_t melodyOutState = 0;",
      "volatile uint8_t bassOutState = 0;",
      "volatile bool audioGateOpen = false;",
      "bool lastNextReading = HIGH;",
      "bool stableNextState = HIGH;",
      "unsigned long lastNextChange = 0;",
      "bool lastPrevReading = HIGH;",
      "bool stablePrevState = HIGH;",
      "unsigned long lastPrevChange = 0;",
      "",
      "uint16_t songEventOffset(uint8_t songIndex) { return pgm_read_word(&songOffset[songIndex]); }",
      "uint16_t songEventLength(uint8_t songIndex) { return pgm_read_word(&songLength[songIndex]); }",
      "uint16_t activeSongBpm() { return pgm_read_word(&songBpm[currentSong]); }",
      "uint8_t activeSongGate() { return pgm_read_byte(&songGatePercent[currentSong]); }",
      "",
      "void showTwoChars(uint8_t leftSegments, uint8_t rightSegments) {",
      "  clearDisplay();",
      "  setCell(3, 1, leftSegments);",
      "  setCell(4, 1, rightSegments);",
      "}",
      "",
      "void showSongStatus() {",
      "  clearDisplay();",
      "  setCell(3, 1, SEG_S);",
      "  setCell(4, 1, currentSong == 0 ? SEG_1 : SEG_2);",
      "}",
      "",
      "void blockingToneOnD3(uint16_t halfPeriodUs, uint16_t durationMs) {",
      "  uint32_t cycles = ((uint32_t)durationMs * 1000UL) / ((uint32_t)halfPeriodUs * 2UL);",
      "  noInterrupts();",
      "  for (uint32_t i = 0; i < cycles; i++) {",
      "    PORTD |= MELODY_BIT;",
      "    delayMicroseconds(halfPeriodUs);",
      "    PORTD &= ~MELODY_BIT;",
      "    delayMicroseconds(halfPeriodUs);",
      "  }",
      "  interrupts();",
      "}",
      "",
      "void blockingToneOnD9(uint16_t halfPeriodUs, uint16_t durationMs) {",
      "  uint32_t cycles = ((uint32_t)durationMs * 1000UL) / ((uint32_t)halfPeriodUs * 2UL);",
      "  noInterrupts();",
      "  for (uint32_t i = 0; i < cycles; i++) {",
      "    PORTB |= BASS_BIT;",
      "    delayMicroseconds(halfPeriodUs);",
      "    PORTB &= ~BASS_BIT;",
      "    delayMicroseconds(halfPeriodUs);",
      "  }",
      "  interrupts();",
      "}",
      "",
      "ISR(TIMER1_COMPA_vect) {",
      "  if (audioGateOpen && melodyHalfPeriodUs > 0) {",
      "    melodyCounterUs += TIMER_TICK_US;",
      "    if (melodyCounterUs >= melodyHalfPeriodUs) {",
      "      melodyCounterUs = 0;",
      "      melodyOutState ^= MELODY_BIT;",
      "      if (melodyOutState) PORTD |= MELODY_BIT;",
      "      else PORTD &= ~MELODY_BIT;",
      "    }",
      "  } else {",
      "    melodyOutState = 0;",
      "    PORTD &= ~MELODY_BIT;",
      "  }",
      "",
      "  if (audioGateOpen && bassHalfPeriodUs > 0) {",
      "    bassCounterUs += TIMER_TICK_US;",
      "    if (bassCounterUs >= bassHalfPeriodUs) {",
      "      bassCounterUs = 0;",
      "      bassOutState ^= BASS_BIT;",
      "      if (bassOutState) PORTB |= BASS_BIT;",
      "      else PORTB &= ~BASS_BIT;",
      "    }",
      "  } else {",
      "    bassOutState = 0;",
      "    PORTB &= ~BASS_BIT;",
      "  }",
      "}",
      "",
      "void setupTimer1Audio() {",
      "  noInterrupts();",
      "  TCCR1A = 0;",
      "  TCCR1B = 0;",
      "  TCNT1 = 0;",
      "  OCR1A = 31;",
      "  TCCR1B |= (1 << WGM12);",
      "  TCCR1B |= (1 << CS11);",
      "  TIMSK1 |= (1 << OCIE1A);",
      "  interrupts();",
      "}",
      "",
      "void setAudioGate(bool open) {",
      "  noInterrupts();",
      "  audioGateOpen = open;",
      "  if (!open) {",
      "    melodyOutState = 0;",
      "    bassOutState = 0;",
      "    PORTD &= ~MELODY_BIT;",
      "    PORTB &= ~BASS_BIT;",
      "  }",
      "  interrupts();",
      "}",
      "",
      "void setAudioPeriods(uint16_t melodyHalf, uint16_t bassHalf) {",
      "  noInterrupts();",
      "  melodyHalfPeriodUs = melodyHalf;",
      "  bassHalfPeriodUs = bassHalf;",
      "  melodyCounterUs = 0;",
      "  bassCounterUs = 0;",
      "  melodyOutState = 0;",
      "  bassOutState = 0;",
      "  PORTD &= ~MELODY_BIT;",
      "  PORTB &= ~BASS_BIT;",
      "  interrupts();",
      "}",
      "",
      "void printSongName(uint8_t songIndex) {",
      "  char buffer[36];",
      "  const char *ptr = (const char *)pgm_read_word(&songNames[songIndex]);",
      "  strncpy_P(buffer, ptr, sizeof(buffer) - 1);",
      "  buffer[sizeof(buffer) - 1] = '\\0';",
      "  Serial.print(F(\"Playing \"));",
      "  Serial.print(songIndex + 1);",
      "  Serial.print(F(\"/\"));",
      "  Serial.print(SONG_COUNT);",
      "  Serial.print(F(\": \"));",
      "  Serial.println(buffer);",
      "}",
      "",
      "void silenceVoices() {",
      "  setAudioGate(false);",
      "  setAudioPeriods(0, 0);",
      "}",
      "",
      "void loadCurrentEvent() {",
      "  uint16_t offset = songEventOffset(currentSong) + currentEvent;",
      "  uint8_t ticks = pgm_read_byte(&durationTicks[offset]);",
      "  uint16_t bpm = activeSongBpm();",
      "  uint8_t gate = activeSongGate();",
      "  uint16_t melodyHalf = pgm_read_word(&melodyHalfUs[offset]);",
      "  uint16_t bassHalf = pgm_read_word(&bassHalfUs[offset]);",
      "",
      "  eventDurationMs = ((unsigned long)ticks * 60000UL) / ((unsigned long)bpm * TICKS_PER_BEAT);",
      "  if (eventDurationMs < 15) eventDurationMs = 15;",
      "  eventGateMs = (eventDurationMs * gate) / 100;",
      "  if (eventGateMs < 8 && (melodyHalf > 0 || bassHalf > 0)) eventGateMs = 8;",
      "  setAudioPeriods(melodyHalf, bassHalf);",
      "  eventStartMs = millis();",
      "  setAudioGate(true);",
      "}",
      "",
      "void selectSong(uint8_t songIndex) {",
      "  if (songIndex >= SONG_COUNT) songIndex = 0;",
      "  currentSong = songIndex;",
      "  currentEvent = 0;",
      "  loadCurrentEvent();",
      "  printSongName(currentSong);",
      "  showSongStatus();",
      "}",
      "",
      "void updatePlayback() {",
      "  unsigned long elapsed = millis() - eventStartMs;",
      "  updateDisplayBrightness();",
      "",
      "  if (elapsed >= eventDurationMs) {",
      "    currentEvent++;",
      "    if (currentEvent >= songEventLength(currentSong)) {",
      "      currentEvent = 0;",
      "    }",
      "    loadCurrentEvent();",
      "    elapsed = 0;",
      "  }",
      "",
      "  setAudioGate(elapsed < eventGateMs);",
      "}",
      "",
      "bool buttonPressed(uint8_t pin, bool &lastReading, bool &stableState, unsigned long &lastChange) {",
      "  bool reading = digitalRead(pin);",
      "  unsigned long now = millis();",
      "",
      "  if (reading != lastReading) {",
      "    lastReading = reading;",
      "    lastChange = now;",
      "  }",
      "",
      "  if ((now - lastChange) >= DEBOUNCE_MS && reading != stableState) {",
      "    stableState = reading;",
      "    return stableState == LOW;",
      "  }",
      "",
      "  return false;",
      "}",
      "",
      "void readButtons() {",
      "  if (buttonPressed(NEXT_SONG_PIN, lastNextReading, stableNextState, lastNextChange)) {",
      "    selectSong((currentSong + 1) % SONG_COUNT);",
      "  }",
      "  if (buttonPressed(PREV_SONG_PIN, lastPrevReading, stablePrevState, lastPrevChange)) {",
      "    selectSong(currentSong == 0 ? SONG_COUNT - 1 : currentSong - 1);",
      "  }",
      "}",
      "",
      "void startupPinTest() {",
      "  Serial.println(F(\"D3 blocking pin test\"));",
      "  showTwoChars(SEG_D, SEG_3);",
      "  blockingToneOnD3(500, 1000);",
      "  delay(150);",
      "  Serial.println(F(\"D9 blocking pin test\"));",
      "  showTwoChars(SEG_D, SEG_9);",
      "  blockingToneOnD9(500, 1000);",
      "  delay(150);",
      "  Serial.println(F(\"D3 Timer1 pin test\"));",
      "  showTwoChars(SEG_D, SEG_3);",
      "  setAudioPeriods(1136, 0);",
      "  setAudioGate(true);",
      "  delay(500);",
      "  silenceVoices();",
      "  delay(150);",
      "  Serial.println(F(\"D9 Timer1 pin test\"));",
      "  showTwoChars(SEG_D, SEG_9);",
      "  setAudioPeriods(0, 4545);",
      "  setAudioGate(true);",
      "  delay(500);",
      "  silenceVoices();",
      "  delay(150);",
      "}",
      "",
      "void setup() {",
      "  initDisplay();",
      "  DDRD |= MELODY_BIT;",
      "  DDRB |= BASS_BIT;",
      "  pinMode(NEXT_SONG_PIN, INPUT_PULLUP);",
      "  pinMode(PREV_SONG_PIN, INPUT_PULLUP);",
      "  Serial.begin(9600);",
      "  Serial.println(F(\"SevenSeg music hardware test\"));",
      "  Serial.println(F(\"D5 next song, D4 previous song\"));",
      "  Serial.println(F(\"D3 melody, D9 bass\"));",
      "  setupTimer1Audio();",
      "  silenceVoices();",
      "  startupPinTest();",
      "  selectSong(0);",
      "}",
      "",
      "void loop() {",
      "  readButtons();",
      "  updatePlayback();",
      "}",
      ""
    ].join("\n");
  }

  function generateCombinedMusicRuntime(project) {
    var selectedSongs = assignedMusicSongs(project || {});
    var melodyHalfUs = [];
    var bassHalfUs = [];
    var durations = [];
    var offsets = [];
    var lengths = [];
    var bpms = [];
    var gates = [];

    selectedSongs.forEach(function (entry) {
      var song = entry.song;
      var channels = songChannels(song);
      var melody = Array.isArray(channels.melodyNotes) ? channels.melodyNotes : [];
      var bass = Array.isArray(channels.bassNotes) ? channels.bassNotes : [];
      var durs = Array.isArray(channels.durations) ? channels.durations : [];
      var count = songEventCount(song);

      if (count <= 0) {
        return;
      }

      offsets.push(melodyHalfUs.length);
      lengths.push(count);
      bpms.push(songBpm(song));
      gates.push(songGatePercent(song));

      for (var i = 0; i < count; i += 1) {
        melodyHalfUs.push(hzToHalfPeriodUs(midiToHz(melody[i])));
        bassHalfUs.push(hzToHalfPeriodUs(midiToHz(bass[i])));
        durations.push(Math.max(1, Math.min(255, Math.round(Number(durs[i]) || 12))));
      }
    });

    if (!lengths.length) {
      return [
        "void initAudio() {}",
        "void playWorldMusic() {}",
        "void playBattleMusic() {}",
        "void updateMusicPlayback() {}",
        "void audioDelay(unsigned long durationMs) {",
        "  unsigned long startedAt = millis();",
        "  while (millis() - startedAt < durationMs) {",
        "    updateDisplayBrightness();",
        "  }",
        "}",
        ""
      ].join("\n");
    }

    return [
      "const uint8_t AUDIO_MELODY_BIT = _BV(PD3);",
      "const uint8_t AUDIO_BASS_BIT = _BV(PB1);",
      "const uint8_t AUDIO_TICKS_PER_BEAT = 24;",
      "const uint8_t AUDIO_TIMER_TICK_US = 16;",
      "const uint8_t AUDIO_WORLD_SONG = 0;",
      "const uint8_t AUDIO_BATTLE_SONG = " + (lengths.length > 1 ? 1 : 0) + ";",
      "const uint8_t AUDIO_SONG_COUNT = " + lengths.length + ";",
      "",
      "const uint16_t audioMelodyHalfUs[] PROGMEM = {",
      numberLines(melodyHalfUs, 12),
      "};",
      "const uint16_t audioBassHalfUs[] PROGMEM = {",
      numberLines(bassHalfUs, 12),
      "};",
      "const uint8_t audioDurationTicks[] PROGMEM = {",
      numberLines(durations, 16),
      "};",
      "const uint16_t audioSongOffset[] PROGMEM = { " + numberList(offsets) + " };",
      "const uint16_t audioSongLength[] PROGMEM = { " + numberList(lengths) + " };",
      "const uint16_t audioSongBpm[] PROGMEM = { " + numberList(bpms) + " };",
      "const uint8_t audioSongGatePercent[] PROGMEM = { " + numberList(gates) + " };",
      "",
      "volatile uint16_t audioMelodyHalfPeriodUs = 0;",
      "volatile uint16_t audioBassHalfPeriodUs = 0;",
      "volatile uint16_t audioMelodyCounterUs = 0;",
      "volatile uint16_t audioBassCounterUs = 0;",
      "volatile uint8_t audioMelodyOutState = 0;",
      "volatile uint8_t audioBassOutState = 0;",
      "volatile bool audioGateOpen = false;",
      "uint8_t currentMusicSong = 255;",
      "uint16_t currentMusicEvent = 0;",
      "unsigned long musicEventStartMs = 0;",
      "unsigned long musicEventDurationMs = 1;",
      "unsigned long musicEventGateMs = 1;",
      "bool musicPlaying = false;",
      "",
      "uint16_t audioSongEventOffset(uint8_t songIndex) { return pgm_read_word(&audioSongOffset[songIndex]); }",
      "uint16_t audioSongEventLength(uint8_t songIndex) { return pgm_read_word(&audioSongLength[songIndex]); }",
      "uint16_t activeAudioSongBpm() { return pgm_read_word(&audioSongBpm[currentMusicSong]); }",
      "uint8_t activeAudioSongGate() { return pgm_read_byte(&audioSongGatePercent[currentMusicSong]); }",
      "",
      "ISR(TIMER1_COMPA_vect) {",
      "  if (audioGateOpen && audioMelodyHalfPeriodUs > 0) {",
      "    audioMelodyCounterUs += AUDIO_TIMER_TICK_US;",
      "    if (audioMelodyCounterUs >= audioMelodyHalfPeriodUs) {",
      "      audioMelodyCounterUs = 0;",
      "      audioMelodyOutState ^= AUDIO_MELODY_BIT;",
      "      if (audioMelodyOutState) PORTD |= AUDIO_MELODY_BIT;",
      "      else PORTD &= ~AUDIO_MELODY_BIT;",
      "    }",
      "  } else {",
      "    audioMelodyOutState = 0;",
      "    PORTD &= ~AUDIO_MELODY_BIT;",
      "  }",
      "",
      "  if (audioGateOpen && audioBassHalfPeriodUs > 0) {",
      "    audioBassCounterUs += AUDIO_TIMER_TICK_US;",
      "    if (audioBassCounterUs >= audioBassHalfPeriodUs) {",
      "      audioBassCounterUs = 0;",
      "      audioBassOutState ^= AUDIO_BASS_BIT;",
      "      if (audioBassOutState) PORTB |= AUDIO_BASS_BIT;",
      "      else PORTB &= ~AUDIO_BASS_BIT;",
      "    }",
      "  } else {",
      "    audioBassOutState = 0;",
      "    PORTB &= ~AUDIO_BASS_BIT;",
      "  }",
      "}",
      "",
      "void setAudioGate(bool open) {",
      "  noInterrupts();",
      "  audioGateOpen = open;",
      "  if (!open) {",
      "    audioMelodyOutState = 0;",
      "    audioBassOutState = 0;",
      "    PORTD &= ~AUDIO_MELODY_BIT;",
      "    PORTB &= ~AUDIO_BASS_BIT;",
      "  }",
      "  interrupts();",
      "}",
      "",
      "void setAudioPeriods(uint16_t melodyHalf, uint16_t bassHalf) {",
      "  noInterrupts();",
      "  audioMelodyHalfPeriodUs = melodyHalf;",
      "  audioBassHalfPeriodUs = bassHalf;",
      "  audioMelodyCounterUs = 0;",
      "  audioBassCounterUs = 0;",
      "  audioMelodyOutState = 0;",
      "  audioBassOutState = 0;",
      "  PORTD &= ~AUDIO_MELODY_BIT;",
      "  PORTB &= ~AUDIO_BASS_BIT;",
      "  interrupts();",
      "}",
      "",
      "void loadCurrentMusicEvent() {",
      "  uint16_t offset = audioSongEventOffset(currentMusicSong) + currentMusicEvent;",
      "  uint8_t ticks = pgm_read_byte(&audioDurationTicks[offset]);",
      "  uint16_t bpm = activeAudioSongBpm();",
      "  uint8_t gate = activeAudioSongGate();",
      "  uint16_t melodyHalf = pgm_read_word(&audioMelodyHalfUs[offset]);",
      "  uint16_t bassHalf = pgm_read_word(&audioBassHalfUs[offset]);",
      "  musicEventDurationMs = ((unsigned long)ticks * 60000UL) / ((unsigned long)bpm * AUDIO_TICKS_PER_BEAT);",
      "  if (musicEventDurationMs < 15) musicEventDurationMs = 15;",
      "  musicEventGateMs = (musicEventDurationMs * gate) / 100;",
      "  if (musicEventGateMs < 8 && (melodyHalf > 0 || bassHalf > 0)) musicEventGateMs = 8;",
      "  setAudioPeriods(melodyHalf, bassHalf);",
      "  musicEventStartMs = millis();",
      "  setAudioGate(true);",
      "}",
      "",
      "void playMusicSong(uint8_t songIndex) {",
      "  if (songIndex >= AUDIO_SONG_COUNT) songIndex = 0;",
      "  if (musicPlaying && currentMusicSong == songIndex) return;",
      "  currentMusicSong = songIndex;",
      "  currentMusicEvent = 0;",
      "  musicPlaying = true;",
      "  loadCurrentMusicEvent();",
      "}",
      "",
      "void playWorldMusic() { playMusicSong(AUDIO_WORLD_SONG); }",
      "void playBattleMusic() { playMusicSong(AUDIO_BATTLE_SONG); }",
      "",
      "void updateMusicPlayback() {",
      "  if (!musicPlaying || currentMusicSong >= AUDIO_SONG_COUNT) return;",
      "  unsigned long elapsed = millis() - musicEventStartMs;",
      "  if (elapsed >= musicEventDurationMs) {",
      "    currentMusicEvent++;",
      "    if (currentMusicEvent >= audioSongEventLength(currentMusicSong)) currentMusicEvent = 0;",
      "    loadCurrentMusicEvent();",
      "    elapsed = 0;",
      "  }",
      "  setAudioGate(elapsed < musicEventGateMs);",
      "}",
      "",
      "void initAudio() {",
      "  DDRD |= AUDIO_MELODY_BIT;",
      "  DDRB |= AUDIO_BASS_BIT;",
      "  noInterrupts();",
      "  TCCR1A = 0;",
      "  TCCR1B = 0;",
      "  TCNT1 = 0;",
      "  OCR1A = 31;",
      "  TCCR1B |= (1 << WGM12);",
      "  TCCR1B |= (1 << CS11);",
      "  TIMSK1 |= (1 << OCIE1A);",
      "  interrupts();",
      "  setAudioGate(false);",
      "  setAudioPeriods(0, 0);",
      "}",
      "",
      "void audioDelay(unsigned long durationMs) {",
      "  unsigned long startedAt = millis();",
      "  while (millis() - startedAt < durationMs) {",
      "    updateDisplayBrightness();",
      "    updateMusicPlayback();",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function generateBattleTestIno(project) {
    var safeProject = project || window.SevenSegModel.defaultProject;
    var battle = project && project.battle ? project.battle : {};
    var playerHp = Math.max(1, Math.min(99, Number(battle.playerHp) || 99));
    var beastHp = Math.max(1, Math.min(99, Number(battle.beastHp) || 50));
    var playerAttack = Math.max(1, Math.min(99, Number(battle.playerAttack) || 10));
    var playerHeal = Math.max(1, Math.min(99, Number(battle.playerHeal) || 50));

    return [
      arduinoDisplayFoundation(),
      "const uint8_t MENU_POT_PIN = A4;",
      "const uint8_t CONFIRM_BUTTON_PIN = 5;",
      "const uint8_t REJECT_BUTTON_PIN = 4;",
      "const unsigned long DEBOUNCE_MS = 40;",
      "const unsigned long BLINK_MS = 350;",
      "const uint8_t DP_BIT = 0x80;",
      "",
      "const uint8_t MODE_TIMER = 0;",
      "const uint8_t MODE_MENU = 1;",
      "const uint8_t MODE_TARGET = 2;",
      "const uint8_t MODE_MESSAGE = 3;",
      "const uint8_t MODE_ACTOR_PROMPT = 4;",
      "const uint8_t MENU_MAIN = 0;",
      "const uint8_t MENU_MAGIC = 1;",
      "const uint8_t MENU_ITEMS = 2;",
      "const uint8_t ACTION_HIT = 0;",
      "const uint8_t ACTION_HEAL = 1;",
      "const uint8_t ACTION_FENIX_DOWN = 2;",
      "const uint8_t ACTION_LIFE = 3;",
      "const uint8_t ACTION_POTION = 4;",
      "const uint8_t ACTOR_YOU1 = 0;",
      "const uint8_t ACTOR_YOU2 = 1;",
      "const uint8_t ACTOR_FOE1 = 2;",
      "const uint8_t ACTOR_FOE2 = 3;",
      "const uint8_t ACTOR_COUNT = 4;",
      "const uint8_t NO_ACTOR = 255;",
      "const uint16_t TIMER_FULL = 28800;",
      "const uint8_t TIMER_DOT_COUNT = 4;",
      "const unsigned long CHARGE_RENDER_MS = 50;",
      "const unsigned long ACTOR_PROMPT_ALTERNATE_MS = 800;",
      "",
      "uint8_t screenMode = MODE_TIMER;",
      "uint8_t currentMenu = MENU_MAIN;",
      "uint8_t pendingAction = ACTION_HIT;",
      "uint8_t selectedIndex = 0;",
      "uint8_t visibleStart = 0;",
      "uint8_t selectedTargetRow = 0;",
      "uint8_t currentActorIndex = NO_ACTOR;",
      "int8_t partyHp[2] = { " + playerHp + ", " + playerHp + " };",
      "int8_t foeHp[2] = { " + beastHp + ", " + beastHp + " };",
      "const int8_t INITIAL_PARTY_HP = " + playerHp + ";",
      "const int8_t INITIAL_FOE_HP = " + beastHp + ";",
      "const int8_t PLAYER_ATTACK = " + playerAttack + ";",
      "const int8_t PLAYER_HEAL = " + playerHeal + ";",
      "const int8_t FOE_ATTACK = 10;",
      "// Fixed B01 actor arrays: YOU1, YOU2, FOE1, FOE2.",
      "uint8_t actorSwiftness[ACTOR_COUNT] = { 10, 5, 1, 1 };",
      "uint16_t actorTimer[ACTOR_COUNT] = { 0, 0, 0, 0 };",
      "uint8_t readyQueue[ACTOR_COUNT] = { 0, 0, 0, 0 };",
      "uint8_t readyCount = 0;",
      "unsigned long lastTimerTick = 0;",
      "unsigned long lastChargeRender = 0;",
      "bool blinkOn = true;",
      "unsigned long lastBlink = 0;",
      "uint8_t actorPromptPage = 0;",
      "unsigned long lastActorPromptAlternate = 0;",
      "bool lastConfirmReading = HIGH;",
      "bool stableConfirmState = HIGH;",
      "unsigned long lastConfirmChange = 0;",
      "bool lastRejectReading = HIGH;",
      "bool stableRejectState = HIGH;",
      "unsigned long lastRejectChange = 0;",
      "",
      arduinoSegmentForCharFunction(safeProject),
      "",
      "void clearFrame(uint8_t frame[]) {",
      "  for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "    frame[i] = 0x00;",
      "  }",
      "}",
      "",
      "uint8_t textLength(const char *text) {",
      "  uint8_t length = 0;",
      "  while (text[length] != '\\0') {",
      "    length++;",
      "  }",
      "  return length;",
      "}",
      "",
      "void putTextAt(uint8_t frame[], uint8_t startIndex, const char *text, bool underline) {",
      "  for (uint8_t i = 0; text[i] != '\\0' && startIndex + i < DISPLAY_CELLS; i++) {",
      "    frame[startIndex + i] = segmentForChar(text[i]);",
      "    if (underline && blinkOn) {",
      "      frame[startIndex + i] |= DP_BIT;",
      "    }",
      "  }",
      "}",
      "",
      "void putTextRight(uint8_t frame[], uint8_t row, const char *text, bool underline) {",
      "  uint8_t length = textLength(text);",
      "  uint8_t startX = length >= DISPLAY_COLS ? 0 : DISPLAY_COLS - length;",
      "  putTextAt(frame, row * DISPLAY_COLS + startX, text, underline);",
      "}",
      "",
      "const char *mainMenuLabel(uint8_t index) {",
      "  switch (index) {",
      "    case 0: return \"HIT\";",
      "    case 1: return \"HEAL\";",
      "    case 2: return \"MAGIC\";",
      "    default: return \"ITEM\";",
      "  }",
      "}",
      "",
      "const char *magicMenuLabel(uint8_t index) {",
      "  switch (index) {",
      "    case 0: return \"M1\";",
      "    case 1: return \"M2\";",
      "    case 2: return \"M3\";",
      "    case 3: return \"M4\";",
      "    default: return \"M5\";",
      "  }",
      "}",
      "",
      "const char *itemMenuLabel(uint8_t index) {",
      "  switch (index) {",
      "    case 0: return \"IT1\";",
      "    case 1: return \"IT2\";",
      "    case 2: return \"IT3\";",
      "    case 3: return \"IT4\";",
      "    default: return \"IT5\";",
      "  }",
      "}",
      "",
      "uint8_t menuCount() {",
      "  if (currentMenu == MENU_MAIN) {",
      "    return 4;",
      "  }",
      "  return 5;",
      "}",
      "",
      "const char *menuLabel(uint8_t index) {",
      "  if (currentMenu == MENU_MAGIC) {",
      "    return magicMenuLabel(index);",
      "  }",
      "  if (currentMenu == MENU_ITEMS) {",
      "    return itemMenuLabel(index);",
      "  }",
      "  return mainMenuLabel(index);",
      "}",
      "",
      "uint8_t potToIndex(uint8_t count) {",
      "  uint16_t pot = analogRead(MENU_POT_PIN);",
      "  uint8_t index = (uint32_t)pot * count / 1024;",
      "  if (index >= count) {",
      "    index = count - 1;",
      "  }",
      "  return index;",
      "}",
      "",
      "void keepSelectionVisible() {",
      "  uint8_t count = menuCount();",
      "  uint8_t maxStart = count > DISPLAY_ROWS ? count - DISPLAY_ROWS : 0;",
      "",
      "  if (selectedIndex < visibleStart) {",
      "    visibleStart = selectedIndex;",
      "  }",
      "",
      "  if (selectedIndex >= visibleStart + DISPLAY_ROWS) {",
      "    visibleStart = selectedIndex - (DISPLAY_ROWS - 1);",
      "  }",
      "",
      "  if (visibleStart > maxStart) {",
      "    visibleStart = maxStart;",
      "  }",
      "}",
      "",
      "void drawActors(uint8_t frame[], int8_t blinkTarget, bool showBlink) {",
      "  if (foeHp[0] > 0 || (blinkTarget == 0 && showBlink)) frame[0] = segmentForChar('0');",
      "  if (partyHp[0] > 0 || (blinkTarget == 2 && showBlink)) frame[7] = segmentForChar('1');",
      "  if (foeHp[1] > 0 || (blinkTarget == 1 && showBlink)) frame[8] = segmentForChar('0');",
      "  if (partyHp[1] > 0 || (blinkTarget == 3 && showBlink)) frame[15] = segmentForChar('1');",
      "}",
      "",
      "const char *actorName(uint8_t actorIndex) {",
      "  if (actorIndex == ACTOR_YOU1) return \"YOU1\";",
      "  if (actorIndex == ACTOR_YOU2) return \"YOU2\";",
      "  if (actorIndex == ACTOR_FOE1) return \"FOE1\";",
      "  return \"FOE2\";",
      "}",
      "",
      "void stepCurrentActor(uint8_t frame[]) {",
      "  if (currentActorIndex == 0 && partyHp[0] > 0) { frame[7] = 0x00; frame[6] = segmentForChar('1'); }",
      "  if (currentActorIndex == 1 && partyHp[1] > 0) { frame[15] = 0x00; frame[14] = segmentForChar('1'); }",
      "}",
      "",
      "void clearBlinkActor(uint8_t frame[], int8_t target) {",
      "  if (target == 0) frame[0] = 0x00;",
      "  if (target == 1) frame[8] = 0x00;",
      "  if (target == 2) { frame[6] = 0x00; frame[7] = 0x00; }",
      "  if (target == 3) { frame[14] = 0x00; frame[15] = 0x00; }",
      "}",
      "",
      "bool actorIsHero(uint8_t actorIndex) {",
      "  return actorIndex == ACTOR_YOU1 || actorIndex == ACTOR_YOU2;",
      "}",
      "",
      "bool actorIsAlive(uint8_t actorIndex) {",
      "  if (actorIndex >= ACTOR_COUNT) return false;",
      "  if (actorIsHero(actorIndex)) return partyHp[actorIndex] > 0;",
      "  return foeHp[actorIndex - ACTOR_FOE1] > 0;",
      "}",
      "",
      "bool actorIsQueued(uint8_t actorIndex) {",
      "  for (uint8_t i = 0; i < readyCount; i++) {",
      "    if (readyQueue[i] == actorIndex) return true;",
      "  }",
      "  return false;",
      "}",
      "",
      "uint8_t timerDotCount(uint8_t actorIndex) {",
      "  if (!actorIsHero(actorIndex) || !actorIsAlive(actorIndex)) return 0;",
      "  uint32_t scaled = (uint32_t)actorTimer[actorIndex] * TIMER_DOT_COUNT;",
      "  uint8_t count = scaled / TIMER_FULL;",
      "  return count > TIMER_DOT_COUNT ? TIMER_DOT_COUNT : count;",
      "}",
      "",
      "void renderTextMenu() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  keepSelectionVisible();",
      "",
      "  for (uint8_t row = 0; row < DISPLAY_ROWS; row++) {",
      "    uint8_t itemIndex = visibleStart + row;",
      "    if (itemIndex < menuCount()) {",
      "      putTextRight(frame, row, menuLabel(itemIndex), itemIndex == selectedIndex);",
      "    }",
      "  }",
      "",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderTargetSelect() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "",
      "  if (pendingAction == ACTION_HIT) {",
      "    putTextAt(frame, 16, selectedTargetRow == 0 ? \"FOE1\" : \"FOE2\", true);",
      "    if (selectedTargetRow == 0) { frame[0] |= blinkOn ? DP_BIT : 0; frame[1] |= blinkOn ? DP_BIT : 0; }",
      "    else { frame[8] |= blinkOn ? DP_BIT : 0; frame[9] |= blinkOn ? DP_BIT : 0; }",
      "  } else {",
      "    putTextAt(frame, 20, selectedTargetRow == 0 ? \"YOU1\" : \"YOU2\", true);",
      "    if (selectedTargetRow == 0) { frame[6] |= blinkOn ? DP_BIT : 0; frame[7] |= blinkOn ? DP_BIT : 0; }",
      "    else { frame[14] |= blinkOn ? DP_BIT : 0; frame[15] |= blinkOn ? DP_BIT : 0; }",
      "  }",
      "",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderMessage(const char *message) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  putTextRight(frame, 1, message, false);",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderBattleEffect(uint8_t row, const char *text, uint8_t startX, int8_t blinkTarget, bool stepActor) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  if (stepActor) stepCurrentActor(frame);",
      "  if (blinkTarget >= 0) clearBlinkActor(frame, blinkTarget);",
      "  putTextAt(frame, row * 8 + startX, text, false);",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderBattleLine(uint8_t activeFoe, uint8_t activeParty, const char *text) {",
      "  renderBattleEffect(activeFoe, text, 2, -1, false);",
      "}",
      "",
      "void renderProjectileStep(uint8_t cellIndex, uint8_t segmentBits, bool stepActor) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  if (stepActor) stepCurrentActor(frame);",
      "  frame[cellIndex] = segmentBits;",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderCharging() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  uint8_t you1Dots = timerDotCount(ACTOR_YOU1);",
      "  uint8_t you2Dots = timerDotCount(ACTOR_YOU2);",
      "  for (uint8_t i = 0; i < you1Dots; i++) {",
      "    frame[4 + i] |= DP_BIT;",
      "  }",
      "  for (uint8_t i = 0; i < you2Dots; i++) {",
      "    frame[12 + i] |= DP_BIT;",
      "  }",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderActorPrompt() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  stepCurrentActor(frame);",
      "  putTextAt(frame, 20, actorName(currentActorIndex), true);",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void showActorPrompt() {",
      "  screenMode = MODE_ACTOR_PROMPT;",
      "  blinkOn = true;",
      "  lastBlink = millis();",
      "  renderActorPrompt();",
      "}",
      "",
      "void showMenu(uint8_t menu) {",
      "  currentMenu = menu;",
      "  selectedIndex = 0;",
      "  visibleStart = 0;",
      "  screenMode = MODE_MENU;",
      "  blinkOn = true;",
      "  lastBlink = millis();",
      "  renderTextMenu();",
      "}",
      "",
      "uint8_t firstAlive(const int8_t values[]) {",
      "  for (uint8_t i = 0; i < 2; i++) {",
      "    if (values[i] > 0) return i;",
      "  }",
      "  return 0;",
      "}",
      "",
      "void showTarget(uint8_t action) {",
      "  pendingAction = action;",
      "  selectedTargetRow = action == ACTION_HIT ? firstAlive(foeHp) : currentActorIndex;",
      "  screenMode = MODE_TARGET;",
      "  blinkOn = true;",
      "  lastBlink = millis();",
      "  renderTargetSelect();",
      "}",
      "",
      "bool allFoesDown() {",
      "  return foeHp[0] <= 0 && foeHp[1] <= 0;",
      "}",
      "",
      "bool allPartyDown() {",
      "  return partyHp[0] <= 0 && partyHp[1] <= 0;",
      "}",
      "",
      "bool actionAllowsDeadPartyTarget(uint8_t action) {",
      "  return action == ACTION_FENIX_DOWN || action == ACTION_LIFE;",
      "}",
      "",
      "bool targetIsSelectable(uint8_t action, uint8_t targetRow) {",
      "  if (targetRow >= 2) return false;",
      "  if (action == ACTION_HIT) return foeHp[targetRow] > 0;",
      "  return partyHp[targetRow] > 0 || actionAllowsDeadPartyTarget(action);",
      "}",
      "",
      "void removeDeadReadyActors() {",
      "  uint8_t writeIndex = 0;",
      "  for (uint8_t readIndex = 0; readIndex < readyCount; readIndex++) {",
      "    uint8_t actorIndex = readyQueue[readIndex];",
      "    if (actorIsAlive(actorIndex)) {",
      "      readyQueue[writeIndex++] = actorIndex;",
      "    }",
      "  }",
      "  readyCount = writeIndex;",
      "}",
      "",
      "uint8_t randomLivingParty() {",
      "  uint8_t living[2];",
      "  uint8_t count = 0;",
      "  for (uint8_t i = 0; i < 2; i++) {",
      "    if (partyHp[i] > 0) living[count++] = i;",
      "  }",
      "  if (count == 0) return NO_ACTOR;",
      "  return living[random(count)];",
      "}",
      "",
      "void beginCharging() {",
      "  screenMode = MODE_TIMER;",
      "  currentActorIndex = NO_ACTOR;",
      "  lastTimerTick = millis();",
      "  lastChargeRender = lastTimerTick;",
      "  renderCharging();",
      "}",
      "",
      "void resetBattle() {",
      "  partyHp[0] = INITIAL_PARTY_HP;",
      "  partyHp[1] = INITIAL_PARTY_HP;",
      "  foeHp[0] = INITIAL_FOE_HP;",
      "  foeHp[1] = INITIAL_FOE_HP;",
      "  actorSwiftness[ACTOR_YOU1] = 10;",
      "  actorSwiftness[ACTOR_YOU2] = 5;",
      "  actorSwiftness[ACTOR_FOE1] = random(1, 11);",
      "  actorSwiftness[ACTOR_FOE2] = random(1, 11);",
      "  for (uint8_t i = 0; i < ACTOR_COUNT; i++) actorTimer[i] = 0;",
      "  readyCount = 0;",
      "  currentActorIndex = NO_ACTOR;",
      "  currentMenu = MENU_MAIN;",
      "  pendingAction = ACTION_HIT;",
      "  selectedIndex = 0;",
      "  visibleStart = 0;",
      "  selectedTargetRow = 0;",
      "  Serial.print(F(\"Foe swiftness: \"));",
      "  Serial.print(actorSwiftness[ACTOR_FOE1]);",
      "  Serial.print('/');",
      "  Serial.println(actorSwiftness[ACTOR_FOE2]);",
      "  beginCharging();",
      "}",
      "",
      "void finishBattle(const char *message) {",
      "  screenMode = MODE_MESSAGE;",
      "  renderMessage(message);",
      "  delay(1000);",
      "  clearDisplay();",
      "  delay(1000);",
      "  resetBattle();",
      "}",
      "",
      "void enqueueNewlyReady(const uint8_t actors[], const uint32_t scores[], uint8_t count) {",
      "  bool used[ACTOR_COUNT] = { false, false, false, false };",
      "  for (uint8_t output = 0; output < count && readyCount < ACTOR_COUNT; output++) {",
      "    int8_t best = -1;",
      "    for (uint8_t candidate = 0; candidate < count; candidate++) {",
      "      if (used[candidate]) continue;",
      "      if (best < 0 || scores[candidate] > scores[(uint8_t)best] ||",
      "          (scores[candidate] == scores[(uint8_t)best] && actors[candidate] < actors[(uint8_t)best])) {",
      "        best = candidate;",
      "      }",
      "    }",
      "    if (best >= 0) {",
      "      used[(uint8_t)best] = true;",
      "      readyQueue[readyCount++] = actors[(uint8_t)best];",
      "    }",
      "  }",
      "}",
      "",
      "void startNextReadyActor() {",
      "  removeDeadReadyActors();",
      "  if (allFoesDown()) { finishBattle(\"VICTORY\"); return; }",
      "  if (allPartyDown()) { finishBattle(\"GAMEOVER\"); return; }",
      "  if (readyCount == 0) { beginCharging(); return; }",
      "",
      "  currentActorIndex = readyQueue[0];",
      "  for (uint8_t i = 1; i < readyCount; i++) readyQueue[i - 1] = readyQueue[i];",
      "  readyCount--;",
      "",
      "  if (actorIsHero(currentActorIndex)) {",
      "    showActorPrompt();",
      "  } else {",
      "    enemyTurn(currentActorIndex);",
      "  }",
      "}",
      "",
      "void completeCurrentActorAction() {",
      "  if (allFoesDown()) { finishBattle(\"VICTORY\"); return; }",
      "  if (allPartyDown()) { finishBattle(\"GAMEOVER\"); return; }",
      "  if (currentActorIndex < ACTOR_COUNT) actorTimer[currentActorIndex] = 0;",
      "  currentActorIndex = NO_ACTOR;",
      "  removeDeadReadyActors();",
      "  if (readyCount > 0) startNextReadyActor();",
      "  else beginCharging();",
      "}",
      "",
      "void updateActorTimers() {",
      "  if (screenMode != MODE_TIMER) return;",
      "  unsigned long now = millis();",
      "  unsigned long elapsed = now - lastTimerTick;",
      "  if (elapsed == 0) return;",
      "  lastTimerTick = now;",
      "",
      "  uint8_t newlyReady[ACTOR_COUNT];",
      "  uint32_t readyScore[ACTOR_COUNT];",
      "  uint8_t newlyReadyCount = 0;",
      "",
      "  for (uint8_t actorIndex = 0; actorIndex < ACTOR_COUNT; actorIndex++) {",
      "    if (!actorIsAlive(actorIndex) || actorIsQueued(actorIndex)) continue;",
      "    uint32_t nextTimer = (uint32_t)actorTimer[actorIndex] + elapsed * actorSwiftness[actorIndex];",
      "    actorTimer[actorIndex] = nextTimer >= TIMER_FULL ? TIMER_FULL : (uint16_t)nextTimer;",
      "    if (actorTimer[actorIndex] >= TIMER_FULL) {",
      "      newlyReady[newlyReadyCount] = actorIndex;",
      "      readyScore[newlyReadyCount] = nextTimer;",
      "      newlyReadyCount++;",
      "    }",
      "  }",
      "",
      "  if (newlyReadyCount > 0) {",
      "    enqueueNewlyReady(newlyReady, readyScore, newlyReadyCount);",
      "    startNextReadyActor();",
      "    return;",
      "  }",
      "",
      "  if (now - lastChargeRender >= CHARGE_RENDER_MS) {",
      "    lastChargeRender = now;",
      "    renderCharging();",
      "  }",
      "}",
      "",
      "void blinkDefeated(int8_t target) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  for (uint8_t i = 0; i < 6; i++) {",
      "    clearFrame(frame);",
      "    drawActors(frame, target, i % 2 == 0);",
      "    renderFrameRaw24(frame);",
      "    delay(170);",
      "  }",
      "}",
      "",
      "void returnToMenu() {",
      "  showMenu(MENU_MAIN);",
      "}",
      "",
      "void makeDamageText(char text[], uint8_t amount) {",
      "  if (amount > 99) amount = 99;",
      "  text[0] = '-';",
      "  if (amount >= 10) {",
      "    text[1] = (char)('0' + amount / 10);",
      "    text[2] = (char)('0' + amount % 10);",
      "    text[3] = '\\0';",
      "  } else {",
      "    text[1] = (char)('0' + amount);",
      "    text[2] = '\\0';",
      "  }",
      "}",
      "",
      "void makeUnsignedText(char text[], uint8_t amount) {",
      "  if (amount > 99) amount = 99;",
      "  if (amount >= 10) {",
      "    text[0] = (char)('0' + amount / 10);",
      "    text[1] = (char)('0' + amount % 10);",
      "    text[2] = '\\0';",
      "  } else {",
      "    text[0] = (char)('0' + amount);",
      "    text[1] = '\\0';",
      "  }",
      "}",
      "",
      "void enemyTurn(uint8_t foeActorIndex) {",
      "  if (foeActorIndex < ACTOR_FOE1 || foeActorIndex > ACTOR_FOE2 || !actorIsAlive(foeActorIndex)) {",
      "    completeCurrentActorAction();",
      "    return;",
      "  }",
      "  uint8_t party = randomLivingParty();",
      "  if (party == NO_ACTOR) { finishBattle(\"GAMEOVER\"); return; }",
      "  screenMode = MODE_MESSAGE;",
      "  char damageText[4];",
      "  makeDamageText(damageText, FOE_ATTACK);",
      "  renderBattleEffect(party, damageText, 4, 2 + party, false);",
      "  delay(170);",
      "  renderBattleEffect(party, damageText, 4, -1, false);",
      "  delay(280);",
      "  int8_t oldHp = partyHp[party];",
      "  partyHp[party] -= FOE_ATTACK;",
      "  if (partyHp[party] < 0) partyHp[party] = 0;",
      "  if (oldHp > 0 && partyHp[party] <= 0) {",
      "    blinkDefeated(2 + party);",
      "  }",
      "  completeCurrentActorAction();",
      "}",
      "",
      "void finishAction() {",
      "  if (pendingAction == ACTION_HIT) {",
      "    if (!targetIsSelectable(pendingAction, selectedTargetRow)) {",
      "      renderMessage(\"DEAD\");",
      "      delay(700);",
      "      renderTargetSelect();",
      "      return;",
      "    }",
      "    if (currentActorIndex == 0 && selectedTargetRow == 1) {",
      "      uint8_t pathCells[4] = { 5, 4, 10, 9 };",
      "      uint8_t pathSegments[4] = { 0x01, 0x08, 0x40, 0x01 };",
      "      for (uint8_t i = 0; i < 4; i++) {",
      "        renderProjectileStep(pathCells[i], pathSegments[i], i < 2);",
      "        delay(110);",
      "      }",
      "    } else {",
      "      for (int8_t projectileX = 5; projectileX >= 2; projectileX--) {",
      "        renderProjectileStep(selectedTargetRow * 8 + (uint8_t)projectileX, segmentForChar('-'), projectileX >= 4);",
      "        delay(110);",
      "      }",
      "    }",
      "    char damageText[4];",
      "    makeDamageText(damageText, PLAYER_ATTACK);",
      "    renderBattleEffect(selectedTargetRow, damageText, 2, selectedTargetRow, false);",
      "    delay(170);",
      "    renderBattleEffect(selectedTargetRow, damageText, 2, -1, false);",
      "    delay(280);",
      "    int8_t oldHp = foeHp[selectedTargetRow];",
      "    foeHp[selectedTargetRow] -= PLAYER_ATTACK;",
      "    if (foeHp[selectedTargetRow] < 0) foeHp[selectedTargetRow] = 0;",
      "    if (oldHp > 0 && foeHp[selectedTargetRow] <= 0) {",
      "      blinkDefeated(selectedTargetRow);",
      "    }",
      "  } else {",
      "    if (!targetIsSelectable(pendingAction, selectedTargetRow)) {",
      "      renderMessage(\"DEAD\");",
      "      delay(700);",
      "      renderTargetSelect();",
      "      return;",
      "    }",
      "    int16_t missingHp = 99 - (int16_t)partyHp[selectedTargetRow];",
      "    if (missingHp < 0) missingHp = 0;",
      "    uint8_t appliedHeal = PLAYER_HEAL > (uint8_t)missingHp ? (uint8_t)missingHp : PLAYER_HEAL;",
      "    char healText[3];",
      "    makeUnsignedText(healText, appliedHeal);",
      "    renderBattleEffect(selectedTargetRow, healText, 4, 2 + selectedTargetRow, true);",
      "    delay(170);",
      "    renderBattleEffect(selectedTargetRow, healText, 4, -1, true);",
      "    delay(280);",
      "    partyHp[selectedTargetRow] += appliedHeal;",
      "  }",
      "",
      "  completeCurrentActorAction();",
      "}",
      "",
      "void confirmMenuItem() {",
      "  if (currentMenu == MENU_MAIN) {",
      "    if (selectedIndex == 0) {",
      "      showTarget(ACTION_HIT);",
      "    } else if (selectedIndex == 1) {",
      "      showTarget(ACTION_HEAL);",
      "    } else if (selectedIndex == 2) {",
      "      showMenu(MENU_MAGIC);",
      "    } else {",
      "      showMenu(MENU_ITEMS);",
      "    }",
      "  } else {",
      "    renderMessage(menuLabel(selectedIndex));",
      "    delay(700);",
      "    completeCurrentActorAction();",
      "  }",
      "}",
      "",
      "bool debouncedPress(uint8_t pin, bool &lastReading, bool &stableState, unsigned long &lastChange) {",
      "  bool reading = digitalRead(pin);",
      "  if (reading != lastReading) {",
      "    lastChange = millis();",
      "    lastReading = reading;",
      "  }",
      "  if ((millis() - lastChange) >= DEBOUNCE_MS && reading != stableState) {",
      "    stableState = reading;",
      "    return stableState == LOW;",
      "  }",
      "  return false;",
      "}",
      "",
      "void handleConfirm() {",
      "  if (screenMode == MODE_ACTOR_PROMPT) {",
      "    showMenu(MENU_MAIN);",
      "  } else if (screenMode == MODE_MENU) {",
      "    confirmMenuItem();",
      "  } else if (screenMode == MODE_TARGET) {",
      "    finishAction();",
      "  }",
      "}",
      "",
      "void handleReject() {",
      "  if (screenMode == MODE_MENU && currentMenu != MENU_MAIN) {",
      "    showMenu(MENU_MAIN);",
      "  } else if (screenMode == MODE_TARGET) {",
      "    showMenu(MENU_MAIN);",
      "  }",
      "}",
      "",
      "void updatePotSelection() {",
      "  if (screenMode == MODE_MENU) {",
      "    uint8_t nextIndex = potToIndex(menuCount());",
      "    if (nextIndex != selectedIndex) {",
      "      selectedIndex = nextIndex;",
      "      renderTextMenu();",
      "    }",
      "  } else if (screenMode == MODE_TARGET) {",
      "    uint8_t nextRow = potToIndex(2);",
      "    if (!targetIsSelectable(pendingAction, nextRow)) {",
      "      nextRow = pendingAction == ACTION_HIT ? firstAlive(foeHp) : firstAlive(partyHp);",
      "    }",
      "    if (nextRow != selectedTargetRow) {",
      "      selectedTargetRow = nextRow;",
      "      renderTargetSelect();",
      "    }",
      "  }",
      "}",
      "",
      "void updateBlink() {",
      "  if (screenMode != MODE_MENU && screenMode != MODE_TARGET && screenMode != MODE_ACTOR_PROMPT) {",
      "    return;",
      "  }",
      "  if (millis() - lastBlink >= BLINK_MS) {",
      "    lastBlink = millis();",
      "    blinkOn = !blinkOn;",
      "    if (screenMode == MODE_MENU) renderTextMenu();",
      "    if (screenMode == MODE_TARGET) renderTargetSelect();",
      "    if (screenMode == MODE_ACTOR_PROMPT) renderActorPrompt();",
      "  }",
      "}",
      "",
      "void printHelp() {",
      "  Serial.println(F(\"SevenSeg Standalone Battle Test\"));",
      "  Serial.println(F(\"A4 pot = choose menu item or target row\"));",
      "  Serial.println(F(\"D5 LOW = confirm\"));",
      "  Serial.println(F(\"D4 LOW = reject/back\"));",
      "}",
      "",
      "void setup() {",
      "  Serial.begin(9600);",
      "  pinMode(CONFIRM_BUTTON_PIN, INPUT_PULLUP);",
      "  pinMode(REJECT_BUTTON_PIN, INPUT_PULLUP);",
      "  initDisplay();",
      "  printHelp();",
      "  randomSeed((unsigned long)analogRead(MENU_POT_PIN) ^ micros());",
      "  resetBattle();",
      "}",
      "",
      "void loop() {",
      "  updateDisplayBrightness();",
      "  updateActorTimers();",
      "  updatePotSelection();",
      "  updateBlink();",
      "  if (debouncedPress(CONFIRM_BUTTON_PIN, lastConfirmReading, stableConfirmState, lastConfirmChange)) {",
      "    handleConfirm();",
      "  }",
      "  if (debouncedPress(REJECT_BUTTON_PIN, lastRejectReading, stableRejectState, lastRejectChange)) {",
      "    handleReject();",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function generateCombinedGameIno(project) {
    assertCombinedGameExportable(project);
    var safeProject = project || window.SevenSegModel.defaultProject;
    var start = safeProject.start || { roomX: 0, roomY: 0, playerX: 0, playerY: 0 };
    var battle = safeProject.battle || {};
    var hardware = window.SevenSegModel.normalizeHardwareSettings(safeProject);
    var startingHeroId = safeProject.gameFlow && safeProject.gameFlow.startingHeroIds ?
      safeProject.gameFlow.startingHeroIds[0] :
      "";
    var starterHero = (safeProject.heroes || []).filter(function (hero) {
      return hero && hero.id === startingHeroId;
    })[0] || (safeProject.heroes || [])[0] || {};
    var starterStats = starterHero.stats || {};
    var playerHp = Math.max(1, Math.min(99,
      Number(starterStats.maxHP || starterStats.maxHp || starterStats.currentHP || battle.playerHp) || 99
    ));
    var beastHp = Math.max(1, Math.min(99, Number(battle.beastHp) || 50));
    var playerAttack = Math.max(1, Math.min(99,
      Number(starterStats.attackPower || starterStats.attack || battle.playerAttack) || 10
    ));
    var playerHeal = Math.max(1, Math.min(99,
      Number(starterStats.healPower || starterStats.healing || starterStats.heal || battle.playerHeal) || 50
    ));

    return [
      arduinoDisplayFoundation(),
      "#include <avr/pgmspace.h>",
      "#include <avr/interrupt.h>",
      "#include <EEPROM.h>",
      arduinoSegmentForCharFunction(safeProject),
      "// Combined worldmap + battle hardware test.",
      "// Worldmap mode: A4 = facing, D5 = move forward, D4 = move backward.",
      "// Battle mode: A4 = choose menu/target, D5 = confirm, D4 = reject/back.",
      "// Every successful worldmap move has a 10 percent chance to start battle.",
      generateCompressedWorldmapData(safeProject),
      generateMinimalRpgPackedData(safeProject),
      generateCombinedMusicRuntime(safeProject),
      "",
      "const uint8_t CONTROL_POT_PIN = A4;",
      "const uint8_t CONFIRM_BUTTON_PIN = 5;",
      "const uint8_t REJECT_BUTTON_PIN = 4;",
      "const unsigned long DEBOUNCE_MS = 40;",
      "const unsigned long HOLD_REPEAT_START_MS = 500;",
      "const unsigned long HOLD_REPEAT_INTERVAL_MS = 200;",
      "const unsigned long SYSTEM_MENU_HOLD_MS = 1000;",
      "const uint16_t TRANSITION_ANIMATION_TIME_MS = " + hardware.transitionAnimationMs + ";",
      "const bool SHOW_ROOM_COORDINATES = " + (hardware.showCoordinates ? "true" : "false") + ";",
      "const uint16_t ROOM_COORDINATE_TIME_MS = " + hardware.coordinateTimeMs + ";",
      "const unsigned long BLINK_MS = 350;",
      "const uint8_t DP_BIT = 0x80;",
      "const uint8_t MODE_WORLD = 0;",
      "const uint8_t MODE_MENU = 1;",
      "const uint8_t MODE_TARGET = 2;",
      "const uint8_t MODE_ACTOR_PROMPT = 3;",
      "const uint8_t MODE_CHARGING = 4;",
      "const uint8_t MODE_BATTLE_MESSAGE = 5;",
      "const uint8_t MODE_SYSTEM_MENU = 6;",
      "const uint8_t MENU_MAIN = 0;",
      "const uint8_t MENU_MAGIC = 1;",
      "const uint8_t MENU_ITEMS = 2;",
      "const uint8_t ACTION_HIT = 0;",
      "const uint8_t ACTION_HEAL = 1;",
      "const uint8_t ACTION_FENIX_DOWN = 2;",
      "const uint8_t ACTION_LIFE = 3;",
      "const uint8_t ACTION_POTION = 4;",
      "const uint8_t ACTOR_YOU1 = 0;",
      "const uint8_t ACTOR_YOU2 = 1;",
      "const uint8_t ACTOR_FOE1 = 2;",
      "const uint8_t ACTOR_FOE2 = 3;",
      "const uint8_t ACTOR_COUNT = 4;",
      "const uint8_t NO_ACTOR = 255;",
      "const uint16_t TIMER_FULL = 28800;",
      "const uint8_t TIMER_DOT_COUNT = 4;",
      "const unsigned long CHARGE_RENDER_MS = 50;",
      "const unsigned long ACTOR_PROMPT_ALTERNATE_MS = 800;",
      "",
      "uint8_t gameMode = MODE_WORLD;",
      "uint8_t currentMenu = MENU_MAIN;",
      "uint8_t selectedIndex = 0;",
      "uint8_t visibleStart = 0;",
      "uint8_t pendingAction = ACTION_HIT;",
      "uint8_t selectedTargetRow = 0;",
      "uint8_t currentActorIndex = NO_ACTOR;",
      "uint16_t currentRoomIndex = 0;",
      "uint8_t playerX = " + Math.max(0, Math.min(7, Number(start.playerX) || 0)) + ";",
      "uint8_t playerY = " + Math.max(0, Math.min(2, Number(start.playerY) || 0)) + ";",
      "int8_t partyHp[2];",
      "int8_t foeHp[2];",
      "const int8_t START_PLAYER_HP = " + playerHp + ";",
      "const int8_t START_FOE_HP = " + beastHp + ";",
      "const int8_t PLAYER_ATTACK = " + playerAttack + ";",
      "const int8_t PLAYER_HEAL = " + playerHeal + ";",
      "const int8_t FOE_ATTACK = 10;",
      "uint8_t storyFlags = 0;",
      "uint8_t equipmentFlags = 0;",
      "uint8_t chestFlags = 0;",
      "uint8_t gold = 0;",
      "uint8_t potionCount = 0;",
      "uint8_t heroLevel = 1;",
      "uint8_t heroXp = 0;",
      "uint8_t heroXpNext = 20;",
      "uint8_t heroMaxHp = START_PLAYER_HP;",
      "uint8_t heroCurrentHp = START_PLAYER_HP;",
      "uint8_t heroAttack = PLAYER_ATTACK;",
      "uint8_t activeEnemyIndex = 0;",
      "bool activeEncounterFinalBoss = false;",
      "bool systemMenuComboArmed = false;",
      "bool systemMenuOpened = false;",
      "unsigned long systemMenuHoldStart = 0;",
      "const uint8_t SAVE_MAGIC = 0x57;",
      "const uint8_t SAVE_VERSION = 1;",
      "const int SAVE_EEPROM_ADDRESS = 0;",
      "// Fixed B01 actor arrays: YOU1, YOU2, FOE1, FOE2.",
      "uint8_t actorSwiftness[ACTOR_COUNT] = { 10, 5, 1, 1 };",
      "uint16_t actorTimer[ACTOR_COUNT] = { 0, 0, 0, 0 };",
      "uint8_t readyQueue[ACTOR_COUNT] = { 0, 0, 0, 0 };",
      "uint8_t readyCount = 0;",
      "unsigned long lastTimerTick = 0;",
      "unsigned long lastChargeRender = 0;",
      "bool blinkOn = true;",
      "unsigned long lastBlink = 0;",
      "uint8_t actorPromptPage = 0;",
      "unsigned long lastActorPromptAlternate = 0;",
      "bool lastConfirmReading = HIGH;",
      "bool stableConfirmState = HIGH;",
      "unsigned long lastConfirmChange = 0;",
      "unsigned long confirmHoldStart = 0;",
      "unsigned long lastConfirmRepeat = 0;",
      "bool lastRejectReading = HIGH;",
      "bool stableRejectState = HIGH;",
      "unsigned long lastRejectChange = 0;",
      "unsigned long rejectHoldStart = 0;",
      "unsigned long lastRejectRepeat = 0;",
      "bool movementLockedUntilRelease = false;",
      "",
      "struct SaveState {",
      "  uint8_t magic;",
      "  uint8_t version;",
      "  uint16_t roomIndex;",
      "  uint8_t playerX;",
      "  uint8_t playerY;",
      "  uint8_t storyFlags;",
      "  uint8_t equipmentFlags;",
      "  uint8_t chestFlags;",
      "  uint8_t gold;",
      "  uint8_t potionCount;",
      "  uint8_t heroLevel;",
      "  uint8_t heroXp;",
      "  uint8_t heroXpNext;",
      "  uint8_t heroMaxHp;",
      "  uint8_t heroCurrentHp;",
      "  uint8_t heroAttack;",
      "  uint8_t checksum;",
      "};",
      "",
      "void clearFrame(uint8_t frame[]) {",
      "  for (uint8_t i = 0; i < DISPLAY_CELLS; i++) frame[i] = 0x00;",
      "}",
      "",
      "uint8_t textLength(const char *text) {",
      "  uint8_t length = 0;",
      "  while (text[length] != '\\0') length++;",
      "  return length;",
      "}",
      "",
      "void putTextAt(uint8_t frame[], uint8_t startIndex, const char *text, bool underline) {",
      "  for (uint8_t i = 0; text[i] != '\\0' && startIndex + i < DISPLAY_CELLS; i++) {",
      "    frame[startIndex + i] = segmentForChar(text[i]);",
      "    if (underline && blinkOn) frame[startIndex + i] |= DP_BIT;",
      "  }",
      "}",
      "",
      "void putTextRight(uint8_t frame[], uint8_t row, const char *text, bool underline) {",
      "  uint8_t length = textLength(text);",
      "  uint8_t startX = length >= DISPLAY_COLS ? 0 : DISPLAY_COLS - length;",
      "  putTextAt(frame, row * DISPLAY_COLS + startX, text, underline);",
      "}",
      "",
      "void waitWorldButtonsReleased() {",
      "  while (digitalRead(CONFIRM_BUTTON_PIN) == LOW || digitalRead(REJECT_BUTTON_PIN) == LOW) {",
      "    updateDisplayBrightness();",
      "    updateMusicPlayback();",
      "  }",
      "  audioDelay(30);",
      "}",
      "",
      "void waitAnyWorldButton() {",
      "  waitWorldButtonsReleased();",
      "  while (digitalRead(CONFIRM_BUTTON_PIN) == HIGH && digitalRead(REJECT_BUTTON_PIN) == HIGH) {",
      "    updateDisplayBrightness();",
      "    updateMusicPlayback();",
      "  }",
      "  audioDelay(30);",
      "  waitWorldButtonsReleased();",
      "}",
      "",
      "void renderTextPage(const char page[]) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "    char c = page[i];",
      "    if (c == '\\0') c = ' ';",
      "    frame[i] = segmentForChar(c);",
      "  }",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void showMessagePaged(const char text[]) {",
      "  uint8_t offset = 0;",
      "  char page[DISPLAY_CELLS + 1];",
      "  bool hasMore = true;",
      "  while (hasMore) {",
      "    bool ended = false;",
      "    for (uint8_t i = 0; i < DISPLAY_CELLS; i++) {",
      "      char c = ended ? '\\0' : text[offset + i];",
      "      if (c == '\\0') { ended = true; page[i] = ' '; }",
      "      else { page[i] = c; }",
      "    }",
      "    hasMore = !ended && text[offset + DISPLAY_CELLS] != '\\0';",
      "    page[DISPLAY_CELLS] = '\\0';",
      "    renderTextPage(page);",
      "    waitAnyWorldButton();",
      "    offset += DISPLAY_CELLS;",
      "  }",
      "}",
      "",
      "uint8_t saveChecksumBytes(const uint8_t *data, uint8_t length) {",
      "  uint8_t sum = 0;",
      "  for (uint8_t i = 0; i < length; i++) sum ^= data[i];",
      "  return sum;",
      "}",
      "",
      "void saveCurrentState() {",
      "  SaveState state = {0};",
      "  state.magic = SAVE_MAGIC;",
      "  state.version = SAVE_VERSION;",
      "  state.roomIndex = currentRoomIndex;",
      "  state.playerX = playerX;",
      "  state.playerY = playerY;",
      "  state.storyFlags = storyFlags;",
      "  state.equipmentFlags = equipmentFlags;",
      "  state.chestFlags = chestFlags;",
      "  state.gold = gold;",
      "  state.potionCount = potionCount;",
      "  state.heroLevel = heroLevel;",
      "  state.heroXp = heroXp;",
      "  state.heroXpNext = heroXpNext;",
      "  state.heroMaxHp = heroMaxHp;",
      "  state.heroCurrentHp = heroCurrentHp;",
      "  state.heroAttack = heroAttack;",
      "  state.checksum = saveChecksumBytes((const uint8_t *)&state, sizeof(SaveState) - 1);",
      "  EEPROM.put(SAVE_EEPROM_ADDRESS, state);",
      "}",
      "",
      "bool loadCurrentState() {",
      "  SaveState state = {0};",
      "  EEPROM.get(SAVE_EEPROM_ADDRESS, state);",
      "  if (state.magic != SAVE_MAGIC || state.version != SAVE_VERSION) return false;",
      "  if (state.checksum != saveChecksumBytes((const uint8_t *)&state, sizeof(SaveState) - 1)) return false;",
      "  if (state.roomIndex >= ROOM_COUNT || state.playerX >= DISPLAY_COLS || state.playerY >= DISPLAY_ROWS) return false;",
      "  currentRoomIndex = state.roomIndex;",
      "  playerX = state.playerX;",
      "  playerY = state.playerY;",
      "  storyFlags = state.storyFlags;",
      "  equipmentFlags = state.equipmentFlags;",
      "  chestFlags = state.chestFlags;",
      "  gold = state.gold;",
      "  potionCount = state.potionCount;",
      "  heroLevel = state.heroLevel;",
      "  heroXp = state.heroXp;",
      "  heroXpNext = state.heroXpNext < 1 ? 20 : state.heroXpNext;",
      "  heroMaxHp = state.heroMaxHp < 1 ? START_PLAYER_HP : state.heroMaxHp;",
      "  heroCurrentHp = state.heroCurrentHp > heroMaxHp ? heroMaxHp : state.heroCurrentHp;",
      "  heroAttack = state.heroAttack < 1 ? PLAYER_ATTACK : state.heroAttack;",
      "  resetBattleHp();",
      "  playWorldMusic();",
      "  return true;",
      "}",
      "",
      "void appendSmallNumber(char text[], uint8_t &pos, uint8_t value) {",
      "  if (value > 99) value = 99;",
      "  if (value >= 10) text[pos++] = (char)('0' + value / 10);",
      "  text[pos++] = (char)('0' + value % 10);",
      "}",
      "",
      "void showStatsMessage() {",
      "  char text[32];",
      "  uint8_t pos = 0;",
      "  text[pos++] = 'L'; appendSmallNumber(text, pos, heroLevel); text[pos++] = ' ';",
      "  text[pos++] = 'X'; appendSmallNumber(text, pos, heroXp); text[pos++] = ' ';",
      "  text[pos++] = 'H'; appendSmallNumber(text, pos, heroCurrentHp); text[pos++] = '-'; appendSmallNumber(text, pos, heroMaxHp); text[pos++] = ' ';",
      "  text[pos++] = 'A'; appendSmallNumber(text, pos, heroAttack); text[pos++] = ' ';",
      "  text[pos++] = 'G'; appendSmallNumber(text, pos, gold); text[pos++] = ' ';",
      "  text[pos++] = 'P'; appendSmallNumber(text, pos, potionCount);",
      "  text[pos] = '\\0';",
      "  showMessagePaged(text);",
      "}",
      "",
      "void useWorldPotion() {",
      "  char text[16];",
      "  uint8_t pos = 0;",
      "  if (potionCount == 0) { showMessagePaged(\"NO POT\"); return; }",
      "  if (heroCurrentHp >= heroMaxHp) { showMessagePaged(\"HP FULL\"); return; }",
      "  uint8_t missingHp = heroMaxHp - heroCurrentHp;",
      "  uint8_t appliedHeal = MINIMAL_POTION_HEAL > missingHp ? missingHp : MINIMAL_POTION_HEAL;",
      "  heroCurrentHp += appliedHeal;",
      "  potionCount--;",
      "  text[pos++] = 'H'; text[pos++] = 'P'; text[pos++] = ' '; text[pos++] = 'P'; text[pos++] = 'L'; text[pos++] = 'U'; text[pos++] = 'S'; text[pos++] = ' ';",
      "  appendSmallNumber(text, pos, appliedHeal);",
      "  text[pos] = '\\0';",
      "  showMessagePaged(text);",
      "}",
      "",
      "bool storyFlag(uint8_t bit) { return bit < 8 && (storyFlags & (1 << bit)) != 0; }",
      "void setStoryFlag(uint8_t bit) { if (bit < 8) storyFlags |= (1 << bit); }",
      "bool chestFlag(uint8_t bit) { return bit < 8 && (chestFlags & (1 << bit)) != 0; }",
      "void setChestFlag(uint8_t bit) { if (bit < 8) chestFlags |= (1 << bit); }",
      "void setEquipmentFlag(uint8_t bit) { if (bit < 8) equipmentFlags |= (1 << bit); }",
      "",
      "uint8_t roomSectionIndex(uint16_t roomIndex) {",
      "  if (roomIndex >= ROOM_COUNT) return 0;",
      "  return pgm_read_byte(&minimalRoomSections[roomIndex]);",
      "}",
      "",
      "uint16_t minimalChestRoom(uint8_t index) { return pgm_read_word(&minimalChests[index].roomIndex); }",
      "uint8_t minimalChestX(uint8_t index) { return pgm_read_byte(&minimalChests[index].x); }",
      "uint8_t minimalChestY(uint8_t index) { return pgm_read_byte(&minimalChests[index].y); }",
      "uint8_t minimalChestLoot(uint8_t index) { return pgm_read_byte(&minimalChests[index].lootKind); }",
      "uint8_t minimalChestAmount(uint8_t index) { return pgm_read_byte(&minimalChests[index].amount); }",
      "uint8_t minimalChestFlag(uint8_t index) { return pgm_read_byte(&minimalChests[index].flagBit); }",
      "",
      "uint16_t minimalGateFromRoom(uint8_t index) { return pgm_read_word(&minimalGates[index].fromRoomIndex); }",
      "uint16_t minimalGateToRoom(uint8_t index) { return pgm_read_word(&minimalGates[index].toRoomIndex); }",
      "uint8_t minimalGateRequiredFlag(uint8_t index) { return pgm_read_byte(&minimalGates[index].requiredFlagBit); }",
      "uint8_t minimalGateOpenedFlag(uint8_t index) { return pgm_read_byte(&minimalGates[index].openedFlagBit); }",
      "uint16_t minimalWallFromRoom(uint8_t index) { return pgm_read_word(&minimalWalls[index].fromRoomIndex); }",
      "uint16_t minimalWallToRoom(uint8_t index) { return pgm_read_word(&minimalWalls[index].toRoomIndex); }",
      "",
      "uint8_t minimalEnemyMaxHp(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].maxHp); }",
      "uint8_t minimalEnemyAttack(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].attack); }",
      "uint8_t minimalEnemyXpReward(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].xpReward); }",
      "uint8_t minimalEnemyEvasion(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].evasion); }",
      "uint8_t minimalEnemyDefense(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].defense); }",
      "uint8_t minimalEnemyMagicDefense(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].magicDefense); }",
      "uint8_t minimalEnemyAccuracy(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].accuracy); }",
      "uint8_t minimalEnemyCriticalChance(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].criticalChance); }",
      "uint8_t minimalEnemyLevel(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].level); }",
      "uint8_t minimalEnemyMagicPower(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].magicPower); }",
      "uint8_t minimalEnemyResistancePhysical(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].resistancePhysical); }",
      "uint8_t minimalEnemyResistanceMagic(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].resistanceMagic); }",
      "uint8_t minimalEnemyWeaponPower(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].weaponPower); }",
      "uint8_t minimalEnemySpellPower(uint8_t index) { return pgm_read_byte(&minimalEnemies[index].spellPower); }",
      "",
      "uint8_t minimalEncounterSection(uint8_t index) { return pgm_read_byte(&minimalEncounters[index].sectionIndex); }",
      "uint8_t minimalEncounterEnemyIndex(uint8_t index) { return pgm_read_byte(&minimalEncounters[index].enemyIndex); }",
      "uint8_t minimalEncounterFinalBoss(uint8_t index) { return pgm_read_byte(&minimalEncounters[index].finalBoss); }",
      "uint8_t minimalEncounterBossFlag(uint8_t index) { return pgm_read_byte(&minimalEncounters[index].bossFlagBit); }",
      "",
      generateCompressedWorldDecoder(),
      "char minimalWallOverlayChar(uint16_t roomIndex, uint8_t x, uint8_t y) {",
      "  for (uint8_t i = 0; i < MINIMAL_WALL_COUNT; i++) {",
      "    uint16_t wallFrom = minimalWallFromRoom(i);",
      "    uint16_t wallTo = minimalWallToRoom(i);",
      "    int8_t dx = 0;",
      "    int8_t dy = 0;",
      "    if (roomIndex == wallFrom) {",
      "      dx = (int8_t)roomXFromIndex(wallTo) - (int8_t)roomXFromIndex(wallFrom);",
      "      dy = (int8_t)roomYFromIndex(wallTo) - (int8_t)roomYFromIndex(wallFrom);",
      "    } else if (roomIndex == wallTo) {",
      "      dx = (int8_t)roomXFromIndex(wallFrom) - (int8_t)roomXFromIndex(wallTo);",
      "      dy = (int8_t)roomYFromIndex(wallFrom) - (int8_t)roomYFromIndex(wallTo);",
      "    } else {",
      "      continue;",
      "    }",
      "    if (dx > 0 && x == DISPLAY_COLS - 1) return '8';",
      "    if (dx < 0 && x == 0) return '8';",
      "    if (dy > 0 && y == DISPLAY_ROWS - 1) return '8';",
      "    if (dy < 0 && y == 0) return '8';",
      "  }",
      "  return ' ';",
      "}",
      "",
      "char minimalOverlayChar(uint16_t roomIndex, uint8_t x, uint8_t y) {",
      "  for (uint8_t i = 0; i < MINIMAL_CHEST_COUNT; i++) {",
      "    if (minimalChestRoom(i) == roomIndex && minimalChestX(i) == x && minimalChestY(i) == y && !chestFlag(minimalChestFlag(i))) {",
      "      return 'C';",
      "    }",
      "  }",
      "  for (uint8_t i = 0; i < MINIMAL_GATE_COUNT; i++) {",
      "    if (roomIndex == minimalGateFromRoom(i) && x == DISPLAY_COLS - 1) return y == 1 ? '1' : '8';",
      "    if (roomIndex == minimalGateToRoom(i) && x == 0) return y == 1 ? '1' : '8';",
      "  }",
      "  char wall = minimalWallOverlayChar(roomIndex, x, y);",
      "  if (wall != ' ') return wall;",
      "  return ' ';",
      "}",
      "",
      "void renderWorldmap() {",
      "  for (uint8_t y = 0; y < DISPLAY_ROWS; y++) {",
      "    for (uint8_t x = 0; x < DISPLAY_COLS; x++) {",
      "      char overlay = minimalOverlayChar(currentRoomIndex, x, y);",
      "      uint8_t segments = overlay != ' ' ? segmentForChar(overlay) : glyphSegments(roomCellGlyph(currentRoomIndex, x, y));",
      "      if (x == playerX && y == playerY) segments = segmentForChar('1');",
      "      setCell(x, y, segments);",
      "    }",
      "  }",
      "}",
      "",
      "void renderRoomCoordinates(uint8_t roomX, uint8_t roomY) {",
      "  if (!SHOW_ROOM_COORDINATES) return;",
      "  clearDisplay();",
      "  setCell(5, 0, segmentForChar((char)('A' + roomX)) | 0x80);",
      "  setCell(6, 0, segmentForChar((char)('0' + (roomY / 10))));",
      "  setCell(7, 0, segmentForChar((char)('0' + (roomY % 10))));",
      "  audioDelay(ROOM_COORDINATE_TIME_MS);",
      "}",
      "",
      "uint8_t segmentLine(char segmentName) {",
      "  if (segmentName == 'a') return 0x40;",
      "  if (segmentName == 'b') return 0x20;",
      "  if (segmentName == 'c') return 0x10;",
      "  if (segmentName == 'd') return 0x08;",
      "  if (segmentName == 'e') return 0x04;",
      "  if (segmentName == 'f') return 0x02;",
      "  return 0x01;",
      "}",
      "",
      "uint16_t transitionStepDelay(uint8_t stepCount) {",
      "  if (TRANSITION_ANIMATION_TIME_MS == 0) return 0;",
      "  uint16_t stepDelay = TRANSITION_ANIMATION_TIME_MS / stepCount;",
      "  return stepDelay == 0 ? 1 : stepDelay;",
      "}",
      "",
      "void delayTransitionStep(uint16_t stepDelay) {",
      "  if (stepDelay > 0) audioDelay(stepDelay);",
      "}",
      "",
      "void renderTransitionRow(uint8_t row, const char *segments, uint16_t stepDelay) {",
      "  clearDisplay();",
      "  for (uint8_t x = 0; x < DISPLAY_COLS; x++) setCell(x, row, segmentLine(segments[0]));",
      "  delayTransitionStep(stepDelay);",
      "  clearDisplay();",
      "  for (uint8_t x = 0; x < DISPLAY_COLS; x++) setCell(x, row, segmentLine(segments[1]));",
      "  delayTransitionStep(stepDelay);",
      "  clearDisplay();",
      "  for (uint8_t x = 0; x < DISPLAY_COLS; x++) setCell(x, row, segmentLine(segments[2]));",
      "  delayTransitionStep(stepDelay);",
      "}",
      "",
      "void renderTransitionColumn(uint8_t col, uint8_t firstSegments, uint8_t secondSegments, uint16_t stepDelay) {",
      "  clearDisplay();",
      "  for (uint8_t y = 0; y < DISPLAY_ROWS; y++) setCell(col, y, firstSegments);",
      "  delayTransitionStep(stepDelay);",
      "  clearDisplay();",
      "  for (uint8_t y = 0; y < DISPLAY_ROWS; y++) setCell(col, y, secondSegments);",
      "  delayTransitionStep(stepDelay);",
      "}",
      "",
      "void animateRoomTransition(int8_t dx, int8_t dy) {",
      "  if (TRANSITION_ANIMATION_TIME_MS == 0) return;",
      "  uint16_t stepDelay = transitionStepDelay(dy == 0 ? 16 : 9);",
      "",
      "  if (dy > 0) {",
      "    renderTransitionRow(2, \"dga\", stepDelay);",
      "    renderTransitionRow(1, \"dga\", stepDelay);",
      "    renderTransitionRow(0, \"dga\", stepDelay);",
      "  } else if (dy < 0) {",
      "    renderTransitionRow(0, \"agd\", stepDelay);",
      "    renderTransitionRow(1, \"agd\", stepDelay);",
      "    renderTransitionRow(2, \"agd\", stepDelay);",
      "  } else if (dx > 0) {",
      "    for (int8_t x = DISPLAY_COLS - 1; x >= 0; x--) renderTransitionColumn((uint8_t)x, 0x30, 0x06, stepDelay);",
      "  } else if (dx < 0) {",
      "    for (uint8_t x = 0; x < DISPLAY_COLS; x++) renderTransitionColumn(x, 0x06, 0x30, stepDelay);",
      "  }",
      "  clearDisplay();",
      "}",
      "",
      "void resetBattleHp() {",
      "  partyHp[0] = heroCurrentHp;",
      "  partyHp[1] = 0;",
      "  foeHp[0] = minimalEnemyMaxHp(activeEnemyIndex);",
      "  foeHp[1] = 0;",
      "}",
      "",
      "void resetWorldmap() {",
      "  int16_t startRoom = findRoomIndex(" + (Number(start.roomX) || 0) + ", " + (Number(start.roomY) || 0) + ");",
      "  if (startRoom < 0) startRoom = 0;",
      "  currentRoomIndex = (uint16_t)startRoom;",
      "  playerX = " + Math.max(0, Math.min(7, Number(start.playerX) || 0)) + ";",
      "  playerY = " + Math.max(0, Math.min(2, Number(start.playerY) || 0)) + ";",
      "  if (glyphBlocks(roomCellGlyph(currentRoomIndex, playerX, playerY))) { playerX = 0; playerY = 0; }",
      "  gameMode = MODE_WORLD;",
      "  storyFlags = 0;",
      "  equipmentFlags = 0;",
      "  chestFlags = 0;",
      "  gold = 0;",
      "  potionCount = 0;",
      "  heroLevel = 1;",
      "  heroXp = 0;",
      "  heroXpNext = 20;",
      "  heroMaxHp = START_PLAYER_HP;",
      "  heroCurrentHp = START_PLAYER_HP;",
      "  heroAttack = PLAYER_ATTACK;",
      "  activeEnemyIndex = 0;",
      "  activeEncounterFinalBoss = false;",
      "  resetBattleHp();",
      "  playWorldMusic();",
      "  renderWorldmap();",
      "}",
      "",
      "void facingDirection(int8_t &dx, int8_t &dy) {",
      "  uint16_t pot = analogRead(CONTROL_POT_PIN);",
      "  if (pot < 184) { dx = -1; dy = 0; }",
      "  else if (pot < 358) { dx = -1; dy = -1; }",
      "  else if (pot < 552) { dx = 0; dy = -1; }",
      "  else if (pot < 736) { dx = 1; dy = -1; }",
      "  else { dx = 1; dy = 0; }",
      "}",
      "",
      "const char *mainMenuLabel(uint8_t index) {",
      "  switch (index) {",
      "    case 0: return \"HIT\";",
      "    case 1: return \"HEAL\";",
      "    case 2: return \"MAGIC\";",
      "    default: return \"ITEM\";",
      "  }",
      "}",
      "",
      "const char *magicMenuLabel(uint8_t index) {",
      "  switch (index) {",
      "    case 0: return \"M1\";",
      "    case 1: return \"M2\";",
      "    case 2: return \"M3\";",
      "    case 3: return \"M4\";",
      "    default: return \"M5\";",
      "  }",
      "}",
      "",
      "const char *itemMenuLabel(uint8_t index) {",
      "  switch (index) {",
      "    case 0: return \"IT1\";",
      "    case 1: return \"IT2\";",
      "    case 2: return \"IT3\";",
      "    case 3: return \"IT4\";",
      "    default: return \"IT5\";",
      "  }",
      "}",
      "",
      "uint8_t menuCount() { return currentMenu == MENU_MAIN ? 4 : 5; }",
      "",
      "const char *menuLabel(uint8_t index) {",
      "  if (currentMenu == MENU_MAGIC) return magicMenuLabel(index);",
      "  if (currentMenu == MENU_ITEMS) return itemMenuLabel(index);",
      "  return mainMenuLabel(index);",
      "}",
      "",
      "uint8_t systemMenuCount() { return 4; }",
      "",
      "const char *systemMenuLabel(uint8_t index) {",
      "  switch (index) {",
      "    case 0: return \"SAVE\";",
      "    case 1: return \"LOAD\";",
      "    case 2: return \"ITEM\";",
      "    default: return \"STATS\";",
      "  }",
      "}",
      "",
      "uint8_t potToIndex(uint8_t count) {",
      "  uint16_t pot = analogRead(CONTROL_POT_PIN);",
      "  uint8_t index = (uint32_t)pot * count / 1024;",
      "  return index >= count ? count - 1 : index;",
      "}",
      "",
      "void keepSelectionVisible() {",
      "  uint8_t count = menuCount();",
      "  uint8_t maxStart = count > DISPLAY_ROWS ? count - DISPLAY_ROWS : 0;",
      "  if (selectedIndex < visibleStart) visibleStart = selectedIndex;",
      "  if (selectedIndex >= visibleStart + DISPLAY_ROWS) visibleStart = selectedIndex - (DISPLAY_ROWS - 1);",
      "  if (visibleStart > maxStart) visibleStart = maxStart;",
      "}",
      "",
      "void keepSystemSelectionVisible() {",
      "  uint8_t count = systemMenuCount();",
      "  uint8_t maxStart = count > DISPLAY_ROWS ? count - DISPLAY_ROWS : 0;",
      "  if (selectedIndex < visibleStart) visibleStart = selectedIndex;",
      "  if (selectedIndex >= visibleStart + DISPLAY_ROWS) visibleStart = selectedIndex - (DISPLAY_ROWS - 1);",
      "  if (visibleStart > maxStart) visibleStart = maxStart;",
      "}",
      "",
      "void drawActors(uint8_t frame[], int8_t blinkTarget, bool showBlink) {",
      "  if (foeHp[0] > 0 || (blinkTarget == 0 && showBlink)) frame[0] = segmentForChar('0');",
      "  if (partyHp[0] > 0 || (blinkTarget == 2 && showBlink)) frame[7] = segmentForChar('1');",
      "  if (foeHp[1] > 0 || (blinkTarget == 1 && showBlink)) frame[8] = segmentForChar('0');",
      "  if (partyHp[1] > 0 || (blinkTarget == 3 && showBlink)) frame[15] = segmentForChar('1');",
      "}",
      "",
      "const char *actorName(uint8_t actorIndex) {",
      "  if (actorIndex == ACTOR_YOU1) return \"YOU1\";",
      "  if (actorIndex == ACTOR_YOU2) return \"YOU2\";",
      "  if (actorIndex == ACTOR_FOE1 && activeEncounterFinalBoss) return \"BOSS\";",
      "  if (actorIndex == ACTOR_FOE1) return \"GOB\";",
      "  return \"FOE2\";",
      "}",
      "",
      "void stepCurrentActor(uint8_t frame[]) {",
      "  if (currentActorIndex == 0 && partyHp[0] > 0) { frame[7] = 0x00; frame[6] = segmentForChar('1'); }",
      "  if (currentActorIndex == 1 && partyHp[1] > 0) { frame[15] = 0x00; frame[14] = segmentForChar('1'); }",
      "}",
      "",
      "void clearBlinkActor(uint8_t frame[], int8_t target) {",
      "  if (target == 0) frame[0] = 0x00;",
      "  if (target == 1) frame[8] = 0x00;",
      "  if (target == 2) { frame[6] = 0x00; frame[7] = 0x00; }",
      "  if (target == 3) { frame[14] = 0x00; frame[15] = 0x00; }",
      "}",
      "",
      "bool actorIsHero(uint8_t actorIndex) {",
      "  return actorIndex == ACTOR_YOU1 || actorIndex == ACTOR_YOU2;",
      "}",
      "",
      "bool actorIsAlive(uint8_t actorIndex) {",
      "  if (actorIndex >= ACTOR_COUNT) return false;",
      "  if (actorIsHero(actorIndex)) return partyHp[actorIndex] > 0;",
      "  return foeHp[actorIndex - ACTOR_FOE1] > 0;",
      "}",
      "",
      "bool actorIsQueued(uint8_t actorIndex) {",
      "  for (uint8_t i = 0; i < readyCount; i++) {",
      "    if (readyQueue[i] == actorIndex) return true;",
      "  }",
      "  return false;",
      "}",
      "",
      "uint8_t timerDotCount(uint8_t actorIndex) {",
      "  if (!actorIsHero(actorIndex) || !actorIsAlive(actorIndex)) return 0;",
      "  uint32_t scaled = (uint32_t)actorTimer[actorIndex] * TIMER_DOT_COUNT;",
      "  uint8_t count = scaled / TIMER_FULL;",
      "  return count > TIMER_DOT_COUNT ? TIMER_DOT_COUNT : count;",
      "}",
      "",
      "void renderTextMenu() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  keepSelectionVisible();",
      "  for (uint8_t row = 0; row < DISPLAY_ROWS; row++) {",
      "    uint8_t itemIndex = visibleStart + row;",
      "    if (itemIndex < menuCount()) putTextRight(frame, row, menuLabel(itemIndex), itemIndex == selectedIndex);",
      "  }",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderSystemMenu() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  keepSystemSelectionVisible();",
      "  for (uint8_t row = 0; row < DISPLAY_ROWS; row++) {",
      "    uint8_t itemIndex = visibleStart + row;",
      "    if (itemIndex < systemMenuCount()) putTextRight(frame, row, systemMenuLabel(itemIndex), itemIndex == selectedIndex);",
      "  }",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderTargetSelect() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  if (pendingAction == ACTION_HIT) {",
      "    putTextAt(frame, 16, selectedTargetRow == 0 ? actorName(ACTOR_FOE1) : \"FOE2\", true);",
      "    if (selectedTargetRow == 0) { frame[0] |= blinkOn ? DP_BIT : 0; frame[1] |= blinkOn ? DP_BIT : 0; }",
      "    else { frame[8] |= blinkOn ? DP_BIT : 0; frame[9] |= blinkOn ? DP_BIT : 0; }",
      "  } else {",
      "    putTextAt(frame, 20, selectedTargetRow == 0 ? \"YOU1\" : \"YOU2\", true);",
      "    if (selectedTargetRow == 0) { frame[6] |= blinkOn ? DP_BIT : 0; frame[7] |= blinkOn ? DP_BIT : 0; }",
      "    else { frame[14] |= blinkOn ? DP_BIT : 0; frame[15] |= blinkOn ? DP_BIT : 0; }",
      "  }",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderMessage(const char *message) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  putTextRight(frame, 1, message, false);",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderBattleEffect(uint8_t row, const char *text, uint8_t startX, int8_t blinkTarget, bool stepActor) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  if (stepActor) stepCurrentActor(frame);",
      "  if (blinkTarget >= 0) clearBlinkActor(frame, blinkTarget);",
      "  putTextAt(frame, row * 8 + startX, text, false);",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderBattleText(uint8_t row, const char *text) {",
      "  renderBattleEffect(row, text, 2, -1, false);",
      "}",
      "",
      "void renderProjectileStep(uint8_t cellIndex, uint8_t segmentBits, bool stepActor) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  if (stepActor) stepCurrentActor(frame);",
      "  frame[cellIndex] = segmentBits;",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void renderCharging() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  uint8_t you1Dots = timerDotCount(ACTOR_YOU1);",
      "  uint8_t you2Dots = timerDotCount(ACTOR_YOU2);",
      "  for (uint8_t i = 0; i < you1Dots; i++) {",
      "    frame[4 + i] |= DP_BIT;",
      "  }",
      "  for (uint8_t i = 0; i < you2Dots; i++) {",
      "    frame[12 + i] |= DP_BIT;",
      "  }",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void appendHpNumber(char text[], uint8_t &pos, uint8_t value) {",
      "  if (value > 99) value = 99;",
      "  if (value >= 10) {",
      "    text[pos++] = (char)('0' + value / 10);",
      "    text[pos++] = (char)('0' + value % 10);",
      "  } else {",
      "    text[pos++] = (char)('0' + value);",
      "  }",
      "}",
      "",
      "uint8_t actorPromptMaxHp(uint8_t actorIndex) {",
      "  if (actorIndex == ACTOR_YOU1) return heroMaxHp;",
      "  return START_PLAYER_HP;",
      "}",
      "",
      "void formatActorPromptHp(char text[]) {",
      "  uint8_t pos = 0;",
      "  uint8_t actorIndex = currentActorIndex < 2 ? currentActorIndex : 0;",
      "  uint8_t hp = partyHp[actorIndex] > 0 ? (uint8_t)partyHp[actorIndex] : 0;",
      "  appendHpNumber(text, pos, hp);",
      "  text[pos++] = '-';",
      "  appendHpNumber(text, pos, actorPromptMaxHp(actorIndex));",
      "  text[pos] = '\\0';",
      "}",
      "",
      "void renderActorPrompt() {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  char hpText[8];",
      "  clearFrame(frame);",
      "  drawActors(frame, -1, false);",
      "  stepCurrentActor(frame);",
      "  if (actorPromptPage == 0) {",
      "    putTextRight(frame, 2, actorName(currentActorIndex), true);",
      "  } else {",
      "    formatActorPromptHp(hpText);",
      "    putTextRight(frame, 2, hpText, true);",
      "  }",
      "  renderFrameRaw24(frame);",
      "}",
      "",
      "void showActorPrompt() {",
      "  gameMode = MODE_ACTOR_PROMPT;",
      "  blinkOn = true;",
      "  lastBlink = millis();",
      "  actorPromptPage = 0;",
      "  lastActorPromptAlternate = millis();",
      "  renderActorPrompt();",
      "}",
      "",
      "void showMenu(uint8_t menu) {",
      "  currentMenu = menu;",
      "  selectedIndex = 0;",
      "  visibleStart = 0;",
      "  gameMode = MODE_MENU;",
      "  blinkOn = true;",
      "  lastBlink = millis();",
      "  renderTextMenu();",
      "}",
      "",
      "void showSystemMenu() {",
      "  gameMode = MODE_SYSTEM_MENU;",
      "  selectedIndex = 0;",
      "  visibleStart = 0;",
      "  blinkOn = true;",
      "  lastBlink = millis();",
      "  renderSystemMenu();",
      "  waitWorldButtonsReleased();",
      "}",
      "",
      "uint8_t firstAlive(const int8_t values[]) {",
      "  for (uint8_t i = 0; i < 2; i++) if (values[i] > 0) return i;",
      "  return 0;",
      "}",
      "",
      "void showTarget(uint8_t action) {",
      "  pendingAction = action;",
      "  selectedTargetRow = action == ACTION_HIT ? firstAlive(foeHp) : currentActorIndex;",
      "  gameMode = MODE_TARGET;",
      "  blinkOn = true;",
      "  lastBlink = millis();",
      "  renderTargetSelect();",
      "}",
      "",
      "bool allFoesDown() { return foeHp[0] <= 0 && foeHp[1] <= 0; }",
      "bool allPartyDown() { return partyHp[0] <= 0 && partyHp[1] <= 0; }",
      "",
      "bool actionAllowsDeadPartyTarget(uint8_t action) {",
      "  return action == ACTION_FENIX_DOWN || action == ACTION_LIFE;",
      "}",
      "",
      "bool targetIsSelectable(uint8_t action, uint8_t targetRow) {",
      "  if (targetRow >= 2) return false;",
      "  if (action == ACTION_HIT) return foeHp[targetRow] > 0;",
      "  return partyHp[targetRow] > 0 || actionAllowsDeadPartyTarget(action);",
      "}",
      "",
      "void clearBattleScheduler() {",
      "  for (uint8_t i = 0; i < ACTOR_COUNT; i++) actorTimer[i] = 0;",
      "  readyCount = 0;",
      "  currentActorIndex = NO_ACTOR;",
      "  lastTimerTick = millis();",
      "  lastChargeRender = lastTimerTick;",
      "}",
      "",
      "void removeDeadReadyActors() {",
      "  uint8_t writeIndex = 0;",
      "  for (uint8_t readIndex = 0; readIndex < readyCount; readIndex++) {",
      "    uint8_t actorIndex = readyQueue[readIndex];",
      "    if (actorIsAlive(actorIndex)) readyQueue[writeIndex++] = actorIndex;",
      "  }",
      "  readyCount = writeIndex;",
      "}",
      "",
      "uint8_t randomLivingParty() {",
      "  uint8_t living[2];",
      "  uint8_t count = 0;",
      "  for (uint8_t i = 0; i < 2; i++) {",
      "    if (partyHp[i] > 0) living[count++] = i;",
      "  }",
      "  if (count == 0) return NO_ACTOR;",
      "  return living[random(count)];",
      "}",
      "",
      "uint8_t clampBattleValue(int16_t value, uint8_t low, uint8_t high) {",
      "  if (value < low) return low;",
      "  if (value > high) return high;",
      "  return (uint8_t)value;",
      "}",
      "",
      "uint8_t rollDie(uint8_t sides) {",
      "  if (sides < 2) sides = 2;",
      "  return (uint8_t)random(1, sides + 1);",
      "}",
      "",
      "uint8_t percentRoll() { return (uint8_t)random(1, 101); }",
      "",
      "uint8_t randomRange(uint8_t low, uint8_t high) {",
      "  if (high < low) { uint8_t temp = low; low = high; high = temp; }",
      "  return low + (uint8_t)random((uint16_t)high - low + 1);",
      "}",
      "",
      "int8_t fateRoll() { return (int8_t)random(-4, 5); }",
      "",
      "uint8_t actorLevel(bool hero) { return hero ? heroLevel : minimalEnemyLevel(activeEnemyIndex); }",
      "uint8_t actorAttackPower(bool hero) { return hero ? heroAttack : minimalEnemyAttack(activeEnemyIndex); }",
      "uint8_t actorMagicPower(bool hero) { return hero ? (uint8_t)(MINIMAL_HERO_MAGIC_POWER + MINIMAL_HERO_SPELL_POWER) : (uint8_t)(minimalEnemyMagicPower(activeEnemyIndex) + minimalEnemySpellPower(activeEnemyIndex)); }",
      "uint8_t actorDefense(bool hero) { return hero ? MINIMAL_HERO_DEFENSE : minimalEnemyDefense(activeEnemyIndex); }",
      "uint8_t actorMagicDefense(bool hero) { return hero ? MINIMAL_HERO_MAGIC_DEFENSE : minimalEnemyMagicDefense(activeEnemyIndex); }",
      "uint8_t actorAccuracy(bool hero) { return hero ? MINIMAL_HERO_ACCURACY : minimalEnemyAccuracy(activeEnemyIndex); }",
      "uint8_t actorEvasion(bool hero) { return hero ? MINIMAL_HERO_EVASION : minimalEnemyEvasion(activeEnemyIndex); }",
      "uint8_t actorCriticalChance(bool hero) { return hero ? MINIMAL_HERO_CRITICAL_CHANCE : minimalEnemyCriticalChance(activeEnemyIndex); }",
      "uint8_t actorPhysicalResistance(bool hero) { return hero ? MINIMAL_HERO_RESISTANCE_PHYSICAL : minimalEnemyResistancePhysical(activeEnemyIndex); }",
      "uint8_t actorWeaponPower(bool hero) { return hero ? 0 : minimalEnemyWeaponPower(activeEnemyIndex); }",
      "",
      "uint8_t finalBattleDamage(bool hit, int16_t damage, bool defenderHero) {",
      "  if (!hit) return 0;",
      "  if (damage < 1) damage = 1;",
      "  uint16_t resisted = ((uint16_t)damage * actorPhysicalResistance(defenderHero) + 50) / 100;",
      "  if (resisted < 1) resisted = 1;",
      "  if (resisted > 99) resisted = 99;",
      "  return (uint8_t)resisted;",
      "}",
      "",
      "uint8_t battleHitChance(bool attackerHero, bool defenderHero) {",
      "  int16_t chance = (int16_t)actorAccuracy(attackerHero) - (int16_t)actorEvasion(defenderHero) + (actorLevel(attackerHero) / 3);",
      "  return clampBattleValue(chance, 5, 95);",
      "}",
      "",
      "uint8_t battleAttackDamage(bool attackerHero, bool defenderHero) {",
      "  uint8_t power = actorAttackPower(attackerHero);",
      "  uint8_t defense = actorDefense(defenderHero);",
      "  uint8_t hitChance = battleHitChance(attackerHero, defenderHero);",
      "  uint8_t roll;",
      "  bool hit;",
      "  bool critical;",
      "  int16_t damage;",
      "  if (BATTLE_CALC_METHOD == 0) {",
      "    int16_t attackBonus = power / 4 + actorLevel(attackerHero) / 4;",
      "    int16_t armorClass = 10 + defense / 4;",
      "    roll = rollDie(20);",
      "    critical = roll == 20 || percentRoll() <= actorCriticalChance(attackerHero);",
      "    hit = roll == 20 || (roll != 1 && (int16_t)roll + attackBonus >= armorClass);",
      "    damage = (int16_t)power + rollDie(8);",
      "    return finalBattleDamage(hit, critical ? damage * 2 : damage, defenderHero);",
      "  }",
      "  if (BATTLE_CALC_METHOD == 1) {",
      "    int16_t attackBonus = actorLevel(attackerHero) + power / 4;",
      "    int16_t defenseNumber = 10 + actorLevel(defenderHero) + defense / 4;",
      "    roll = rollDie(20);",
      "    int16_t total = roll + attackBonus;",
      "    hit = roll == 20 || (roll != 1 && total >= defenseNumber);",
      "    critical = hit && (roll == 20 || total >= defenseNumber + 10);",
      "    damage = (int16_t)power + rollDie(6);",
      "    return finalBattleDamage(hit, critical ? damage * 2 : damage, defenderHero);",
      "  }",
      "  if (BATTLE_CALC_METHOD == 2) {",
      "    uint8_t skill = 8 + power / 10;",
      "    uint8_t defend = 8 + actorEvasion(defenderHero) / 20;",
      "    uint8_t attackRoll = rollDie(6) + rollDie(6) + rollDie(6);",
      "    uint8_t defendRoll = rollDie(6) + rollDie(6) + rollDie(6);",
      "    hit = attackRoll <= skill && defendRoll > defend;",
      "    damage = (int16_t)rollDie(6) + power / 5 - defense / 3;",
      "    return finalBattleDamage(hit, damage, defenderHero);",
      "  }",
      "  if (BATTLE_CALC_METHOD == 3) {",
      "    int8_t attackSkill = power / 25;",
      "    int8_t defendSkill = defense / 25 + actorEvasion(defenderHero) / 25;",
      "    int8_t shifts = attackSkill + fateRoll() - defendSkill - fateRoll();",
      "    damage = shifts + actorWeaponPower(attackerHero) / 25;",
      "    return finalBattleDamage(shifts > 0, damage, defenderHero);",
      "  }",
      "  if (BATTLE_CALC_METHOD == 4) {",
      "    uint8_t skill = actorAccuracy(attackerHero);",
      "    uint8_t dodge = actorEvasion(defenderHero);",
      "    uint8_t attackRoll = percentRoll();",
      "    uint8_t defendRoll = percentRoll();",
      "    uint8_t attackLevel = attackRoll <= skill / 5 ? 3 : attackRoll <= skill / 2 ? 2 : attackRoll <= skill ? 1 : 0;",
      "    uint8_t defendLevel = defendRoll <= dodge / 5 ? 3 : defendRoll <= dodge / 2 ? 2 : defendRoll <= dodge ? 1 : 0;",
      "    hit = attackLevel > 0 && attackLevel >= defendLevel;",
      "    damage = (int16_t)rollDie(8) + power / 5 - defense / 5;",
      "    return finalBattleDamage(hit, attackLevel == 3 ? damage * 2 : damage, defenderHero);",
      "  }",
      "  if (BATTLE_CALC_METHOD == 5 || BATTLE_CALC_METHOD == 6) {",
      "    uint8_t sides = BATTLE_CALC_METHOD == 5 ? 6 : 10;",
      "    uint8_t pool = 1 + power / 20;",
      "    uint8_t defendPool = 1 + (actorEvasion(defenderHero) + defense) / 30;",
      "    uint8_t hits = 0;",
      "    uint8_t blocks = 0;",
      "    uint8_t target = (sides * 2 + 2) / 3;",
      "    for (uint8_t i = 0; i < pool; i++) if (rollDie(sides) >= target) hits++;",
      "    for (uint8_t i = 0; i < defendPool; i++) if (rollDie(sides) >= target) blocks++;",
      "    if (hits <= blocks) return 0;",
      "    uint8_t base = BATTLE_CALC_METHOD == 5 ? 2 + power / 12 : 1 + power / 25;",
      "    return finalBattleDamage(true, (int16_t)base + hits - blocks, defenderHero);",
      "  }",
      "  if (BATTLE_CALC_METHOD == 7) {",
      "    if (percentRoll() > hitChance) return 0;",
      "    uint8_t hits = 1 + actorLevel(attackerHero) / 16;",
      "    uint8_t high = power > 0 ? power * 2 : 1;",
      "    damage = (int16_t)(randomRange(power, high)) - defense;",
      "    damage *= hits;",
      "    if (percentRoll() <= actorCriticalChance(attackerHero)) damage += power;",
      "    return finalBattleDamage(true, damage, defenderHero);",
      "  }",
      "  if (BATTLE_CALC_METHOD == 8) {",
      "    if (percentRoll() > hitChance) return 0;",
      "    int16_t adjusted = (int16_t)power / 2 - (int16_t)defense / 4;",
      "    if (adjusted < 1) adjusted = 1;",
      "    critical = percentRoll() <= actorCriticalChance(attackerHero);",
      "    if (critical) return finalBattleDamage(true, power, defenderHero);",
      "    return finalBattleDamage(true, randomRange((uint8_t)((adjusted * 3 + 3) / 4), (uint8_t)((adjusted * 5 + 3) / 4)), defenderHero);",
      "  }",
      "  if (BATTLE_CALC_METHOD == 9) {",
      "    if (percentRoll() > hitChance) return 0;",
      "    uint8_t attackStat = power < 1 ? 1 : power;",
      "    uint8_t defenseStat = defense < 1 ? 1 : defense;",
      "    uint32_t base = (((uint32_t)(2 * actorLevel(attackerHero) / 5 + 2) * power * attackStat) / defenseStat) / 50 + 2;",
      "    base = base * randomRange(85, 100) / 100;",
      "    if (percentRoll() <= actorCriticalChance(attackerHero)) base = base * 3 / 2;",
      "    return finalBattleDamage(true, base > 99 ? 99 : (int16_t)base, defenderHero);",
      "  }",
      "  if (percentRoll() > hitChance) return 0;",
      "  damage = (int16_t)power + randomRange(0, power) - defense;",
      "  return finalBattleDamage(true, damage, defenderHero);",
      "}",
      "",
      "void beginBattleCharging() {",
      "  gameMode = MODE_CHARGING;",
      "  currentActorIndex = NO_ACTOR;",
      "  lastTimerTick = millis();",
      "  lastChargeRender = lastTimerTick;",
      "  renderCharging();",
      "}",
      "",
      "void startBattle() {",
      "  playBattleMusic();",
      "  resetBattleHp();",
      "  clearBattleScheduler();",
      "  actorSwiftness[ACTOR_YOU1] = 10;",
      "  actorSwiftness[ACTOR_YOU2] = 5;",
      "  actorSwiftness[ACTOR_FOE1] = random(1, 11);",
      "  actorSwiftness[ACTOR_FOE2] = 0;",
      "  currentMenu = MENU_MAIN;",
      "  pendingAction = ACTION_HIT;",
      "  selectedIndex = 0;",
      "  visibleStart = 0;",
      "  selectedTargetRow = 0;",
      "  Serial.print(F(\"Foe swiftness: \"));",
      "  Serial.print(actorSwiftness[ACTOR_FOE1]);",
      "  Serial.print('/');",
      "  Serial.println(actorSwiftness[ACTOR_FOE2]);",
      "  if (activeEncounterFinalBoss) {",
      "    renderMessage(\"BOSS\");",
      "    audioDelay(700);",
      "  }",
      "  beginBattleCharging();",
      "}",
      "",
      "void enqueueNewlyReady(const uint8_t actors[], const uint32_t scores[], uint8_t count) {",
      "  bool used[ACTOR_COUNT] = { false, false, false, false };",
      "  for (uint8_t output = 0; output < count && readyCount < ACTOR_COUNT; output++) {",
      "    int8_t best = -1;",
      "    for (uint8_t candidate = 0; candidate < count; candidate++) {",
      "      if (used[candidate]) continue;",
      "      if (best < 0 || scores[candidate] > scores[(uint8_t)best] ||",
      "          (scores[candidate] == scores[(uint8_t)best] && actors[candidate] < actors[(uint8_t)best])) {",
      "        best = candidate;",
      "      }",
      "    }",
      "    if (best >= 0) {",
      "      used[(uint8_t)best] = true;",
      "      readyQueue[readyCount++] = actors[(uint8_t)best];",
      "    }",
      "  }",
      "}",
      "",
      "void startNextReadyActor() {",
      "  removeDeadReadyActors();",
      "  if (allFoesDown()) { resetAfterBattle(\"VICTORY\", true); return; }",
      "  if (allPartyDown()) { resetAfterBattle(\"GAMEOVER\", false); return; }",
      "  if (readyCount == 0) { beginBattleCharging(); return; }",
      "  currentActorIndex = readyQueue[0];",
      "  for (uint8_t i = 1; i < readyCount; i++) readyQueue[i - 1] = readyQueue[i];",
      "  readyCount--;",
      "  if (actorIsHero(currentActorIndex)) showActorPrompt();",
      "  else enemyTurn(currentActorIndex);",
      "}",
      "",
      "void completeCurrentActorAction() {",
      "  if (allFoesDown()) { resetAfterBattle(\"VICTORY\", true); return; }",
      "  if (allPartyDown()) { resetAfterBattle(\"GAMEOVER\", false); return; }",
      "  if (currentActorIndex < ACTOR_COUNT) actorTimer[currentActorIndex] = 0;",
      "  currentActorIndex = NO_ACTOR;",
      "  removeDeadReadyActors();",
      "  if (readyCount > 0) startNextReadyActor();",
      "  else beginBattleCharging();",
      "}",
      "",
      "void updateActorTimers() {",
      "  if (gameMode != MODE_CHARGING) return;",
      "  unsigned long now = millis();",
      "  unsigned long elapsed = now - lastTimerTick;",
      "  if (elapsed == 0) return;",
      "  lastTimerTick = now;",
      "  uint8_t newlyReady[ACTOR_COUNT];",
      "  uint32_t readyScore[ACTOR_COUNT];",
      "  uint8_t newlyReadyCount = 0;",
      "  for (uint8_t actorIndex = 0; actorIndex < ACTOR_COUNT; actorIndex++) {",
      "    if (!actorIsAlive(actorIndex) || actorIsQueued(actorIndex)) continue;",
      "    uint32_t nextTimer = (uint32_t)actorTimer[actorIndex] + elapsed * actorSwiftness[actorIndex];",
      "    actorTimer[actorIndex] = nextTimer >= TIMER_FULL ? TIMER_FULL : (uint16_t)nextTimer;",
      "    if (actorTimer[actorIndex] >= TIMER_FULL) {",
      "      newlyReady[newlyReadyCount] = actorIndex;",
      "      readyScore[newlyReadyCount] = nextTimer;",
      "      newlyReadyCount++;",
      "    }",
      "  }",
      "  if (newlyReadyCount > 0) {",
      "    enqueueNewlyReady(newlyReady, readyScore, newlyReadyCount);",
      "    startNextReadyActor();",
      "    return;",
      "  }",
      "  if (now - lastChargeRender >= CHARGE_RENDER_MS) {",
      "    lastChargeRender = now;",
      "    renderCharging();",
      "  }",
      "}",
      "",
      "void blinkDefeated(int8_t target) {",
      "  uint8_t frame[DISPLAY_CELLS];",
      "  for (uint8_t i = 0; i < 6; i++) {",
      "    clearFrame(frame);",
      "    drawActors(frame, target, i % 2 == 0);",
      "    renderFrameRaw24(frame);",
      "    audioDelay(170);",
      "  }",
      "}",
      "",
      "void applyBattleVictoryRewards() {",
      "  heroCurrentHp = partyHp[0] > 0 ? partyHp[0] : 1;",
      "  heroXp += minimalEnemyXpReward(activeEnemyIndex);",
      "  bool leveledUp = false;",
      "  while (heroXp >= heroXpNext && heroLevel < 9) {",
      "    heroXp -= heroXpNext;",
      "    heroLevel++;",
      "    heroXpNext += 10;",
      "    heroMaxHp = heroMaxHp > 94 ? 99 : heroMaxHp + 5;",
      "    heroCurrentHp = heroMaxHp;",
      "    leveledUp = true;",
      "  }",
      "  if (leveledUp) {",
      "    showMessagePaged(\"LEVEL UP HP PLUS 5\");",
      "  }",
      "  if (activeEncounterFinalBoss) {",
      "    setStoryFlag(MINIMAL_FLAG_BOSS_DEFEATED);",
      "    showMessagePaged(\"YOU HAVE SAVED THE WORLD THANK YOU\");",
      "  }",
      "}",
      "",
      "void resetAfterBattle(const char *message, bool keepWorldPosition) {",
      "  gameMode = MODE_BATTLE_MESSAGE;",
      "  if (message[0] == 'V') applyBattleVictoryRewards();",
      "  renderMessage(message);",
      "  audioDelay(1000);",
      "  clearDisplay();",
      "  audioDelay(1000);",
      "  clearBattleScheduler();",
      "  if (keepWorldPosition) {",
      "    gameMode = MODE_WORLD;",
      "    playWorldMusic();",
      "    renderWorldmap();",
      "  } else {",
      "    resetWorldmap();",
      "  }",
      "}",
      "",
      "void maybeStartBattle() {",
      "  if (random(10) != 0) return;",
      "  uint8_t sectionIndex = roomSectionIndex(currentRoomIndex);",
      "  for (uint8_t i = 0; i < MINIMAL_ENCOUNTER_COUNT; i++) {",
      "    if (minimalEncounterSection(i) != sectionIndex) continue;",
      "    if (minimalEncounterFinalBoss(i) && storyFlag(minimalEncounterBossFlag(i))) continue;",
      "    activeEnemyIndex = minimalEncounterEnemyIndex(i);",
      "    activeEncounterFinalBoss = minimalEncounterFinalBoss(i) != 0;",
      "    startBattle();",
      "    return;",
      "  }",
      "}",
      "",
      "int8_t gateIndexBetweenRooms(uint16_t fromRoom, uint16_t toRoom) {",
      "  for (uint8_t i = 0; i < MINIMAL_GATE_COUNT; i++) {",
      "    uint16_t gateFrom = minimalGateFromRoom(i);",
      "    uint16_t gateTo = minimalGateToRoom(i);",
      "    if ((gateFrom == fromRoom && gateTo == toRoom) ||",
      "        (gateFrom == toRoom && gateTo == fromRoom)) {",
      "      return (int8_t)i;",
      "    }",
      "  }",
      "  return -1;",
      "}",
      "",
      "bool wallBetweenRooms(uint16_t fromRoom, uint16_t toRoom) {",
      "  for (uint8_t i = 0; i < MINIMAL_WALL_COUNT; i++) {",
      "    uint16_t wallFrom = minimalWallFromRoom(i);",
      "    uint16_t wallTo = minimalWallToRoom(i);",
      "    if ((wallFrom == fromRoom && wallTo == toRoom) ||",
      "        (wallFrom == toRoom && wallTo == fromRoom)) {",
      "      return true;",
      "    }",
      "  }",
      "  return false;",
      "}",
      "",
      "bool openCurrentChestIfAny() {",
      "  for (uint8_t i = 0; i < MINIMAL_CHEST_COUNT; i++) {",
      "    uint8_t lootKind = minimalChestLoot(i);",
      "    uint8_t amount = minimalChestAmount(i);",
      "    if (minimalChestRoom(i) != currentRoomIndex || minimalChestX(i) != playerX || minimalChestY(i) != playerY || chestFlag(minimalChestFlag(i))) continue;",
      "    setChestFlag(minimalChestFlag(i));",
      "    if (lootKind == 1) {",
      "      gold += amount;",
      "      showMessagePaged(\"FOUND 10 GOLD\");",
      "    } else if (lootKind == 2) {",
      "      setStoryFlag(MINIMAL_FLAG_HAS_ANCIENT_KEY);",
      "      setStoryFlag(MINIMAL_FLAG_GATE_OPENED);",
      "      showMessagePaged(\"YOU NOW HOLD THE ANCHENT KEY\");",
      "    } else if (lootKind == 3) {",
      "      setEquipmentFlag(MINIMAL_EQUIP_SWORD_OBTAINED);",
      "      setEquipmentFlag(MINIMAL_EQUIP_SWORD_EQUIPPED);",
      "      heroAttack = PLAYER_ATTACK + MINIMAL_SWORD_ATTACK_BONUS;",
      "      showMessagePaged(\"SWORD ATK PLUS 4\");",
      "    } else if (lootKind == 4) {",
      "      potionCount += amount;",
      "      showMessagePaged(\"POTION PLUS 1\");",
      "    }",
      "    return true;",
      "  }",
      "  return false;",
      "}",
      "",
      "void tryMove(int8_t dx, int8_t dy) {",
      "  int8_t targetRoomX = (int8_t)roomXFromIndex(currentRoomIndex);",
      "  int8_t targetRoomY = (int8_t)roomYFromIndex(currentRoomIndex);",
      "  int8_t targetX = (int8_t)playerX + dx;",
      "  int8_t targetY = (int8_t)playerY + dy;",
      "  bool changesRoom = false;",
      "  if (targetX < 0) { targetRoomX--; targetX = DISPLAY_COLS - 1; changesRoom = true; }",
      "  else if (targetX >= DISPLAY_COLS) { targetRoomX++; targetX = 0; changesRoom = true; }",
      "  if (targetY < 0) { targetRoomY--; targetY = DISPLAY_ROWS - 1; changesRoom = true; }",
      "  else if (targetY >= DISPLAY_ROWS) { targetRoomY++; targetY = 0; changesRoom = true; }",
      "  int16_t targetRoomIndex = findRoomIndex(targetRoomX, targetRoomY);",
      "  if (targetRoomIndex < 0) return;",
      "  char targetOverlay = minimalOverlayChar(currentRoomIndex, (uint8_t)targetX, (uint8_t)targetY);",
      "  if (!changesRoom && (targetOverlay == '8' || targetOverlay == '#')) return;",
      "  if (!changesRoom && targetOverlay == '1') {",
      "    int16_t neighborRoomIndex = -1;",
      "    if (targetX == DISPLAY_COLS - 1) neighborRoomIndex = findRoomIndex(targetRoomX + 1, targetRoomY);",
      "    else if (targetX == 0) neighborRoomIndex = findRoomIndex(targetRoomX - 1, targetRoomY);",
      "    if (neighborRoomIndex >= 0) {",
      "      int8_t gateIndex = gateIndexBetweenRooms(currentRoomIndex, (uint16_t)neighborRoomIndex);",
      "      if (gateIndex >= 0 && !storyFlag(minimalGateRequiredFlag((uint8_t)gateIndex))) {",
      "        showMessagePaged(\"GATE LOCKED FIND KEY\");",
      "        renderWorldmap();",
      "        return;",
      "      }",
      "    }",
      "  }",
      "  if (changesRoom) {",
      "    if (wallBetweenRooms(currentRoomIndex, (uint16_t)targetRoomIndex)) return;",
      "    int8_t gateIndex = gateIndexBetweenRooms(currentRoomIndex, (uint16_t)targetRoomIndex);",
      "    if (gateIndex >= 0) {",
      "      if (!storyFlag(minimalGateRequiredFlag((uint8_t)gateIndex))) {",
      "        showMessagePaged(\"GATE LOCKED FIND KEY\");",
      "        renderWorldmap();",
      "        return;",
      "      }",
      "      setStoryFlag(minimalGateOpenedFlag((uint8_t)gateIndex));",
      "    }",
      "  }",
      "  char landingOverlay = minimalOverlayChar((uint16_t)targetRoomIndex, (uint8_t)targetX, (uint8_t)targetY);",
      "  if (landingOverlay == '8' || landingOverlay == '#') return;",
      "  if (glyphBlocks(roomCellGlyph((uint16_t)targetRoomIndex, (uint8_t)targetX, (uint8_t)targetY))) return;",
      "  if (changesRoom) {",
      "    movementLockedUntilRelease = true;",
      "    animateRoomTransition(dx, dy);",
      "  }",
      "  currentRoomIndex = (uint16_t)targetRoomIndex;",
      "  playerX = (uint8_t)targetX;",
      "  playerY = (uint8_t)targetY;",
      "  if (changesRoom) renderRoomCoordinates(roomXFromIndex(currentRoomIndex), roomYFromIndex(currentRoomIndex));",
      "  renderWorldmap();",
      "  if (openCurrentChestIfAny()) { renderWorldmap(); return; }",
      "  maybeStartBattle();",
      "}",
      "",
      "void enemyTurn(uint8_t foeActorIndex) {",
      "  if (foeActorIndex < ACTOR_FOE1 || foeActorIndex > ACTOR_FOE2 || !actorIsAlive(foeActorIndex)) {",
      "    completeCurrentActorAction();",
      "    return;",
      "  }",
      "  uint8_t party = randomLivingParty();",
      "  if (party == NO_ACTOR) { resetAfterBattle(\"GAMEOVER\", false); return; }",
      "  gameMode = MODE_BATTLE_MESSAGE;",
      "  uint8_t damageAmount = battleAttackDamage(false, true);",
      "  char damageText[4];",
      "  if (damageAmount > 0) makeDamageText(damageText, damageAmount);",
      "  renderBattleEffect(party, damageAmount > 0 ? damageText : \"MISS\", 4, 2 + party, false);",
      "  audioDelay(170);",
      "  renderBattleEffect(party, damageAmount > 0 ? damageText : \"MISS\", 4, -1, false);",
      "  audioDelay(280);",
      "  int8_t oldHp = partyHp[party];",
      "  if (damageAmount > 0) {",
      "    partyHp[party] -= damageAmount;",
      "    if (partyHp[party] < 0) partyHp[party] = 0;",
      "    if (oldHp > 0 && partyHp[party] <= 0) blinkDefeated(2 + party);",
      "  }",
      "  completeCurrentActorAction();",
      "}",
      "",
      "void makeDamageText(char text[], uint8_t amount) {",
      "  if (amount > 99) amount = 99;",
      "  text[0] = '-';",
      "  if (amount >= 10) {",
      "    text[1] = (char)('0' + amount / 10);",
      "    text[2] = (char)('0' + amount % 10);",
      "    text[3] = '\\0';",
      "  } else {",
      "    text[1] = (char)('0' + amount);",
      "    text[2] = '\\0';",
      "  }",
      "}",
      "",
      "void makeUnsignedText(char text[], uint8_t amount) {",
      "  if (amount > 99) amount = 99;",
      "  if (amount >= 10) {",
      "    text[0] = (char)('0' + amount / 10);",
      "    text[1] = (char)('0' + amount % 10);",
      "    text[2] = '\\0';",
      "  } else {",
      "    text[0] = (char)('0' + amount);",
      "    text[1] = '\\0';",
      "  }",
      "}",
      "",
      "void finishAction() {",
      "  if (pendingAction == ACTION_HIT) {",
      "    if (!targetIsSelectable(pendingAction, selectedTargetRow)) { renderMessage(\"DEAD\"); audioDelay(700); renderTargetSelect(); return; }",
      "    if (currentActorIndex == 0 && selectedTargetRow == 1) {",
      "      uint8_t pathCells[4] = { 5, 4, 10, 9 };",
      "      uint8_t pathSegments[4] = { 0x01, 0x08, 0x40, 0x01 };",
      "      for (uint8_t i = 0; i < 4; i++) {",
      "        renderProjectileStep(pathCells[i], pathSegments[i], i < 2);",
      "        audioDelay(110);",
      "      }",
      "    } else {",
      "      for (int8_t projectileX = 5; projectileX >= 2; projectileX--) {",
      "        renderProjectileStep(selectedTargetRow * 8 + (uint8_t)projectileX, segmentForChar('-'), projectileX >= 4);",
      "        audioDelay(110);",
      "      }",
      "    }",
      "    uint8_t damageAmount = battleAttackDamage(true, false);",
      "    if (damageAmount == 0) {",
      "      renderBattleEffect(selectedTargetRow, \"MISS\", 2, selectedTargetRow, false);",
      "      audioDelay(600);",
      "      completeCurrentActorAction();",
      "      return;",
      "    }",
      "    char damageText[4];",
      "    makeDamageText(damageText, damageAmount);",
      "    renderBattleEffect(selectedTargetRow, damageText, 2, selectedTargetRow, false);",
      "    audioDelay(170);",
      "    renderBattleEffect(selectedTargetRow, damageText, 2, -1, false);",
      "    audioDelay(280);",
      "    int8_t oldHp = foeHp[selectedTargetRow];",
      "    foeHp[selectedTargetRow] -= damageAmount;",
      "    if (foeHp[selectedTargetRow] < 0) foeHp[selectedTargetRow] = 0;",
      "    if (oldHp > 0 && foeHp[selectedTargetRow] <= 0) blinkDefeated(selectedTargetRow);",
      "  } else {",
      "    if (!targetIsSelectable(pendingAction, selectedTargetRow)) { renderMessage(\"DEAD\"); audioDelay(700); renderTargetSelect(); return; }",
      "    uint8_t healAmount = pendingAction == ACTION_POTION ? MINIMAL_POTION_HEAL : PLAYER_HEAL;",
      "    int16_t missingHp = (int16_t)heroMaxHp - (int16_t)partyHp[selectedTargetRow];",
      "    if (missingHp < 0) missingHp = 0;",
      "    uint8_t appliedHeal = healAmount > (uint8_t)missingHp ? (uint8_t)missingHp : healAmount;",
      "    char healText[3];",
      "    makeUnsignedText(healText, appliedHeal);",
      "    renderBattleEffect(selectedTargetRow, healText, 4, 2 + selectedTargetRow, true);",
      "    audioDelay(170);",
      "    renderBattleEffect(selectedTargetRow, healText, 4, -1, true);",
      "    audioDelay(280);",
      "    if (pendingAction == ACTION_POTION && potionCount > 0) potionCount--;",
      "    partyHp[selectedTargetRow] += appliedHeal;",
      "  }",
      "  completeCurrentActorAction();",
      "}",
      "",
      "void confirmMenuItem() {",
      "  if (currentMenu == MENU_MAIN) {",
      "    if (selectedIndex == 0) showTarget(ACTION_HIT);",
      "    else if (selectedIndex == 1) showTarget(ACTION_HEAL);",
      "    else if (selectedIndex == 2) showMenu(MENU_MAGIC);",
      "    else showMenu(MENU_ITEMS);",
      "  } else if (currentMenu == MENU_ITEMS && selectedIndex == 0) {",
      "    if (potionCount == 0) { renderMessage(\"NO POT\"); audioDelay(700); renderTextMenu(); }",
      "    else showTarget(ACTION_POTION);",
      "  } else {",
      "    renderMessage(menuLabel(selectedIndex));",
      "    audioDelay(700);",
      "    completeCurrentActorAction();",
      "  }",
      "}",
      "",
      "void closeSystemMenuToWorld() {",
      "  gameMode = MODE_WORLD;",
      "  renderWorldmap();",
      "}",
      "",
      "void confirmSystemMenuItem() {",
      "  if (selectedIndex == 0) {",
      "    saveCurrentState();",
      "    showMessagePaged(\"SAVED\");",
      "  } else if (selectedIndex == 1) {",
      "    if (loadCurrentState()) showMessagePaged(\"LOADED\");",
      "    else showMessagePaged(\"NO SAVE\");",
      "  } else if (selectedIndex == 2) {",
      "    useWorldPotion();",
      "  } else {",
      "    showStatsMessage();",
      "  }",
      "  closeSystemMenuToWorld();",
      "}",
      "",
      "bool debouncedPress(uint8_t pin, bool &lastReading, bool &stableState, unsigned long &lastChange) {",
      "  bool reading = digitalRead(pin);",
      "  if (reading != lastReading) { lastChange = millis(); lastReading = reading; }",
      "  if ((millis() - lastChange) >= DEBOUNCE_MS && reading != stableState) {",
      "    stableState = reading;",
      "    return stableState == LOW;",
      "  }",
      "  return false;",
      "}",
      "",
      "bool buttonClickOrRepeat(uint8_t pin, bool &lastReading, bool &stableState, unsigned long &lastChange, unsigned long &holdStart, unsigned long &lastRepeat) {",
      "  bool reading = digitalRead(pin);",
      "  unsigned long now = millis();",
      "  if (reading != lastReading) { lastChange = now; lastReading = reading; }",
      "  if ((now - lastChange) >= DEBOUNCE_MS && reading != stableState) {",
      "    stableState = reading;",
      "    if (stableState == LOW) { holdStart = now; lastRepeat = now; return true; }",
      "    holdStart = 0;",
      "    lastRepeat = 0;",
      "  }",
      "  if (stableState == LOW && holdStart > 0 && now - holdStart >= HOLD_REPEAT_START_MS && now - lastRepeat >= HOLD_REPEAT_INTERVAL_MS) {",
      "    lastRepeat = now;",
      "    return true;",
      "  }",
      "  return false;",
      "}",
      "",
      "void handleConfirm() {",
      "  if (gameMode == MODE_WORLD) { int8_t dx = 0; int8_t dy = 0; facingDirection(dx, dy); tryMove(dx, dy); }",
      "  else if (gameMode == MODE_ACTOR_PROMPT) showMenu(MENU_MAIN);",
      "  else if (gameMode == MODE_MENU) confirmMenuItem();",
      "  else if (gameMode == MODE_TARGET) finishAction();",
      "  else if (gameMode == MODE_SYSTEM_MENU) confirmSystemMenuItem();",
      "}",
      "",
      "void handleReject() {",
      "  if (gameMode == MODE_WORLD) { int8_t dx = 0; int8_t dy = 0; facingDirection(dx, dy); tryMove(-dx, -dy); }",
      "  else if (gameMode == MODE_MENU && currentMenu != MENU_MAIN) showMenu(MENU_MAIN);",
      "  else if (gameMode == MODE_TARGET) showMenu(MENU_MAIN);",
      "  else if (gameMode == MODE_SYSTEM_MENU) closeSystemMenuToWorld();",
      "}",
      "",
      "void updatePotSelection() {",
      "  if (gameMode == MODE_MENU) {",
      "    uint8_t nextIndex = potToIndex(menuCount());",
      "    if (nextIndex != selectedIndex) { selectedIndex = nextIndex; renderTextMenu(); }",
      "  } else if (gameMode == MODE_SYSTEM_MENU) {",
      "    uint8_t nextIndex = potToIndex(systemMenuCount());",
      "    if (nextIndex != selectedIndex) { selectedIndex = nextIndex; renderSystemMenu(); }",
      "  } else if (gameMode == MODE_TARGET) {",
      "    uint8_t nextRow = potToIndex(2);",
      "    if (!targetIsSelectable(pendingAction, nextRow)) {",
      "      nextRow = pendingAction == ACTION_HIT ? firstAlive(foeHp) : firstAlive(partyHp);",
      "    }",
      "    if (nextRow != selectedTargetRow) { selectedTargetRow = nextRow; renderTargetSelect(); }",
      "  }",
      "}",
      "",
      "void updateBlink() {",
      "  bool shouldRender = false;",
      "  unsigned long now = millis();",
      "  if (gameMode != MODE_MENU && gameMode != MODE_TARGET && gameMode != MODE_ACTOR_PROMPT && gameMode != MODE_SYSTEM_MENU) return;",
      "  if (gameMode == MODE_ACTOR_PROMPT && now - lastActorPromptAlternate >= ACTOR_PROMPT_ALTERNATE_MS) {",
      "    lastActorPromptAlternate = now;",
      "    actorPromptPage = actorPromptPage == 0 ? 1 : 0;",
      "    shouldRender = true;",
      "  }",
      "  if (now - lastBlink >= BLINK_MS) {",
      "    lastBlink = now;",
      "    blinkOn = !blinkOn;",
      "    shouldRender = true;",
      "  }",
      "  if (!shouldRender) return;",
      "  if (gameMode == MODE_MENU) renderTextMenu();",
      "  if (gameMode == MODE_SYSTEM_MENU) renderSystemMenu();",
      "  if (gameMode == MODE_TARGET) renderTargetSelect();",
      "  if (gameMode == MODE_ACTOR_PROMPT) renderActorPrompt();",
      "}",
      "",
      "void printHelp() {",
      "  Serial.println(F(\"SevenSeg Combined Game Test\"));",
      "  Serial.println(F(\"World: A4 facing, D5 forward, D4 backward\"));",
      "  Serial.println(F(\"World hold: 500ms then repeat every 200ms\"));",
      "  Serial.println(F(\"World menu: hold D4+D5 for 1 second\"));",
      "  Serial.println(F(\"Battle: A4 choose, D5 confirm, D4 reject/back\"));",
      "}",
      "",
      "void setup() {",
      "  Serial.begin(9600);",
      "  pinMode(CONFIRM_BUTTON_PIN, INPUT_PULLUP);",
      "  pinMode(REJECT_BUTTON_PIN, INPUT_PULLUP);",
      "  initDisplay();",
      "  initAudio();",
      "  randomSeed((unsigned long)analogRead(CONTROL_POT_PIN) ^ micros());",
      "  printHelp();",
      "  resetWorldmap();",
      "}",
      "",
      "void loop() {",
      "  updateDisplayBrightness();",
      "  updateMusicPlayback();",
      "  updateActorTimers();",
      "  updatePotSelection();",
      "  updateBlink();",
      "  if (gameMode == MODE_WORLD) {",
      "    bool confirmMove = buttonClickOrRepeat(CONFIRM_BUTTON_PIN, lastConfirmReading, stableConfirmState, lastConfirmChange, confirmHoldStart, lastConfirmRepeat);",
      "    bool rejectMove = buttonClickOrRepeat(REJECT_BUTTON_PIN, lastRejectReading, stableRejectState, lastRejectChange, rejectHoldStart, lastRejectRepeat);",
      "    bool bothButtonsHeld = stableConfirmState == LOW && stableRejectState == LOW;",
      "    if (bothButtonsHeld) {",
      "      if (!systemMenuComboArmed) {",
      "        systemMenuComboArmed = true;",
      "        systemMenuOpened = false;",
      "        systemMenuHoldStart = millis();",
      "      }",
      "      if (!systemMenuOpened && millis() - systemMenuHoldStart >= SYSTEM_MENU_HOLD_MS) {",
      "        systemMenuOpened = true;",
      "        showSystemMenu();",
      "        return;",
      "      }",
      "      return;",
      "    } else {",
      "      systemMenuComboArmed = false;",
      "      systemMenuOpened = false;",
      "    }",
      "    if (movementLockedUntilRelease) {",
      "      if (stableConfirmState == HIGH && stableRejectState == HIGH) movementLockedUntilRelease = false;",
      "    } else {",
      "      if (confirmMove) handleConfirm();",
      "      if (!movementLockedUntilRelease && rejectMove) handleReject();",
      "    }",
      "  } else {",
      "    if (debouncedPress(CONFIRM_BUTTON_PIN, lastConfirmReading, stableConfirmState, lastConfirmChange)) handleConfirm();",
      "    if (debouncedPress(REJECT_BUTTON_PIN, lastRejectReading, stableRejectState, lastRejectChange)) handleReject();",
      "  }",
      "}",
      ""
    ].join("\n");
  }

  function preflightCombinedGameProject(project) {
    if (!window.SevenSegPreflight || typeof window.SevenSegPreflight.run !== "function") {
      return {
        status: "block",
        blockers: [{
          code: "PREFLIGHT_UNAVAILABLE",
          message: "Combined-game preflight is unavailable."
        }],
        warnings: []
      };
    }

    return window.SevenSegPreflight.run(
      project || window.SevenSegModel.defaultProject,
      { finalExport: false }
    );
  }

  function assertCombinedGameExportable(project) {
    var report = preflightCombinedGameProject(project);

    if (report.blockers.length) {
      var error = new Error(
        "Combined export blocked: " +
        report.blockers.slice(0, 3).map(function (entry) {
          return entry.message;
        }).join(" ")
      );
      error.name = "SevenSegPreflightError";
      error.preflightReport = report;
      throw error;
    }

    return report;
  }

  var arduinoTestsDirectoryHandle = null;

  function padTimestampPart(value, width) {
    return String(value).padStart(width, "0");
  }

  function arduinoTimestamp(date) {
    return [
      date.getFullYear(),
      padTimestampPart(date.getMonth() + 1, 2),
      padTimestampPart(date.getDate(), 2),
      "_",
      padTimestampPart(date.getHours(), 2),
      padTimestampPart(date.getMinutes(), 2),
      padTimestampPart(date.getSeconds(), 2),
      "_",
      padTimestampPart(date.getMilliseconds(), 3)
    ].join("");
  }

  function safeSketchBaseName(name) {
    var baseName = String(name || "SevenSeg_Test")
      .replace(/\.ino$/i, "")
      .replace(/[^A-Za-z0-9_]/g, "_")
      .replace(/_+/g, "_")
      .replace(/^_+|_+$/g, "");

    if (!baseName || !/^[A-Za-z]/.test(baseName)) {
      baseName = "SevenSeg_" + baseName;
    }

    return baseName;
  }

  function downloadIno(filename, code) {
    var blob = new Blob([code], { type: "text/plain" });
    var url = URL.createObjectURL(blob);
    var link = document.createElement("a");

    link.href = url;
    link.download = filename;
    document.body.appendChild(link);
    link.click();
    link.remove();
    URL.revokeObjectURL(url);
  }

  async function getArduinoTestsDirectory() {
    if (arduinoTestsDirectoryHandle) {
      return arduinoTestsDirectoryHandle;
    }

    var selectedDirectory = await window.showDirectoryPicker({
      id: "sevenseg-arduino-tests",
      mode: "readwrite"
    });

    if (selectedDirectory.name === "Arduino_Tests") {
      arduinoTestsDirectoryHandle = selectedDirectory;
    } else {
      arduinoTestsDirectoryHandle = await selectedDirectory.getDirectoryHandle("Arduino_Tests", {
        create: true
      });
    }

    return arduinoTestsDirectoryHandle;
  }

  async function exportIno(sketchBaseName, code) {
    var baseName = safeSketchBaseName(sketchBaseName);
    var sketchName = baseName + "_" + arduinoTimestamp(new Date());
    var filename = sketchName + ".ino";

    if (typeof window.showDirectoryPicker === "function") {
      try {
        var arduinoTestsDirectory = await getArduinoTestsDirectory();
        var sketchDirectory = await arduinoTestsDirectory.getDirectoryHandle(sketchName, {
          create: true
        });
        var sketchFile = await sketchDirectory.getFileHandle(filename, {
          create: true
        });
        var sketchWriter = await sketchFile.createWritable();

        await sketchWriter.write(code);
        await sketchWriter.close();

        var markerFile = await arduinoTestsDirectory.getFileHandle("LATEST_" + baseName + ".txt", {
          create: true
        });
        var markerWriter = await markerFile.createWritable();

        await markerWriter.write(
          "Latest export: " + sketchName + "\n" +
          "Sketch: " + sketchName + "/" + filename + "\n"
        );
        await markerWriter.close();

        return {
          canceled: false,
          savedToFolder: true,
          sketchName: sketchName,
          filename: filename,
          relativePath: "Arduino_Tests/" + sketchName + "/" + filename
        };
      } catch (error) {
        if (error && error.name === "AbortError") {
          return {
            canceled: true,
            savedToFolder: false,
            sketchName: sketchName,
            filename: filename
          };
        }

        arduinoTestsDirectoryHandle = null;
      }
    }

    downloadIno(filename, code);
    return {
      canceled: false,
      savedToFolder: false,
      sketchName: sketchName,
      filename: filename,
      relativePath: filename
    };
  }

  window.SevenSegArduino = {
    arduinoDisplayFoundation: arduinoDisplayFoundation,
    generateTextTestIno: generateTextTestIno,
    generateGlyphDataTestIno: generateGlyphDataTestIno,
    generateWorldDataModesTestIno: generateWorldDataModesTestIno,
    generateGateChestTestIno: generateGateChestTestIno,
    generateRewardLevelTestIno: generateRewardLevelTestIno,
    generateBossEndingTestIno: generateBossEndingTestIno,
    generateMusicHardwareTestIno: generateMusicHardwareTestIno,
    generateWorldmapTestIno: generateWorldmapTestIno,
    generateBattleTestIno: generateBattleTestIno,
    generateCombinedGameIno: generateCombinedGameIno,
    preflightCombinedGameProject: preflightCombinedGameProject,
    assertCombinedGameExportable: assertCombinedGameExportable,
    exportIno: exportIno,
    downloadIno: downloadIno
  };
}());