Guía para agentes de código

LostMagic: datos del juego para hacer tu propia versión

LostMagic (Taito, 2006, Nintendo DS) es un juego de táctica. Isaac, el protagonista, lanza hechizos dibujando runas en la pantalla táctil y pelea junto a los monstruos que recluta, en una historia cuyas decisiones llevan a cuatro finales.

Estos archivos tienen lo que se extrajo del cartucho del juego (versión de EE. UU.): los sprites y las animaciones de cada unidad, los retratos de los personajes, los mapas de batalla con dónde empieza cada enemigo, la historia completa con sus decisiones y la lógica que ordena las misiones, los textos en inglés, español, francés y alemán, la música, los efectos de sonido y el resto del arte. Úsalos para hacer una versión del juego en cualquier plataforma.

URL base: https://lostmagic.skapxd.dev/

Las rutas dentro de los JSON empiezan con / y son relativas a la URL base.

Para descargarlo todo de una vez: https://lostmagic.skapxd.dev/data/files.txt (una URL por línea).

Archivos

Convenciones

• Cada archivo de /data/ viene en dos formatos con el mismo contenido: .md, en tablas, más fácil de leer y con menos tokens, y .json, para cargar los datos desde un programa. Los campos que se describen abajo son las claves del JSON; las tablas del Markdown usan los mismos nombres en sus columnas (name.en, name.es para los dos idiomas).
• Cada una de las dos pantallas de la DS mide 256×192 px. Las escenas de la historia se dibujan para la de arriba.
• Las coordenadas están en píxeles, desde la esquina superior izquierda, con la y creciendo hacia abajo.
• Las duraciones vienen en ticks de 1/60 s, la frecuencia de cuadros de la consola. Los campos ms son lo mismo, redondeado.
• El arte es pixel art: escálalo por números enteros, con muestreo del vecino más cercano, para que se vea nítido.
• Los nombres vienen en inglés y en español como { "en": …, "es": … }. La historia tiene cuatro idiomas.
• Las imágenes son PNG; los GIF animados son solo vistas previas. El audio es AAC en .m4a: conviértelo si tu plataforma no reproduce AAC.

Unidades y sus animaciones

/data/units.json lista todas las unidades: uid (el número que usan las batallas y la historia; null en las apariencias sin nombre), slug, name, element (fire, wind, water, earth, dark, light o null), un retrato (portrait), la hoja (sheet) y details, la URL con todos sus datos.

Cada unidad tiene una hoja de sprites: un PNG con todos los cuadros que usa. sheet.cells da el rectángulo exacto de cada cuadro en la hoja (x, y, w, h); su posición en la lista es el número del cuadro.

Una animación es una secuencia de cuadros que se repite, dibujada sobre un lienzo fijo de width × height:

• Cada elemento de frames dice qué cuadro de la hoja se muestra (cell), dónde va su esquina superior izquierda en el lienzo (x, y) y durante cuánto tiempo (ticks). Un mismo cuadro puede aparecer varias veces.
• origin es el punto de anclaje de la unidad en el lienzo. Queda fijo mientras los cuadros se mueven a su alrededor: así se desplaza el cuerpo en los saltos y los ataques. Coloca el lienzo de modo que origin caiga en la posición de la unidad.
• action y facing dicen cuándo la reproduce el juego: la acción de la unidad y hacia dónde mira (down de frente, up de espaldas, left, right; vacío si la acción no tiene dirección). used es false en las que están dibujadas pero el juego nunca reproduce.
• preview es la misma animación como GIF, para ver qué muestra. Los GIF guardan los tiempos en 1/100 s y unen los cuadros repetidos, así que usa frames para los tiempos.

Las acciones:

Si una unidad no tiene animación propia para una acción, se queda en su pose idle. Las que miran a la derecha son dibujos aparte, no un espejo hecho al reproducirlas.

{
  "uid": 1,
  "slug": "isaac",
  "name": {
    "en": "Isaac",
    "es": "Isaac"
  },
  "element": null,
  "description": {
    "en": "A 14 year old boy. His face plainly displays his emotions.",
    "es": "Un joven. Su rostro muestra emociones."
  },
  "stats": {
    "hp": [
      300,
      450
    ],
    "mp": [
      30,
      130
    ],
    "attack": [
      80,
      80
    ],
    "defense": [
      25,
      38
    ],
    "magic": [
      30,
      130
    ],
    "magic_defense": [
      87,
      92
    ],
    "speed": [
      21,
      23
    ],
    "accuracy": [
      100,
      100
    ],
    "evasion": [
      0,
      30
    ]
  },
  "growth": "linear",
  "up_cost": 1,
  "squad_size": 1,
  "flying": false,
  "ranged": false,
  "can_capture_crystals": true,
  "attack_interval_ticks": 60,
  "attack_reach_px": 0,
  "radius_px": 8,
  "head_px": 19,
  "speed_px_per_tick": [
    0.65625,
    0.71875
  ],
  "attack_strike_ticks": 8,
  "attack_element": null,
  "projectile_type": null,
  "shot_start_px": null,
  "sight_px": 0,
  "keep_distance_px": 0,
  "terrain_spared": [],
  "attack_used_by": "dance_spells",
  "attack_note": {
    "en": "Never attacks: its Attack is used only by the dance spells. Isaac deals damage with his spells and the creatures he sends.",
    "es": "Nunca ataca: su Ataque solo lo usan los hechizos de baile. Isaac hace daño con sus hechizos y con las criaturas que manda."
  },
  "portrait": {
    "url": "/unidades/isaac/retrato.png",
    "width": 125,
    "height": 125
  },
  "sheet": {
    "url": "/unidades/isaac/hoja.png",
    "width": 1012,
    "height": 156,
    "cells": [
      {
        "x": 6,
        "y": 10,
        "w": 32,
        "h": 32
      },
      "…"
    ]
  },
  "animations": [
    {
      "index": 1,
      "action": "walk",
      "facing": "down",
      "used": true,
      "preview": "/unidades/isaac/01.gif",
      "width": 35,
      "height": 34,
      "origin": {
        "x": 20,
        "y": 23
      },
      "frames": [
        {
          "cell": 4,
          "x": 3,
          "y": 2,
          "ticks": 15,
          "ms": 250
        },
        "…"
      ]
    },
    "…"
  ],
  "battles": [],
  "casts_spells": []
}

battles lista las batallas de la historia en las que participa la unidad.

Para dibujar el cuadro i de una animación: toma el rectángulo sheet.cells[frames[i].cell] y pégalo en el lienzo en (frames[i].x, frames[i].y). Muéstralo durante frames[i].ticks / 60 segundos, pasa al siguiente y, al terminar, vuelve al primero.

Estadísticas

Cada unidad con nombre trae, en /data/units/<slug>.json, sus números de las tablas del juego:

• stats: hp (vida), mp (maná), attack, defense, magic, magic_defense, speed, accuracy y evasion, cada una como [nivel 1, nivel 50]. En el nivel L vale nivel1 + floor((nivel50 − nivel1) × factor / 128), donde factor es el valor de la curva growth de la unidad (early, late o linear) para el nivel L en /data/levels.json.
• speed_px_per_tick: cuánto camina por tick en los niveles 1 y 50; es speed / 32. Las que vuelan usan la misma velocidad.
• flying, ranged (su ataque normal es un proyectil), attack_interval_ticks (tiempo entre ataques), attack_reach_px (ataca cuando la separación entre los bordes de las dos unidades es menor que esto) y radius_px (su cuerpo es un círculo de ese radio).
• head_px: la altura de su cabeza sobre su punto; la barra de vida y los íconos de estado van encima.
• up_cost (lo que ocupa de la capacidad del equipo) y squad_size (cuántas unidades trae un escuadrón).
• attack_used_by: para qué sirve su estadística attack. normal_attack, su ataque normal. Las que nunca atacan (attack_reach_px 0) traen dance_spells (Isaac: solo lo usan los hechizos de baile, que golpean con su ataque completo menos un cuarto de la defensa del objetivo) o nothing (los magos, los jefes de la historia y el Aldeano: no se usa nunca). attack_note lo explica en inglés y en español, y dice cómo hace daño la unidad. /data/units.json trae los dos campos de cada unidad.
• element es el elemento de la unidad, y description el texto del juego sobre ella, en inglés y en español.

/data/levels.json tiene, por nivel: exp_to_next (la experiencia para subir al siguiente), los factores de las tres curvas (growth, sobre 128) y lineup_up, cuántos UP de unidades admite el equipo en ese nivel de Isaac.

Movimiento e IA

/data/ai.json describe cómo se mueven las unidades y qué hacen por su cuenta. Sale de leer el código del juego (evidence: static); no se observó en un emulador.

• movement: las rutas son rectas (route: straight), sin búsqueda de caminos, con hasta route_points_max puntos; una unidad llega a un punto cuando está a menos de point_reached_distance_px. Un grupo enviado a un punto se reparte alrededor: cada unidad va al punto más su dirección desde el centro del grupo × (su radio + group_spacing_extra_px). Una unidad camina velocidad / 32 px por tic, sin aceleración; los obstáculos y las demás unidades la empujan hacia afuera.

• Objetivo: cada retarget_every_ticks tics, en los estados states_with_target_search, busca enemigos a menos de search_px y elige el más cercano, el de más vida o el de menos vida (estas dos prefieren a los que están a su alcance).

• orders: cada orden (order, con las clases del juego en classes) fija un estado de decisión (state):

  • wait con modo 0 (estado 0) ataca sin perseguir a quien entre en su alcance + attack_in_place_extra_px; con otro modo (state_other_mode, 1) persigue dentro de su radio de visión.
  • move sigue la ruta sin atacar; move_auto ataca de paso sin salirse; move_attack persigue dentro de su radio de visión o sigue la ruta; move_wait_auto sigue la ruta, persigue y, detenida, espera.
  • guard (estados 9 y 10) vigila un punto: guard dice cuándo vuelve (distance > sight) y hasta dónde (distance <= sight / 2).
  • escape (11) huye en línea recta mientras la distancia entre centros es menor que la keep_distance de la unidad (/data/units.json).
  • take_crystal (8) va al cristal de maná de otro bando más cercano a menos de order_list.take_crystal_radius_px y se queda hasta que es de su bando.

  El radio de visión es el sight de cada unidad, y las misiones lo cambian.

• unresolved_states: los estados que existen pero de los que no se sabe todavía qué orden los produce.

Órdenes de las unidades en las batallas

Cada unidad de una batalla de /data/maps.json trae orders, su lista de órdenes; vacía, la unidad no recibe ninguna al empezar. unit_orders de /data/ai.json describe cada orden: state es el estado en que deja a la unidad (null: no lo cambia), target cómo da el punto y ends cuándo termina.

• Puntos: x, y es un punto del mapa en px; dx, dy se suman a la posición de la unidad cuando la orden empieza. La unidad camina en línea recta hasta él.
• wait: ticks (null: para siempre); chase: false es el estado 0 (ataca sin moverse), true el 1 (persigue dentro de su visión).
• back: vuelve steps órdenes atrás, nunca antes de la primera. Así se repiten las patrullas.
• target_nearest, target_most_hp, target_least_hp: con qué regla elige objetivo desde ahí. set_sight: su radio de visión pasa a sight_px.
• change_max_hp: su vida máxima pasa a floor(máxima × percent / 100); set_max_hp: a hp. Su vida actual pasa a ese mismo valor, sin superar la máxima que tenía.
• guard no termina nunca: la lista se queda ahí.

Cómo corre la lista (order_list), un paso por tic (steps_per_tick):

1. Empieza en la primera orden. El tic en que una orden empieza no cuenta para terminarla.
2. ends: at_once termina el mismo tic en que empieza; route, el primer tic después de que la unidad llega al punto (al llegar queda en el estado route_end_state); ticks, cuando lleva ticks tics contados después del de inicio, en el tic siguiente; crystal, cuando el cristal es de su bando, o al empezar si no hay ninguno tan cerca; jump es back; removed, como at_once, y además la orden sale de la lista.
3. La orden siguiente empieza en el tic siguiente. Con wait de ticks N, la siguiente empieza N + 2 tics después de que empezó la espera.
4. back cuenta solo las órdenes que siguen en la lista: removed_when_done ya no están.
5. Al terminar la última, la unidad se queda en el estado en que estaba y no recibe más órdenes.

Ejemplo, el primer Hongo bruma de la batalla 1: change_max_hp 75 (sale de la lista), move a (344, 153), wait 30, move a (344, 133), wait 30, back 4. Patrulla entre los dos puntos y se queda en cada uno los 30 tics de la espera más los tics en que la lista avanza; no ataca al caminar y ataca sin moverse al esperar.

Duelo

/data/duel.json describe el modo duelo, en el que juegan dos personas. Sale de los datos y el código del juego (DB/chrSelScnDat.cssd, DB/eloRate.elo); no se observó en un emulador.

• presets: los 8 equipos predefinidos que se pueden elegir. Cada uno tiene level (el nivel del jugador, 40), element_levels (los seis niveles de elemento, que el juego limita a 1–50) y squads, tres escuadrones (unit_id de /data/units.json, name, slug y level). El cartucho no les da nombre: se numeran del 1 al 8.
• rating: la puntuación de las partidas por Wi-Fi, entre min y max. rows tiene, por fila, el límite de la diferencia (difference, puntuación propia − la del rival) y los puntos que suma una victoria (win), un empate (draw) o una derrota (loss). Con diferencia negativa se usa la primera fila cuyo límite es mayor o igual que la diferencia; con cualquier otra, la última fila cuyo límite es menor o igual. Después la puntuación se mantiene entre min y max. elo_k vale 50 porque las 53 filas coinciden, a menos de un punto, con el sistema Elo de K = 50: K × (resultado − 1 / (1 + 10^(−diferencia/400))), con resultado 1, 0,5 o 0.

Reglas del juego

/data/rules.json tiene los límites del juego, leídos de su código:

• team: squads_max, los escuadrones que entran con Isaac, nunca más que los puntos de inicio de escuadrón del mapa; player_units_max; formation_px, dónde empieza cada unidad de un escuadrón respecto de su punto de inicio (la y crece hacia abajo); capacity_up_by_isaac_level, los UP que admite el equipo en cada nivel de Isaac, desde el nivel 1.
• roster: monsters_max, los monstruos que se pueden guardar, y captures_per_battle_max.
• items: inventory_max, found_level_max (el nivel más alto de un objeto encontrado) y found_per_battle_max.
• levels: level_max de Isaac y los monstruos, element_level_max y enemy_level_max.
• experience: per_kill_per_level (cada unidad que muere da ese número × su nivel), battle_max y level_1_to_max.
• battle: default_time_limit_s, el límite cuando la misión no fija otro.
• new_game_plus: los niveles que suben los enemigos en cada capítulo (del 1 al 5, con el tope de levels.enemy_level_max) y los niveles extra de los objetos de los cofres (con el tope de items.found_level_max).
• checkpoints: cuántas misiones y escenas del mapa y cuántas batallas libres toman un punto de control al empezar.

Las reglas que no son un número:

• Isaac siempre está en el equipo y no lleva objetos. Cada escuadrón lleva un objeto, que afecta a todas sus unidades, y tiene tantas unidades como el squad_size de su especie.
• El UP solo se comprueba al armar el equipo, no en la batalla.
• Solo se capturan unidades enemigas comunes, no jefes ni aliados. Se suman al ganar, con su nivel de la batalla y 0 de experiencia. Se permiten especies repetidas en la lista y objetos repetidos en el inventario; con la lista llena, la nueva reemplaza a una que no esté en un escuadrón o se descarta.
• Da experiencia toda unidad del bando enemigo o aliada del mapa que muere, la mate quien la mate; las capturadas no dan nada. Al ganar, Isaac y cada escuadrón reciben el total, sin repartirlo.
• Una derrota o un empate descartan todo lo ganado en la batalla. Al continuar, la historia y las runas vuelven al punto de control, que se toma cuando una misión, escena o batalla libre empieza desde el mapa; nivel, monstruos y objetos se conservan, y la misión se repite desde el principio.
• Retirarse desde la pausa descarta la batalla y lleva al título, sin continuar.
• En la nueva partida+ Isaac conserva nivel, experiencia, niveles de elemento, runas, monstruos, equipo y objetos; la historia vuelve a empezar con batallas más difíciles.
• La pantalla de resultados, solo al ganar, muestra en orden: experiencia y niveles de elemento, objetos encontrados, monstruos capturados y hechizos nuevos. No hay rangos ni notas.
• No hay dinero ni tienda, ni un máximo de unidades en el campo o de hechizos activos. Isaac puede lanzar en cuanto termina la animación del hechizo anterior; el límite es el MP.

Objetos

/data/items.json tiene los 8 objetos. Cada escuadrón lleva uno, que se aplica a todas sus unidades al empezar la batalla; Isaac no lleva ninguno.

icon es el ícono de 16 × 16 px que muestran los menús. Depende de la estadística que mejora el objeto, así que varios lo comparten. En la batalla no se dibuja ningún ícono de objeto: los cofres se ven siempre igual.

pictures son los íconos de cada objeto en los niveles 1 a 6, hechos con IA para este sitio: no están en el juego. sheet es la hoja de 120 × 160 px y by_level da la celda de 20 × 20 px de cada nivel (x, y, w, h). Desde el nivel 2 el ícono lleva un aura de otro color, y desde el nivel 4, destellos. Para verlos nítidos, escálalos en múltiplos enteros con image-rendering: pixelated.

• stat: la estadística que cambia (hp, speed, attack, interval, accuracy, evasion, defense o magic_defense).
• bonus_by_level: el valor v en los niveles 1 a 10, sobre 128. Los cofres solo dan niveles 1 a items.found_level_max de /data/rules.json.
• effect, cómo se aplica v a la estadística x de la unidad:
  • multiply: x + floor(x × v / 128). Con hp, la unidad además empieza con la vida llena.
  • reduce: x − floor(x × v / 128), como mínimo 1.
  • double: x × 2, en cualquier nivel.
  • gap_to_100: x + floor((100 − x) × v / 128).
• in_battle (Escudo vi., Ojo cazador, Pelliza áng. y Escama drag.; null en los demás): qué cambia el objeto en la batalla, en en y es: what (qué es la estadística), examples (ejemplos con unidades de nivel 1), good, bad, caution, level (cuando el nivel del objeto no importa) y anchor (la sección de /logic/combat/ con la regla). examples trae los mismos ejemplos como números: accuracy, evasion y hit_percent como [sin el objeto, con él].
• chests: los cofres de la historia que pueden dar el objeto: battle (el mismo número que en /data/maps.json), map, la posición x, y en píxeles del mapa, chance (0 a 1), levels, la probabilidad de cada nivel, y new_game_plus_levels, la misma probabilidad en la nueva partida+.

El nivel 6 casi no sale en la historia: los cofres dan hasta nivel 5, salvo un cofre de Cuerno dem. en el mapa 038 (1,1 %). En la nueva partida+ el juego suma new_game_plus.chest_level_bonus (2) al nivel del cofre, con tope items.found_level_max (6), así que los cofres de nivel 4 y 5 dan nivel 6.

Cómo deciden un golpe la precisión y la evasión (las estadísticas de cada nivel están en /data/units/<slug>.json; el Ojo cazador duplica la precisión del atacante y la Pelliza áng. la evasión del defensor, en cualquier nivel del objeto):

• Cuerpo a cuerpo acierta cuando un número al azar del 0 al 100, más la precisión, menos la evasión, llega a 100: una probabilidad de clamp(precisión − evasión + 1, 0, 101) / 101.
• Un disparo acierta cuando un número al azar del 0 al 99 es menor que (precisión − evasión) & 0xff: el juego guarda un solo byte de la diferencia. Así que acierta siempre si la evasión supera a la precisión, y desde una diferencia de 256 vuelve a empezar desde 0 (un tirador con el Ojo cazador puede acertar menos). Sale de leer el código del juego (ov1 0x2130f40); no se probó en un emulador.

godot dice cómo funcionará cada objeto en nuestro port a Godot (diseño aprobado, versión 1), aparte de los campos del original: same_as_original, effect y bonus_by_level como arriba (más add: x + bonus_by_level, en puntos), line_up_shows_effect (la pantalla de formación muestra el efecto de los 8), el texto en en y es (same, igual que same_as_original; change, qué cambia y por qué, o «Igual que el original»; examples; notes) y, en el Ojo cazador y la Pelliza áng., examples como números: hit_percent sin el objeto, by_level con el objeto en los niveles 1, 3, 5 y 6, y original_hit_percent con el objeto del original. En Godot:

• Ojo cazador: multiply, precisión × (1 + v/128), como el Cuerno dem.
• Pelliza áng.: add, 4 puntos de evasión por nivel (v × 40 / 128, redondeado).
• Un disparo acierta con una probabilidad de clamp(precisión − evasión, 0, 100) / 100: con la evasión mayor, falla siempre.
• Los demás objetos, los niveles (1 a 6, +2 en nueva partida+) y quién lleva objetos quedan como en el original.

Al cargar la batalla, el juego sortea el objeto y el nivel de cada cofre. El objeto es para la unidad del jugador que abre el cofre y se recibe al ganar. En la nueva partida+, el nivel sube 2, con el mismo tope.

/data/chest.json es el cofre como sprite:

• closed es la imagen cerrada que dibujan los mapas, puesta en el punto del cofre más (dx, dy).
• sheet tiene cells celdas iguales de cell.width × cell.height px en columns columnas. El punto del cofre está en cell.origin de cada celda.
• animations: idle0 (cerrado), open (se abre), loop (abierto con el premio), suka (humo) y emptybox (vacío). Cada frames es una lista de cell y ticks de 1/60 s. loop dice si se repite, y preview es un GIF o PNG para verla.
• flow: con premio, el juego pasa de idle0 a open y queda en loop; sin premio, de idle0 a emptybox. suka tiene used_by_game en false: el juego nunca la elige.

Hechizos y runas

Runas

/data/runes.json tiene las 18 runas: id (1 a 18), element, level (1 a 3), su imagen, spell (el hechizo que lanza sola) y learned (las misiones donde se aprende). Isaac lanza un hechizo dibujando de 1 a 3 runas en orden mientras mantiene L (R con la opción para zurdos); soltar el botón termina el canto. Cada runa es un solo trazo: levantar el lápiz la cierra.

templates son los trazos que el juego acepta para cada runa: puntos en una cuadrícula de 0 a 63 (y hacia abajo), en el orden en que se dibujan. from_dot marca los que empiezan en el punto de la imagen de la runa; los demás son el mismo dibujo desde otro inicio o en el otro sentido.

Para reconocer un trazo:

1. Guarda un punto por fotograma mientras se toca la pantalla. Después del primero, guarda solo los que avanzan al menos 1 px en x respecto del último guardado: el juego no mira el avance en y. Un trazo de menos de 4 puntos cancela el canto.
2. Toma un cuadrado centrado en el trazo, de lado max(ancho, alto), así que la proporción se conserva. Simplifícalo: conserva los dos extremos y, tramo a tramo, el punto más lejano de la cuerda si está a max(1, 2 × lado / 64) px o más, hasta 40 puntos. Pásalo a la cuadrícula de 0 a 63 con (p − origen) × 64 / (lado + 1) y quita los puntos repetidos seguidos.
3. Para cada punto k ≥ 1 calcula angle[k], la dirección del segmento que llega a él, y ratio[k], qué parte del largo total es ese segmento. El punto 0 toma la dirección del primer segmento.
4. Compara el trazo (I, con nI puntos) con cada plantilla (P, con nP puntos) recorriendo las dos líneas a la vez por su largo:

i = j = 1; remP = ratioP[1]; remI = ratioI[1]; score = 0
repeat nP + nI − 3 times:
  A = 1 − |angleP[j] − angleI[i]| / 180°        # angle difference wrapped to 0–180°
  if remP <= remI:
    remI −= remP
    q = I[i] if remI < ratioI[i] / 2 else I[i − 1]
    score += remP × A × (1 − manhattan(q, P[j]) / 128)
    j += 1; remP = ratioP[j]
  else:
    remP −= remI
    q = P[j] if remP < ratioP[j] / 2 else P[j − 1]
    score += remI × A × (1 − manhattan(I[i], q) / 128)
    i += 1; remI = ratioI[i]

5. Gana la plantilla de mayor puntuación (de 0 a 1); con empate, la primera. Si llega a accept (0,70), el trazo es su runa. La rotación no se tolera: unos 30° de giro ya quedan en el límite.

Una runa reconocida además tiene que estar aprendida, las runas dibujadas hasta ahí tienen que formar el comienzo de algún hechizo, no se puede pasar del límite de runas por hechizo (runes_per_spell: las misiones que permiten 2 y 3) y tiene que alcanzar el MP de esa runa. Si algo falla, el canto se cancela.

La calidad del hechizo es el promedio de las puntuaciones de sus runas. Si llega a great (0,85), se le suma 0,5: el factor va de 0,70–0,85 a 1,35–1,50.

En /es/logic/runes/practice/ se practica el trazado con este reconocedor, portado a TypeScript con la misma aritmética entera: dice la runa, el puntaje, si pasa accept o llega a great, el factor y las tres plantillas más cercanas. /data/rune-strokes.json trae 640 trazos de prueba con lo que da el reconocedor del juego en cada uno; un port tiene que dar lo mismo. Cada uno es samples (un punto por fotograma a 60 Hz, en píxeles de la pantalla táctil de 256 × 192) y kept (cuántos guarda la captura); con menos de 4, cancelled es true; si no, top son las tres plantillas más cercanas como [runa, plantilla, puntaje], con la plantilla numerada como en templates de /data/runes.json (las runas en orden) y el puntaje sobre 4096: se acepta desde 2868 y es excelente desde 3482.

Hechizos

/data/spells.json tiene los 396 hechizos:

• name: el nombre del cartucho en inglés y en español. Los españoles suelen venir abreviados (ninguno pasa de 12 caracteres, por ejemplo «Torbell. f.»); el sitio los conserva tal cual, sin ampliarlos ni traducirlos, y muestra el inglés al lado.
• runes: sus runas, en orden. element: su elemento, que es el de su última runa: 294 de los 396 combinan runas de distintos elementos.
• kind: la familia (cloud, wall, bullet, blast, falling_objects, aura, zone, unit_effect, object, dragon). variant: el comportamiento concreto dentro de la familia.
• mp_by_rank: el costo en MP con el elemento en el rango 0 a 4. El rango es floor((nivel del elemento − 1) / 10). El costo es la suma de sus runas: mp_per_rune[posición][rango del elemento de esa runa][nivel de la runa − 1] de /data/runes.json. Cada runa se cobra al dibujarla.
• targeting: cómo se apunta (circle: centro y radio; line: inicio y final; fixed_circle y point: un punto; direction: sale de Isaac hacia donde se suelta; unit: una unidad; instant: sin apuntar). targets: enemies, allies o all; es null en los tres que no tocan ninguna unidad (Transport y Flight mueven a quien los lanza, Restore solo cambia el suelo). numbers.cast_range_px es la distancia máxima desde Isaac.
• effect_group: solo en unit_effect (null en las demás familias), qué hace sobre las unidades. heal recupera vida o quita estados: la bandera heal, un estado de grupo cure o regeneration, o las variantes que pasan vida al propio bando (life_thread, life_shine, light_transfer). boost pone un estado a aliados y weaken a enemigos: todo estado que el juego lanza a aliados los ayuda y todo el que lanza a enemigos los perjudica. other es el resto: sin estado ni curación, o un estado a los dos bandos. Es la clasificación del filtro de la página de hechizos, no un campo del cartucho.
• power: con power_scaled, la potencia al lanzarlo es floor(floor((power + magia de quien lo lanza) × factor de calidad) × (rango + 4) / 4); sin power_scaled, se usa power tal cual. Con la bandera heal, cura.
• status: el estado que puede causar: su registro (id), group, chance (con rango 0 y factor 1; se multiplica por el factor, por (rango + 4) / 4 y por el factor de elemento de elements.status_chance de /data/combat.json), duration_ticks y power.
• terrain: cómo cambia el terreno (heat vuelve magma el suelo, harden endurece el magma, freeze congela el agua, dry seca el pantano en arena, swamp vuelve pantano la arena movediza, restore lo restaura).
• terrain_overlay: lo que el hechizo dibuja sobre el mapa mientras vive su zona, lasts_ticks (1200, 20 s). La zona es un círculo: area.radius_px, o un círculo de area.per_object_radius_px por cada objeto que cae. Se pintan las celdas de 8 × 8 px cuyo centro cae dentro del círculo. paints es la capa que pone y sobre qué superficie (on); image son sus 32 teselas animadas, cada cuadro de frame_ticks (null: fija). clears son las capas que borra dentro de su círculo mientras vive, aunque las haya puesto otro hechizo, antes o después. Así se anulan los opuestos: Storm borra el magma de Fire Rain y Fire Rain borra el hielo de Ice Maiden, y restore borra todo. Aparece de golpe y, al terminar la zona, desaparece sin animación: no hay animación de entrada ni de salida, y los cuadros de frame_ticks son un bucle de toda la capa. Es solo el dibujo: el efecto sobre las unidades lo dan los estados del terreno. on_any_map dice si esa superficie existe en algún mapa. dry pinta mf04 sobre pantano, pero ningún mapa tiene pantano (on_any_map: false): en el juego solo borra el pantano que deja swamp.
• flags: piercing atraviesa, homing persigue, rapid ráfaga, spread abanico, lock_on fija cada objetivo, flying_only y walking_only limitan a quién afecta, knockback empuja, knockdown derriba.
• numbers: los números de su familia, en tics de 1/60 s y en px.

Familias de hechizos

/data/spell-families.json agrupa los 396 hechizos por el código del juego que los ejecuta: la clase y el subtipo de efecto de sus datos. El hechizo genérico sobre unidades (direct) se divide por función (heal, damage o status-only) y grupo de estado, y Prank, Joke y Trick van juntos como tub. Cada familia tiene page (su página en el sitio, /logic/families/<family>/, o /es/logic/families/<family>/ en español: sus tipos y sus hechizos en una matriz elemento × variante (filas como Nivel I, Rápido o Rey, y «Otros» para los que no encajan) cuando la mayoría encaja, o en tarjetas, cada uno con su animación y un panel con todos sus datos; /logic/families/ es el catálogo con todas), spells (los slug de /data/spells.json), same (los campos iguales en todos, con su valor) y differs (los que cambian). Los campos son los de /data/spells.json: numbers.<nombre> y status.<campo> van aplanados, y runes es cuántas tiene. power solo se compara dentro de una familia, porque cada una lo usa distinto. note (EN/ES), cuando existe, dice cuándo conviene cada uno, solo donde la investigación lo sostiene; sale de leer el código, no de jugar. Las familias de un solo hechizo tienen same y differs vacíos.

total_effect dice, por hechizo, lo que recibe una unidad durante todo el hechizo, con la referencia fija de total_effect_reference: quien lo lanza tiene magia 30 (Isaac en nivel 1), el elemento en rango 0 (nivel 1–10) y un trazo perfecto (calidad 1, factor 1,5); quien lo recibe tiene defensa y defensa mágica 0, elemento neutro y ni debilidades ni escudos; sin el factor aleatorio. kind es damage, heal, status u other; hp es el daño o la curación en vida cuando lo hay (si no, null); text (EN/ES) dice cómo se suma o qué hace. Las reglas: el daño por golpe es floor(floor((power + 30) × 1,5) × (0 + 4) / 4), salvo en las nubes, que golpean con su power tal cual numbers.hits veces; quemadura y veneno suman status.power cada 60 tics, floor((status.duration_ticks − 1) / 60) veces, si el estado entra (la pasada de estados de la unidad descuenta la vida antes de cada golpe), y la regeneración cura una vez más porque la primera es al instante; la probabilidad del estado es status.chance × 1,5, como mucho 1. up_to marca un máximo: le llegan todos los disparos u objetos (ráfagas y objetos que caen), o la unidad se queda donde el hechizo la alcanza. El veneno normal solo avanza mientras la unidad se mueve o ataca. El dragón atraviesa a la unidad, sigue 192 px y vuelve, así que a una unidad quieta le pega en cada pasada: numbers.passes_max como mucho, passes_typical en la mayoría de los sitios, passes_min en el peor. Una armadura le pega a un enemigo que se queda dentro de su pulso numbers.touches_max veces con el poder y numbers.aura_ticks_max veces con status.power. Una danza son numbers.hits_max golpes de numbers.hit_attack (el ataque de Isaac en nivel 1, contra defensa 0). El torbellino pega una vez por contacto y solo persigue unidades que tiene delante, así que vuelve a pegarle a una unidad solo si esta vuelve a cruzarse en su camino. confirmed: false marca lo que el código leído no resuelve; desde el #256 ningún hechizo lo tiene.

Cada familia trae description (EN/ES): una frase sin números sobre lo que hace, armada desde sus datos con una plantilla por kind o variant y los efectos de al menos la mitad de sus hechizos («algunos también…» suma hasta tres de los demás). Lo que hace cada hechizo, calculado de sus datos y nunca escrito a mano, va en dos niveles: tags, efectos concretos (damage, heal, protect, empower, haste, weaken, burn, poison, freeze, sleep, charm, pacify, immobilize, knock, capture, summon, movement, terrain), y types, sus ocho grupos generales (attack, heal, buff, debuff, control, summon, movement, terrain). Los tags y types de arriba del archivo traen el nombre (EN/ES), el criterio y, en cada etiqueta, su type. Las reglas: damage si su efecto total es daño (o switch_life); heal con heal en flags, un efecto total que cura, un estado cure o regeneration, o light_transfer; el estado que aplica, con todas las ramas de un estado random, da el resto: un cambio de estadística hacia arriba protege (defensa, defensa mágica, evasión), fortalece (ataque, magia, precisión) o acelera (velocidad, o menos interval), y hacia abajo frena (velocidad; toda la velocidad o una burbuja inmovilizan) o debilita (lo demás, debilidad, virus, rebote, olvido); quemadura y veneno son burn y poison; sueño, congelación y encanto, los suyos; no atacar y terror, pacify; la furia (berserk) fortalece a un aliado y, lanzada a un enemigo, cuenta como charm. knockdown y knockback son knock; las trampas de captura, capture; kind wall, object o dragon, summon; variant transport, gather o self_cannon, movement; terrain o un estado de terreno, terrain. Holy Pulse no aplica un estado propio: fortalece a los aliados y debilita a los enemigos. En cada familia, tags y types listan los de sus hechizos, el más común primero, con spells = cuántos lo tienen; spell_types da los de cada hechizo.

Mejores hechizos

/data/best-spells.json dice qué hechizos le convienen al jugador, calculado a partir de los datos (evidence: static), no de jugar. El efecto de cada hechizo es hp_expected: el efecto total de /data/spell-families.json con la misma referencia, con la quemadura y el veneno contados por su probabilidad (en las nubes, la probabilidad de que caiga al menos una vez en sus golpes). spells trae por hechizo su mp, chapter (el capítulo en que Isaac ya aprendió todas sus runas y puede encadenar esa cantidad), stroke, reach_px (el mayor entre el alcance para lanzarlo y el del disparo), area_px (el radio, si tiene) y badges: per_mp, jump, easy y not_worth.

• rankings.per_mp: efecto por MP al menos el doble de la mediana de su familia (vs_family), o efecto al menos el doble de la mediana de los demás hechizos de su familia con el mismo MP (vs_same_mp).
• rankings.jumps: el siguiente hechizo por MP de la misma familia y elemento, con efecto ×2 o más y effect_ratio / mp_ratio ≥ 1,5.
• rankings.not_worth: otro hechizo de su familia y elemento (better) cuesta menos MP y es igual de bueno en todo; si gains_only no está vacío, el más caro solo gana en esos números.
• rankings.easy: todos los hechizos, del trazo más fácil al más difícil.
• Según la situación, solo los hechizos que hacen daño: grouped (con área, por efecto sobre cada unidad dentro), scattered (sin área que golpee también a los aliados; por mp_per_kill = MP × lanzamientos para quitarle la vida al enemigo débil, después por trazo y después por alcance) y boss (por efecto sobre una unidad). El enemigo débil (reference.weak_enemy) tiene la mediana de la vida de las unidades sin nombre de las batallas de los capítulos 1 y 2, a su nivel.

El puntaje de trazo (method.stroke) es una estimación de qué tan difícil es dibujar una runa a mano, no un dato del juego. Para cada forma que acepta la runa (templates de /data/runes.json, rejilla de 0 a 63 = un ancho de runa) se quitan los puntos a menos de min_step del anterior y se suma: el largo en anchos, w_sharp por cada esquina de más de sharp_deg grados, w_turn por cada vuelta completa (la suma de los ángulos de giro / 360°) y w_against por cada ancho que el trazo sube o va a la izquierda. La runa toma su forma más fácil (runes[].template, runes[].points) y el hechizo suma sus runas más w_extra_rune por cada runa después de la primera. El cuarto más fácil de los hechizos lleva la insignia easy.

Hechizos con reglas propias, por variant:

Escenas de hechizos

/data/spell-scenes.json (también .md) relaciona cada hechizo con sus gráficos y sonidos, sus jefes reales, las 90 apariencias de unidades y los 141 estados. La página de cada hechizo permite elegir lanzador, receptor, cuatro direcciones, distancia, calidad y resultado, repetir y activar el sonido. El receptor es aliado o enemigo según targets; los resultados y estados de ejemplo son selecciones del usuario, no tiradas de combate. Transport y Flight no tienen receptor ni resultado: su escena mueve al lanzador al destino.

• assets[id]: PNG, archivo CAN/NCER/NANR y paleta exacta; cells da rectángulos [x,y,w,h] de la hoja y origins su posición respecto al ancla. Un cuadro vacío sigue consumiendo su tiempo.
• sequences[].frames: [celda,tics,dx,dy,rotación en grados,escalaX,escalaY]. Incluye animaciones de un solo cuadro. mode: 1 una vez, 2 bucle, 3 ida y vuelta una vez, 4 ida y vuelta en bucle; loop_start es el cuadro inicial del bucle. ticks y seconds conservan la duración original.
• units[].actions[acción][dirección]: secuencia, own y fallback. Los monstruos sin conjuro o lanzamiento usan reposo. launch_px coloca el disparo. boss_spells identifica los hechizos que el jefe usa en batalla.
• spells[].graphics: función, hoja, secuencias, paleta, evidencia y confianza. times_seconds convierte los campos de tiempo del hechizo. Las distancias siguen en px; un proyectil tarda distancia/velocidad, redondeada al tic siguiente.
• sounds: audio, ancla (chant, stroke, rune, cast, release, shot, hit, status, death, vanish, capture, capture_close), desplazamiento en segundos y tics, condición y confianza. timing_confidence separa la atribución del sonido de su colocación de ejemplo. Rune/stroke se repiten por runa; hit por disparo. Calidad <0,85 usa KAKUNIN/INVOKE; ≥0,85 usa MENU_MAGIC/INVOKE2. El sonido se activa mediante interacción.
• statuses[].overlay, popup, sounds y duration_seconds describen el estado. /data/statuses.json también incluye este objeto como visual.
• Derribo usa solo la bandera 0x800: 40 tics en el suelo y 10 al levantarse; empuje, solo 0x400 y desacelera 30 tics. Derrota reproduce die, espera 30 tics, usa la nube 272 para monstruos y elimina después de 80. La captura resuelta usa capture_timing: cierre exitoso a los 2 tics, retirada de la unidad a los 33, o cierre fallido/liberación a los 60; las secuencias de libro 199/200 determinan el final, sin prolongarlo por la vida de la trampa armada.

Los muros (clase 1) crean estructuras en el terreno, sin receptor ni resultado de impacto. structure_timing conserva los 5 tics entre pilares; targeting distingue línea y círculo. Los estados elementales se aplican por contacto, no al colocar el muro. El visor permite ajustar la longitud de la línea.

La orientación de los proyectiles está en graphics[].rotation: el gráfico original apunta arriba y la ROM añade 90° al ángulo de movimiento. La estela hereda ese ángulo; oscuridad y luz giran 16,875°/tic. La fase inicial aleatoria se fija a 0 en la vista. El manifiesto tiene revision para evitar reutilizar datos de una exportación anterior en el navegador.

La composición de la escena es ilustrativa: no reproduce un combate completo. preview declara el ritmo de dibujo (0,8 s por runa) y las convenciones; confidence/evidence distinguen lo leído del código de lo probable. El seguimiento extraccion/investigacion/visuals/SCENE_DISPATCH.md confirma por código los sonidos de conjuro/trazo, el icono del byte 7 y las tablas de Fallthing. Las entradas cero omiten ese sonido. Las demás familias usan sus propias llamadas; fall y object_hit se repiten por objeto, con descenso de 20 tics como convención de la vista.

visual_behavior distingue efectos compartidos (Holy Pulse: icono 11; Life Thread/Life Shine: icono 7), movimiento de unidad (Self Cannon: unit_motion, 2 px/tic, separación de contacto 12 px) y estados condicionales (Betrayal/Mutiny/Uprising: choices). dance (los seis bailes, 361–366) marca que quien baila es Isaac: camina hasta el receptor a approach_px_per_tick (2), baila a su lado numbers.duration_ticks (300; está en el registro del hechizo, como en /data/spells.json) cuando la separación es start_gap_px (12) o menos y golpea en los hit_ticks (9, 19, 30) de cada ciclo de cycle_ticks (43): 21 golpes. El receptor no baila. El aura del elemento nace donde está Isaac (aura_origin); aura_pending dice lo que falta decodificar. caster_teleport (Transport y Flight) marca el salto del lanzador: destello de salida al lanzar, destello de llegada a los arrival_effect_ticks (20) y cambio de posición a los move_ticks (30), sin receptor ni impacto. Sus probabilidades son condicionadas al éxito; el visor permite escoger una rama sin simular la tirada. own_graphic_confirmed se refiere al dispatch del informe original, no a la presencia de feedback compartido.

Quedan pendientes la composición visual de explosiones/dragones y el derribo en juego. La sincronización de fases, la colocación absoluta de la fase de Missile, los donantes de vida y el daño propio de Autocañón no se reconstruyen completamente. El seguimiento extraccion/investigacion/visuals/SCENE_RENDERING.md añade dragon_assembly (tabla de 14 índices, aparición 23+índice y escalas), explosion_assembly (núcleo, aro y partículas de carga) y lock_timing (8/16/24 tics). La trayectoria del dragón y las posiciones preliminares de Explosion siguen siendo ilustrativas. Cómo termina cada efecto está en extraccion/investigacion/visuals/SCENE_ENDINGS.md: rain_assembly (los 6 hechizos con MagicEffectRain) da 20 nubes, 10 gotas con su ciclo de alfa (drop_alpha) y 10 salpicaduras, y removed_after_hit_ticks (63) es cuando el dueño se borra y se lleva todo a la vez. En las demás familias de explosiones y objetos que caen no está decodificado cuándo se retira el efecto; la escena lo quita 120 tics después del impacto. Los 27 hechizos de terreno llevan terrain_scene:

• map y origin dicen en qué mapa del juego y en qué punto se pone la escena, para que se vea el terreno sobre el que actúa;
• zone dice cuándo nace la zona: al impactar (hit), en cada objeto que cae (object_hits) o al aparecer el área (release);
• radius_px y lasts_ticks (1200) dan su círculo y su duración;
• prior, en los que solo quitan, es el recubrimiento previo que la escena pinta para que se vea qué quitan.

terrain trae la regla de cada material, la capa que elige el juego, las tablas de teselas por vecinas (tiles), las hojas de cada capa con sus tics por cuadro y la grilla NHIT de cada mapa usado (detalle en extraccion/investigacion/terrain_morph/STATIC_REVIEW.md). sounds[].duration_ticks corta el conjuro al lanzar y el trazo al terminar cada runa; los clips *-sustain conservan muestras/instrumentos de la ROM con una retención de 3 s elegida para la vista. Continuar reanuda las notas sostenidas con su desplazamiento y duración restante. Ninguno de estos hallazgos está verificado en emulador.

Apuntar un hechizo

/data/aiming.json dice qué muestra la batalla entre el final del canto y el lanzamiento, según el targeting del hechizo (ver "Hechizos y runas"). Está leído del código (evidence: static), no medido en un emulador; confidence dice qué tan seguro es cada punto. Posiciones en px de la pantalla de abajo (256 × 192), tiempos en ticks de 1/60 s y ángulos en grados con 0 = derecha y 90 = abajo (la y crece hacia abajo).

• Modos (modes). Cada targeting tiene su icono (icon) y su forma de confirmar (confirm). arrow dice si usa la flecha; range_graphics_3d, si dibuja algo en el suelo (círculos o sombra). direction no dibuja nada en el suelo: solo la flecha y el icono.
• Flecha (arrow, solo direction: Fireball y los demás disparos). La imagen image (32 × 56) apunta hacia arriba. Su punto pivot_px (15, 36), el centro del aro, va sobre el punto de Isaac (anchor: caster_point, sus pies) y la imagen gira alrededor de ese punto. La punta queda tip_px (36) px delante de Isaac y el mango tail_px (15) px detrás, así que la flecha sale de debajo de él. Ángulo de dibujo = atan2(dy, dx) en grados + rotation_offset_deg (90), donde (dx, dy) va del punto de Isaac al lápiz, girando en el sentido de las agujas del reloj en pantalla: la flecha apunta siempre al lápiz. El giro es libre (turn_steps 4096 por vuelta), sin pasos de 4 u 8 direcciones. No se estira ni cambia de tamaño con la distancia (scale 1) y es opaca (alpha 1). Se dibuja debajo de Isaac (layer: under_caster). Colores: los de la imagen, iguales para todos los elementos.
• Cuándo (direction_flow). La flecha aparece en cuanto empieza el apuntado, apuntando hacia arriba (rest.end_offset_px (0, −10): −90°). Cuando el lápiz toca la pantalla (en cualquier parte), cada tick la flecha apunta al lápiz e Isaac se gira hacia él en 4 direcciones (derecha, abajo, izquierda, arriba, cortes a 45°). Al levantar el lápiz se lanza el hechizo desde Isaac hacia el último punto del lápiz, y la flecha y el icono desaparecen. No hay límite de distancia (range_limit: null): el disparo recorre su shot_range_px de /data/spells.json. Antes de tocar, pulsar el botón del canto (L, o R con la opción para zurdos) cancela: suena SE_CANCEL (efecto 4) y no se lanza nada; una vez tocado, ya no se cancela.
• Icono (icon). Mientras se apunta, el icono del modo (32 × 32, punto en su centro) va fijo en la pantalla en at_px: (20, 172), abajo a la izquierda, o (236, 172) con la opción para zurdos, encima del campo. Si la flecha apunta hacia esa esquina (entre los ángulos de move_when_arrow_deg: 90–180 para diestros, 0–90 para zurdos) salta a moved_at_px (236, 20 o 20, 20) para no quedar bajo la mano.
• Círculo (circle_flow, targeting: circle). Fuera del alcance (cast_range_px desde Isaac) el campo se sombrea con shade_outside_range (#525252, alfa 20/31). Un toque fuera del alcance no cuenta; uno dentro fija el centro. Arrastrando se elige el radio, desde radius.min_px (5) hasta el radius_px del hechizo; al soltar se lanza con ese centro y ese radio. El área se colorea según targets (area_colour_by_targets: rojo enemigos, azul aliados, amarillo todos; area_colour_other para los hechizos que lista) y con area_colour_at_max_radius al llegar al radio máximo. Forma (area): un disco de 24 lados centrado en el centro elegido, del radio arrastrado, alfa 24/31. Mientras el radio no llega al máximo lleva cuatro triangulitos (handles) a 4 px del borde, de 5 px de largo y 8 de base, que apuntan hacia fuera y giran para que uno apunte al lápiz; al llegar al máximo desaparecen. La sombra de fuera del alcance solo se ve antes de tocar.
• Instantáneo (instant_flow). Cualquier toque lanza el hechizo; el botón del canto cancela.
• Línea (line_flow, muros como Fire Wall). El primer toque tiene que caer estrictamente dentro del alcance; fija el inicio. Si cae fuera no pasa nada. Desde ahí el extremo sigue al lápiz, con un largo máximo max_length_px del hechizo. Si el lápiz sale del alcance, el extremo se queda donde la recta del inicio al lápiz corta el borde del alcance: la línea entera queda dentro. Isaac se gira hacia el lápiz solo antes de fijar el inicio. Al soltar se lanza del inicio al extremo (la misma llamada que la flecha). Se dibuja (graphics, color #e6b552, alfa 28/31) un disco de 8 px de radio en cada punta y una banda de 8 px de ancho entre ellas, que sobresale 4 px por cada lado. La sombra de fuera del alcance se ve siempre.
• Punto (point_flow) y círculo fijo (fixed_circle_flow) son el mismo código. El primer toque tiene que caer estrictamente dentro del alcance. Después el punto sigue al lápiz y, si el lápiz sale del alcance, se queda en el borde, en la dirección del lápiz. Isaac se gira hacia el lápiz. Al soltar se lanza en el punto. point dibuja la retícula (reticle, 16 × 16 px a escala 1,5: 24 × 24 en pantalla, centrada en el punto, encima del campo) y ningún área. fixed_circle dibuja en el punto un disco de 24 lados del radio del hechizo (radius_px, trigger_radius_px o ring_radius_px según la clase), siempre en #ffa5a5 alfa 24/31 y sin triangulitos, porque el código lo dibuja con el radio máximo. Solo mostraría la retícula con radio 0, y ningún hechizo lo tiene. La llamada de lanzamiento recibe además un radio fijo de 20 px (cast_radius_arg_px); no se sabe para qué lo usa. La sombra de fuera del alcance se ve siempre.
• Unidad (unit_flow). Cualquier toque empieza. Un cursor sigue al lápiz; si el lápiz sale del alcance, el cursor se queda en el borde. Isaac se gira hacia el lápiz. Cada tick se elige la unidad más cercana al cursor entre las que permite targets y cuya caja de toque contiene el cursor. Caja: en x, la x de la unidad ± (touch_box_by_unit[slug][0] + 4 px); en y, desde la y de la unidad − ([1] + 4 px) hasta la y + (radius_px de la unidad + 4 px). Se dibuja un marcador de tres líneas (marker.lines_px, px desde su punto) en rojo #ff5252 sobre la unidad elegida, también con hechizos para aliados, o en amarillo #ffff52 sobre el cursor si no hay ninguna. Al soltar se lanza sobre esa unidad. Si no había unidad, vuelve a esperar un toque y el botón del canto vuelve a cancelar. La sombra de fuera del alcance se ve siempre.
• cross (una cruz) se carga para todos los modos pero ninguno la muestra. numbers son cifras del mismo archivo que no se usan al apuntar: son las de los números de daño (ver "Números de daño").

Estados alterados

/data/statuses.json tiene los 141 registros de estado; el status.id de un hechizo apunta a uno. duration_ticks es cuánto dura (0: actúa una vez) y caused_by, los hechizos que lo causan. La intensidad de los que hacen daño o curan es la status.power del hechizo. key dice qué hace:

Cada cambio de changes tiene stat (attack, defense, speed, magic, magic_defense, interval = tiempo entre ataques, accuracy, evasion) y mode: percent → stat × (1 + amount); flat → stat + amount; gap → stat + (100 − stat) × amount.

• Los estados no se acumulan: aplicar uno otra vez reinicia su tiempo. Los cambios de estadísticas, las auras y las maldiciones sí, y se multiplican.
• Cada fotograma las estadísticas se recalculan desde las de la unidad aplicando sus estados, del más nuevo al más viejo, y se limitan: ninguna baja de 0; ataque, defensa, velocidad, magia e interval llegan como mucho al doble de las de la unidad (interval al menos 1); la defensa mágica, a 99; la precisión y la evasión, a 150 más que las de la unidad.
• Isaac y los jefes son inmunes a berserk, charm, terror y forget.

Combate

La batalla corre a 60 tics por segundo. /data/combat.json tiene las constantes del código; las de cada unidad están en /data/units/<slug>.json.

Ataque normal. gap = distancia entre centros − radius_px de las dos unidades.

• Empieza a golpear con gap < attack_reach_px y sigue mientras gap < attack_reach_px + attack.reach_pad_px. Con attack_reach_px 0 no ataca nunca; al perseguir se detiene a attack.stop_gap_px.
• Ritmo: espera attack_interval_ticks, reproduce su animación attack; el golpe o el disparo sale a los attack_strike_ticks de empezarla; al terminar la animación vuelve a esperar.
• Acierto cuerpo a cuerpo: azar(0..100) + precisión − evasión ≥ 100. A distancia: azar(0..99) < (precisión − evasión) mod 256 (una diferencia negativa acierta siempre).
• Daño: d = floor(ataque / 2) − floor(defensa / 4); si d ≤ 0, nada. Con attack_element: ×½ contra el mismo elemento, ×1,5 contra el opuesto (opposite). Los disparos hacen ×1,5 a las unidades que vuelan. Al final floor(d × (128 + r) / 128), con r entero al azar entre −10 y 10.

Disparos (projectile_type de la unidad, projectiles de /data/combat.json): salen de shot_start_px según hacia dónde mira, en línea recta hacia donde estaba el centro del objetivo, a speed_px_per_tick, sin perseguirlo. Recorren como mucho attack_reach_px + reach_pad_px. Impactan a la unidad enemiga más cercana que esté a shot_hit_radius_px + su radio; no atraviesan. Los obstáculos altos los detienen; el agua y los pozos no. on_hit: stick se queda stick_ticks sobre el objetivo, vanish desaparece. Si fallan, rebotan y se desvanecen en shot_fade_ticks.

Visión. Cada search_every_ticks la unidad busca enemigos a menos de max(sight_px, search_px) y persigue mientras gap < sight_px. Los guiones de misión cambian sight_px a menudo.

Daño de los hechizos. Con la potencia al lanzarlo P (ver «Hechizos y runas»), sobre cada objetivo:

1. Elemento: sin elemento, P; mismo elemento que el objetivo, −floor(P / 8); opuesto, floor(3P / 2).
2. Si es mayor que 0, × (100 − defensa mágica) / 100 (defensa mágica ≤ 99); si es 0 o menos, se divide entre 2 (el mismo elemento cura alrededor de P/16).
3. × (128 + r) / 128, con r al azar entre −10 y 10.
4. Si el objetivo tiene más estados weakness que halving de ese elemento, ×2; si tiene más halving, ×½. Los hechizos con heal suman P sin elemento, defensa ni azar.

Elemento contra elemento (elements de /data/combat.json). Cuenta el element de la unidad (null: sin elemento) contra el del golpe. elements.spell_table es el paso 1 de arriba, por elemento del hechizo (filas) y del objetivo (columnas): -0.125 es el mismo elemento, que cura; 1.5, el opuesto; 1, el resto, y siempre que uno de los dos no tiene elemento. Un hechizo de fuego cura a una criatura de fuego en lugar de dañarla, sea cual sea su defensa mágica. Ninguna unidad es inmune al daño de un elemento.

• Ataque normal (elements.attack): ×½ contra el mismo elemento, ×1,5 contra el opuesto.
• Probabilidad del estado del hechizo (elements.status_chance): ×½ si el objetivo tiene el elemento del hechizo, ×1,5 si tiene el opuesto. Se compara el elemento del hechizo, no el del estado. Ningún estado tiene una excepción por elemento: una criatura de fuego se puede quemar y una de agua se puede congelar, con la mitad de probabilidad si el hechizo es de su elemento.
• Daño que hacen los estados (elements.status_damage): la quemadura es de fuego y el veneno de oscuridad, y pasan por los pasos 1 a 4. A una criatura de fuego, cada tic de quemadura la cura en vez de dañarla (con potencia 10, 1 o 2 de vida); a una de agua le hace ×1,5. El congelamiento lleva agua, pero no hace daño.

Jefes. Solo la unidad jefe de cada batalla lanza hechizos (casts_spells en su ficha), cuando su guion se lo ordena; no hay comprobación de alcance. Tiene su propio MP (su estadística mp), paga cada runa con rango 0 y su potencia es power + magia, sin calidad ni rango.

Niveles de elemento de Isaac. Empiezan en growth.start. Solo cambian en la pantalla de resultados de una batalla. Con old el nivel antes de la batalla, c los hechizos de ese elemento lanzados en ella (uno por hechizo, el elemento de su última runa; los cantos cancelados no cuentan) y fav el elemento lanzado estrictamente más veces (ninguno si hay empate):

• old ≤ low_band_max: +low_band_many_gain si c ≥ many_casts, +1 si 1 ≤ c < many_casts; +1 más si es fav.
• old ≤ mid_band_max: +1 si c ≥ many_casts; +1 más si es fav.
• Si no: +1 solo si es fav, y entonces el elemento opuesto pierde 1 si su nivel era decay_min o más.
• Después, cada nivel se limita a level_min–level_max. El nivel solo cambia el rango (floor((nivel − 1) / 10)), y el rango solo cambia el MP de las runas, la potencia (×(rango + 4) / 4) y la probabilidad de los estados (×(rango + 4) / 4).

Barra de vida

hp_bar de /data/combat.json es la barra de vida que el juego dibuja sobre cada unidad en el campo, todo el tiempo. Son rectángulos de color sólido, sin imagen (drawn_by_site: true). Las medidas están en px desde el punto de la unidad (x, y de /data/maps.json) subido la altura de su cabeza, head_px de /data/units/<slug>.json: un rectángulo con left_px y top_px va de (x + left_px, y − head_px + top_px) a width_px × height_px.

1. frame: el marco, de color frame.color, debajo de todo. Lo que la barra no cubre se ve de ese color.
2. bar: la vida, de floor(width_px × vida / vida máxima) px de ancho, con la vida máxima efectiva (después de change_max_hp). Su color, color_by_side: player para el bando de Isaac, enemy para los enemigos, ally para los aliados y los personajes sin bando.
3. change: durante change.ticks tics después de cambiar la vida, otra barra de la misma posición y alto va entre el marco y bar. Solo cuenta el último cambio.
   • Tras un daño, bar muestra la vida nueva y la de abajo la de antes, en damage_color.enemy en los enemigos y damage_color.other en el resto.
   • Tras una curación, bar muestra la vida de antes y la de abajo la nueva, en heal_color.

La barra no sube con las unidades que se elevan del suelo. Una unidad vencida la conserva durante su animación die y la espera de 30 tics, y la pierde cuando empieza la nube con la que desaparece (hidden_from: vanish).

Marca de enemigo

/data/enemy-marker.json es la letra pequeña que el juego dibuja justo a la izquierda de la barra de vida de cada enemigo. Marca el bando: solo la llevan los enemigos; Isaac, sus escuadrones y los aliados no llevan ninguna (carried_by).

• Imagen. letters: «E» con el juego en inglés, francés o español y «F» en alemán (languages; el juego toma el idioma de la consola y cualquier otro cuenta como inglés). Cada una mide 8 × 8 px (size_px), rosa y blanca, sin animación.
• Posición. Desde el punto de la unidad (x, y de /data/maps.json) subido la altura de su cabeza (head_px): el pivot_px de la imagen va en (x + offset_px[0], y − head_px + offset_px[1]), es decir (x − 14, y − head_px − 6). Queda gap_to_hp_bar_frame_px (5 px) a la izquierda del marco de la barra de vida. Escala 1, opaca, delante de su unidad. Ejemplo (example): en un Hongo bruma (head_px 14) la imagen ocupa de (x − 18, y − 24) a (x − 11, y − 17).
• Cuándo se ve. Mientras el enemigo esté en el campo y en pantalla, todo el tiempo; no depende de la selección ni del daño. Cada unidad tiene un contador de aparición de 0 a fade_max (127): entra al campo en 63 y sube 1 por tic hasta 127; mientras parpadea al aparecer, la letra se ve fija (blinks: false). Un enemigo con el estado hidden baja 1 por tic y la letra se va cuando llega a 0. Al morir, la letra sigue durante la nube de desaparición, aunque la barra ya no se dibuje, y se va cuando la unidad se quita.

Cristales de maná

Los cristales de maná (pilares de MP) están en muchas batallas. Cada batalla de /data/maps.json trae crystals: la posición x, y en px del mapa y owner, quién lo tiene al empezar (player, enemy o neutral). Las reglas están en mana_crystals de /data/combat.json, en px y tics de 1/60 s:

• Es un círculo sólido de radius_px que detiene a las unidades que caminan, a las que vuelan y a los disparos. No tiene vida: solo cambia de dueño.
• Captura. Cada tic, cada unidad que puede capturar (can_capture_crystals en /data/units/<slug>.json), viva y a menos de capture_radius_px, suma gauge_per_unit_per_tick al medidor. Cuando nadie suma, el medidor baja gauge_decay_per_tick. Al pasar de capture_gauge.neutral (cristal de nadie) o de capture_gauge.owned (cristal con dueño), pasa al bando que lo toma, y el medidor vuelve a 0.
• Bloqueo. Nadie lo toma mientras una unidad de su dueño esté a menos de presence_radius_px. Un cristal de nadie tampoco avanza si hay unidades de dos bandos a esa distancia.
• Bandos. sides_that_capture: en la historia solo Isaac y sus escuadrones toman cristales; los enemigos nunca los toman ni los defienden.
• Curación. Las unidades de su dueño a menos de heal.radius_px recuperan heal.hp de vida cada heal.every_ticks mientras estén heridas.
• MP. Cada mp_regen.every_ticks, el MP de Isaac sube mp_regen.base_mp, más mp_regen.mp_per_crystal por cada cristal suyo, más 1 por cada aumento anterior seguido sin cantar, hasta mp_regen.streak_max. Sin cristales también recupera: la base y la racha. Después de un canto, el primer aumento llega a los mp_regen.chant_wait_ticks; con cristales, a los chant_wait_ticks − chant_wait_cut_ticks_per_crystal × cristales, con un mínimo de chant_wait_min_ticks.
• Imagen. pictures tiene una imagen por dueño, de picture_size. Su esquina superior izquierda va en el punto del cristal más picture_offset.
• Barra de captura. capture_bar describe la barra que el juego dibuja con rectángulos, sin imagen. drawn_by_site es true porque el sitio la redibuja a partir de estas reglas:
  • Mide height_px de alto y va a above_px sobre el punto del cristal.
  • El fondo, de color colors.background, empieza en background.<neutral|owned>.left_px y mide width_px.
  • Encima, desde el mismo borde y en colors.remaining, va lo que falta: (capture_gauge − medidor) / remaining_divisor px, con el medidor del último empuje.
  • Cada empuje la muestra durante fade_ticks ticks, con opacidad ticks restantes / 2 sobre alpha_max.
• Misiones. El objetivo «¡Purifica los cristales!» se gana cuando todos son del jugador (all_crystals en conditions).

Cámara de batalla

/data/camera.json tiene las constantes del código, en px del mapa y px por frame (60 por segundo). La vista mide view_px (256 × 192): es la pantalla de abajo, la táctil, donde el juego pone el motor gráfico principal (el 3D y los fondos del mapa). La de arriba la ocupa la sección «Pantalla de arriba» de abajo.

• Posición. Es la esquina superior izquierda de la vista. Va de 0 a view_x_max_px y view_y_max_px de cada mapa en maps (el tamaño del mapa menos la vista); cada movimiento se recorta a esos límites. Son los límites del mundo (world_bounds.always): fuera del mapa no hay nada, así que la cámara se detiene en cada eje al llegar al borde y sigue en el otro eje si todavía puede. El juego tiene una bandera para quitarlos, pero solo la escribe al iniciar la cámara, con 0; nada la activa. Las unidades y efectos se dibujan en posición en el mapa − posición de la cámara, en px enteros. Una unidad a más de 40 px fuera de la vista (unit_draw_margin_px) no se dibuja.
• No sigue a nadie. La cámara no se mueve sola cuando Isaac camina, ni sigue a los hechizos, a los objetivos ni a las criaturas capturadas. Solo la mueven los cuatro casos siguientes, sin suavizado ni zona muerta: velocidad constante y llegada exacta.
• Al empezar la batalla se centra en Isaac: lo deja en battle_start_isaac_at_px (128, 96) de la pantalla, recortado a los límites.
• Cruceta. Mientras se mantiene, la vista avanza dpad.px_per_frame (7) en esa dirección, o dpad.diagonal_px_per_frame_per_axis (4,9) por eje en diagonal. Con la opción de zurdo, A, Y, B y X hacen de derecha, izquierda, abajo y arriba. No hay retorno automático: la vista se queda donde el jugador la deja. No se mueve mientras se prepara o se canta un hechizo, ni cuando la misión desactiva la cruceta.
• Canto. Al mantener L (R con la opción de zurdo), si Isaac está fuera del rectángulo chant_recentre.isaac_rect_px de la pantalla (x 20–236, y 20–172), el canto espera y la vista va hacia él a chant_recentre.px_per_frame (10) en línea recta, hasta dejarlo en target_px (128, 96). Cuando falta menos de jump_below_px (10), salta al destino. Termina antes si Isaac entra en el rectángulo o si un borde del mapa detiene la vista. Durante el canto sigue corrigiendo igual.
• Misiones. El guion lee la posición de la vista y la mueve en línea recta a (x, y) a velocidad × script_pan.px_per_frame_per_speed_unit (velocidad / 4) px por frame; las misiones usan casi siempre 24, es decir, 6 px por frame. Al llegar devuelve que terminó. No vuelve sola a Isaac. Si el destino queda fuera de los límites, la vista se detiene en el borde.
• Temblor. Big Drop mueve la vista shake.big_drop: ±2 px en horizontal, cambiando de lado cada 2 frames, durante 30 frames, y luego la devuelve a 0. El efecto de terremoto (earthquake_unused, tres fases) existe en el código, pero ningún hechizo lo usa. El temblor no cambia la posición de la cámara, solo lo que se dibuja.
• Pantalla de arriba (top_screen). Depende del estado del canto. En los estados 0, 1 y 2 (sin canto) muestra el minimapa, que coloca cuatro marcas según la posición de la vista. Mientras se dibuja (estados 7 y 8) muestra la lista de runas: una cuadrícula de rune_grid 6 columnas, una por elemento, por 3 filas, una por nivel de runa, junto a una barra del MP de Isaac. Cuando el canto da un hechizo (estado 9) muestra ese hechizo: su número, su nombre y su descripción. Vuelve al minimapa en cuanto el estado vuelve a 0, 1 o 2. Que las runas no aprendidas salgan como «?» se vio en el juego, pero no se siguió en el código.
• Fondos. Cada capa del mapa recibe la posición de la vista. BACK (el mapa) y ANIM la usan tal cual. NORM la multiplica por speed_factor (PARM / 256): con modo 3 o 4 es un fondo detrás del mapa (cielo, mar, lava) que avanza a esa fracción; con modo 1 va delante. En un mapa con ANIM, la capa NORM no se muestra (shown: false). No se confirmó leyendo el código si el fondo se repite al llegar a su borde.

Números de daño

/data/damage-numbers.json dice cómo se dibuja el número que aparece sobre una unidad cuando su vida cambia. Está leído del código (evidence: static); el color, la posición, la duración y el error de la centena se comprobaron además en el emulador con Fireball en la primera batalla. confidence dice qué tan seguro es cada punto. Posiciones en px de pantalla (la y crece hacia abajo) y tiempos en ticks de 1/60 s.

• Cuándo (shown_when: hp_changes). Cada vez que la vida de una unidad cambia, por un hechizo, un ataque normal, un disparo, un estado, el terreno o la curación de un cristal (sources), en cualquier bando (Isaac, sus escuadrones y los enemigos por igual). Se muestra el valor absoluto del cambio (value.shown), sin signo, hasta value.max (9999). Es el daño calculado, no lo que le quedaba de vida: un golpe de 347 a una unidad con 20 de vida muestra 347. Un cambio de 0 no muestra nada, y un fallo no cambia la vida, así que tampoco.
• Un error del juego con 1000 o más (value.drops_zero_hundreds). Las cifras se eligen así (value.digits_drawn): el millar si el valor pasa de 999; la centena solo si el resto (valor mod 1000) pasa de 99; la decena si el resto (mod 100) pasa de 9 o ya se dibujó una cifra; y la unidad. La centena no mira si ya hubo millar, así que un 0 en la centena se pierde: 1050 se ve «150», 1005 «105» y 2000 «200». Para dibujarlo como el DS hay que copiar ese error.
• Cifras (font). Solo los dígitos 0–9, en celdas de 8 × 8 px con su punto en (4, 4), el centro. Son las mismas en los cuatro idiomas. Las imágenes de kinds.<tipo>.image son tiras de 80 × 8 con el dígito d en x = 8 × d.
• Color (kinds). Depende solo del signo, no del bando ni del elemento: damage (vida perdida) es rosa/rojo #de1852 con borde blanco; healing (vida ganada) es verde #18bd73 con borde blanco. Daño a Isaac o a un aliado se ve igual que daño a un enemigo.
• Dónde (place). El centro del número va en el punto de la unidad (sus pies) más radius_px de esa unidad hacia abajo (/data/units/<slug>.json). Se calcula en cada tick, así que sigue a la unidad si se mueve. No se dibuja mientras la unidad no se dibuja (más de 40 px fuera de la vista).
• Cómo se reparten las cifras (layout). Con n cifras, el centro de la cifra k (desde 0, de izquierda a derecha) va en x = −(3n − 3) + 6k respecto al centro del número, y en y = 0. Están a 6 px (advance_px) aunque cada celda mida 8, así que los bordes blancos se pisan: cada cifra se dibuja encima de la anterior.
• Movimiento (timing). Ninguno: no sube, no rebota, no cambia de tamaño ni se desvanece. Aparece entero, se queda lasts_ticks (40, dos tercios de segundo) y desaparece de golpe. Si el golpe mata a la unidad (timing.killing_blow), la cuenta se detiene mientras muere: el número se queda hasta que la unidad desaparece en su nube (unos 190 ticks con el Misty Mush de la primera batalla).
• Varios a la vez (stacking). Cada unidad tiene un solo número. Si su vida vuelve a cambiar antes de que se borre, el nuevo valor lo reemplaza y los 40 ticks vuelven a empezar; no se suman ni se apilan. Los números de unidades distintas son independientes.
• Capa (layer). Se ordena con el resto del campo como si estuviera 20 px más abajo que la unidad: queda delante de ella y de lo que esté a menos de 20 px por debajo.
• Sonido. El daño (no la curación) suena con damage_sound (SE_UNIT_DAMAGE, efecto 50).
• Ejemplo (example). Fireball le quita 347 a un Misty Mush (radius_px 6): tres cifras rosas con sus centros en (−6, 6), (0, 6) y (6, 6) respecto a los pies del hongo, durante 40 ticks. example.image es ese número ya armado (20 × 8), con su centro en point_px (10, 4).

Pantalla del canto

/data/chant-screen.json tiene los gráficos de la pantalla del canto, leídos del código (evidence: static), no medidos en un emulador. Las posiciones son px de la pantalla (256 × 192), los tiempos ticks de 1/60 s y los alfas van de 0 (transparente) a 1 (opaco; el DS usa 0 a 31).

• Cuándo. El círculo y la capa oscura aparecen al empezar a dibujar y desaparecen de golpe al terminar el dibujo, junto con los trazos. No siguen a la cámara: quedan fijos en la pantalla de abajo.
• Capa oscura (dim_layer). Un rectángulo de toda la pantalla, color colour (#525252), mezclado con alfa normal sobre el campo. Su alfa empieza en alpha_from (10/31) y sube 1/31 cada step_every_ticks (2) ticks hasta alpha_to (20/31): llega en 20 ticks. Es lo que tiñe el campo; el círculo no lo tiñe.
• Círculo (circle). La imagen image (256 × 192, paleta propia naranja) va con su punto pivot_px (128, 79) en centre_px (128, 96); el dibujo ocupa art_box_px de la imagen, así que su centro cae en (128, 103) de la pantalla. Se dibuja opaco (alfa 1) encima de la capa oscura. Al aparecer, durante appear.ticks (30) crece desde casi 0 a scale_per_tick (0,0332) por tick y gira turns_per_tick (1/30 de vuelta por tick): una vuelta completa. En el tick 31 queda en escala 1 y ángulo 0, y se queda quieto. El sentido del giro no se confirmó. fade_unused es una salida con giro y fundido que está en el código pero el juego no usa.
• Trazo (stroke). Cada trazo es una cinta de width_px (8) de ancho alrededor de los puntos del lápiz (uno por tick, hasta max_points), con remates redondos que pasan cap_px (4) del primer y del último punto. Se pinta con la textura texture (32 × 32: borde rim amarillo, centro core blanco) reducida al ancho de la cinta: la mitad izquierda de la textura es el remate del inicio, la derecha el del final, y las columnas del centro se estiran a lo largo. El color de la textura se multiplica por el del trazo (canal a canal, en 0..31: (textura + 1) × (trazo + 1) / 32 − 1) y se mezcla con alfa.
• Color del trazo. Mientras se dibuja es blanco y opaco: se ve la textura tal cual. Cuando un trazo se reconoce como runa, en rune.ticks (11) ticks cada canal baja step31 por tick hasta el color de su elemento (by_element, en 0..31) y el alfa baja de 31 a 20 (alpha_to); se queda así. Un trazo que no es runa (not_a_rune) sigue blanco y baja 1/31 de alfa por tick hasta 1/31 en 30 ticks.
• Lista de runas (rune_list, pantalla de arriba, mientras se dibuja). Encima del fondo background, que ya trae un «?» en cada celda y el riel de la barra de MP, van los iconos de los seis elementos (elements) y una imagen de 32 × 32 por runa aprendida en su celda (cells: columna = elemento, fila = nivel). Una runa no aprendida no dibuja nada y se ve el «?». Una aprendida que Isaac no puede pagar con su MP actual muestra no_mp (una X) en lugar de la runa. preview es la lista con las 18.
• Números. Cada runa que se puede pagar lleva su costo en MP, cost.digits (2) cifras en cost.offset_px (18, 18) desde la esquina de su celda; el costo es el de mp_per_rune de /data/runes.json para la próxima runa del canto. El MP actual de Isaac va con 3 cifras en mp.at_px (217, 45). La fuente de esas cifras no está en estos datos.
• Barras de MP (bars). Dos imágenes de 64 × 64 (gris y amarilla) con su punto pivot_px (29, 64) en at_px (224, 155): crecen hacia arriba y, llenas, miden full_height_px (88) de alto. Las dos siguen el MP de Isaac; cuál queda delante no se confirmó.
• Destello (sparkle). Una tira de cuadros de 32 × 32 con su duración en ticks, que se pone sobre la celda de la runa que se acaba de dibujar.

Fin de la batalla

/data/battle-end.json dice qué muestra el DS desde que una batalla se decide hasta que termina la pantalla de resultados. Está leído del código (evidence: static), no medido en un emulador; confidence dice qué tan seguro es cada punto. Px de pantalla (256 × 192 cada una) y ticks de 1/60 s.

• Resultados (outcomes). Un disparador de la misión termina la batalla con una de cuatro acciones (action_id, el número de acción de los scripts de misión). Cada una fija la palabra que sale en el campo (word), la canción (song) y si sigue la pantalla de resultados (results_screen). GameClearStart (3) es una victoria: WIN y canción 11. GameOverStart (2) es una derrota: LOSE, o TIME OVER (word_when_time_limit) si el disparador fue el límite de tiempo. GameLostClearStart (5) muestra LOSE pero cuenta como victoria. GameEvenStart (6) es un empate: DRAW. Todas menos la victoria ponen la canción 12.
• La batalla se detiene (battle). Desde ese tick ninguna unidad se mueve, piensa ni ataca y no corre ningún disparador; las unidades se siguen dibujando. No hay pose de victoria. Un canto en curso se cancela y su sonido (stops_sound, SE_MAGIC_EISHO) se corta. La batalla espera settle_ticks (30) y a que terminen los efectos en curso.
• Cartel (banner). Luego empieza la canción y corre el cartel, en la pantalla de abajo, fijo a la pantalla en at_px (128, 96); cada imagen de words (una por idioma, según el de la consola: francés, alemán, español; cualquier otro, inglés) va con su pivot_px sobre ese punto. En español las palabras son VICTORIA, DERROTA, EMPATE, FIN DEL TIEMPO e INICIO.
  1. Durante ticks.circle_only (31) solo se ven el círculo mágico y la capa oscura del canto, entrando como cuando Isaac canta (/data/chant-screen.json, circle y dim_layer). La palabra todavía no se dibuja.
  2. La palabra aparece, opaca, durante ticks.shown (31) y se queda ticks.held (61) más.
  3. Después la palabra se va de golpe (el código quiere desvanecerla, pero su alfa empieza en 0; visto en el emulador) y durante ticks.circle_leaving (31) el círculo se va (circle.exit): gira 24° por tick y su alfa baja 1/31 por tick.
  4. En ticks.total (154) el círculo y la capa oscura desaparecen a la vez.
• Después. Con la canción 12 la batalla además espera a que esa canción termine (waits_while_song_plays; suena una vez, 4,287 s), así que una derrota dura más que una victoria. Al final las dos pantallas funden a negro (fade_out, 30 ticks). Tras una victoria viene la pantalla de resultados; tras una derrota o un empate, Continuar (sección «Reglas del juego»).
• INICIO (banner.start). Antes de jugar la batalla muestra START igual, salvo que la misión llame antes al nativo 46. La primera batalla (qc01_m001) lo llama, así que empieza sin cartel; su versión de nueva partida+ sí lo muestra.

Pantalla de resultados

results. Solo sigue a una victoria. La canción results.song (10, SEQ_QUESTCL) empieza con ella y suena hasta el final. Tiene hasta cuatro fases en el orden de results.phases; una fase sin nada que mostrar se salta. Cada fase entra desde negro y sale a negro (30 ticks). Tras la última viene el título del capítulo, si hay uno pendiente, o el mapa del mundo.

Experiencia (results.exp), siempre. previews trae las dos pantallas armadas con estos campos, en inglés y en español, sin el texto. La fuente de los menús del juego no está decodificada: los textos van con caracteres de ancho fijo de 7 px desde su punto, en una fuente a elección.

• Pantalla de arriba: top.background (ya trae el retrato de Isaac, el recuadro LV y tres filas oscuras). Isaac: la etiqueta LV en isaac.lv_label_at_px (la _fr_es en francés y español), su nivel como %2d en level_text_at_px, la barra de EXP en exp_bar_at_px (bar_frame_64, luego bar_back_64, luego bar_fill estirada a exp_bar_fill_px (62) × EXP / EXP para el siguiente nivel). Cada escuadrón del equipo, en el orden de la lista, 3 como mucho: el icono de su unidad en squads.icon_at_px, la placa, su nombre, su nivel y su barra a los desplazamientos de squads desde el icono (barra de 46 px, bar_frame_48 y bar_back_48). Los niveles de elemento no salen en la pantalla de arriba.
• Pantalla de abajo, página 1 (bottom.pages 1): las cuatro bars en su at_px y los texts: clear_time el tiempo de batalla en segundos (como mucho su límite) como hh:mm:ss; defeated los derribados; survival los monstruos de escuadrón vivos × 10000 / los desplegados, como %3d.%02d%%, o ---.--% sin escuadrones; exp_pool la EXP que falta repartir, que baja hasta 0.
• Pantalla de abajo, página 2 (bottom.pages 2, 192 px más abajo): el radar de elementos. Los seis iconos en radar.icons y dos hexágonos traslúcidos centrados en radar.centre_px, un vértice por elemento (arriba luz, arriba a la derecha fuego, abajo a la derecha tierra, abajo oscuridad, abajo a la izquierda agua, arriba a la izquierda viento). Rojo: radio floor((nivel + 10) × 68 / 50); verde: floor(rango × 10 × 68 / 50), rango floor((nivel − 1) / 10) + 1. El verde va delante del rojo (visto en el emulador); su alfa no está decodificado.
• Cronología (waits_ticks 30, 60, 30, 60):
  1. Espera 30 ticks.
  2. Conteo, cada tick: paso = max(1, floor(bolsa / 80)), bolsa − paso, e Isaac y cada escuadrón reciben paso. El sonido count_step (18, SE_KASAN) suena cada tick; cada nivel ganado suena level_up (19, SE_LEVELUP) y muestra level_up («UP!», «¡SUBE!» en español; sus frames lo mueven dy_px) en level_up_at_px de Isaac o sobre el icono del escuadrón. Barras, niveles y exp_pool cambian cada tick. En 0 aparece el botón Siguiente y la pantalla espera.
  3. Espera 60 ticks y la página 2 sube a la vista en 64 ticks (3 px por tick).
  4. Espera 30 ticks y los niveles de elemento pasan de los viejos a los nuevos (regla de crecimiento en «Reglas del juego») en 30 ticks, redibujando los hexágonos cada tick; element_step (20, SE_ZOKUSEI) suena en los ticks 0, 10 y 20. Aparece Siguiente y la pantalla espera.
  5. Espera 60 ticks y funde a negro.
• Controles. El botón Siguiente (next_button, por idioma) está en (232, 168), o en (24, 168) con la opción para zurdos; actúa al levantar el lápiz a menos de 20 px de ese punto. Pulsar A, B, X, Y o la cruceta también cuenta como Siguiente. Durante el conteo, cualquier toque o uno de esos botones da el resto de golpe (cada miembro recibe ceil(bolsa / miembros), un defecto del juego) y se salta ese Siguiente. Un toque durante el desplazamiento salta a la página 2.

Objetos y monstruos (results.getting): una pantalla por objeto encontrado y luego una por monstruo capturado, en el orden en que la batalla los consiguió. Pantalla de abajo: el fondo (item o monster), el título (texto 70 «¡Encontraste un objeto!» o 75 «¡Has capturado un monstruo!», centrado en x 128, y 24), la fila del hallazgo en found_row_at_px (su fondo button_images 11 para objetos, 10 para monstruos; icono, nombre 16 px a la derecha, LV y nivel) y los dos botones de buttons.options (104 × 48, textos 71/72 o 76/77). «Añadir» lo agrega a la lista; con la lista llena el título pasa a 73/78 y Siguiente abre la lista (item_list/monster_list, 6 filas cada 18 px, list_images, flechas de página 30/31) para elegir cuál reemplazar; no se pueden elegir objetos equipados ni monstruos en un escuadrón. «Tirar»/«Soltar» pregunta con buttons.confirm (SÍ 8, NO 9). Solo táctil; un botón actúa al levantar el lápiz dentro de él. La pantalla de arriba muestra el nombre y la descripción del objeto (item_top, item_top_window).

Hechizos nuevos (results.magic): una pantalla por hechizo nuevo, primero los aprendidos y luego los solo vistos (sus runas salen como «?»). Abajo: background y una fila en row_at_px (32, 76): barra del color del elemento (images 9–14), número %03d:, nombre 32 px a la derecha y runas en 132, 152 y 172 px (images 15–32, «?» 34). Arriba se ve el hechizo como en la pantalla de arriba de la batalla. Siguiente o A/B/X/Y/cruceta avanza.

/data/battle-end.md trae los mismos datos en tablas.

Pantalla de título

/data/title-screen.json es el menú que sigue a TOUCH TO START: el logo arriba y cinco botones abajo. Está leído del código y comprobado en un emulador (evidence: static_and_emulator); confidence dice qué tan seguro es cada punto. Px de pantalla (256 × 192 cada una, desde la esquina superior izquierda) y ticks de 1/60 s.

• Fondos. top.background ya trae el logo y «©TAITO CORP. 2005, 2006»; bottom.background, el cielo, Isaac en la colina, el bastón y los pájaros. Los dos van en (0, 0) y no se mueve nada: los pájaros están pintados.
• Botones (buttons, en orden: New Game, Load Game, Multiplayer, Wi-Fi Connection, Hand Settings). Cada uno es el panel panel (128 × 24) con su texto (label, en, es, fr, de) centrado a label.offset_px (64, 4) de su esquina. images trae el botón ya armado en cada idioma, capturado del emulador: la fuente de los menús no está decodificada. El juego elige el idioma por el de la consola (francés, alemán, español; cualquier otro, inglés).
• Entrada (entry). Al aparecer el menú, las dos pantallas se aclaran desde negro en 30 ticks (fade_in) y, a la vez, cada botón va en línea recta de from_px a to_px en 30 ticks: New Game y Multiplayer desde la izquierda, Load Game y Wi-Fi desde la derecha, Hand Settings desde abajo. El paso por tick es step_px, truncado como hace el juego (entry.position), por eso New Game termina en x 29 y Multiplayer en x 40, 1 px antes que table_to_px. Hasta que todos se detienen, los toques no cuentan.
• Toque (press). Solo pantalla táctil: la cruceta y los botones no hacen nada aquí. Un toque que empieza dentro de un botón (hit_box, sin contar el borde) lo marca; mientras el lápiz sigue dentro, el botón se dibuja 2 px a la derecha y 2 px abajo y vuelve 1 px por tick al soltarlo. Levantar el lápiz dentro lo elige: suena press.sound (3, SE_KETTEI) y los demás dejan de responder. No hay sonido de cursor ni de cancelar.
• Al elegir (choose). Los botones no salen: las dos pantallas se oscurecen a negro en 30 ticks y el juego pasa a lo que dice does. New Game empieza el prólogo. Load Game abre la pantalla de carga aunque no haya partida guardada: sus tres casillas dicen «No Data». El menú nunca desactiva un botón; un botón desactivado tendría el texto gris (label.colour_bgr555.disabled) y no respondería.
• Música. La canción music (21, SEQ_DM_TITLE) la empieza la demo del título, antes de TOUCH TO START, y el menú no pone otra. Tocar TOUCH TO START suena 2 (SE_CURSOR), oscurece en 30 ticks y queda en negro unos 57 mientras carga el menú.
• Quieto (idle). Sin tocar nada no cambia nada y no vuelve a la demo.
• Hand Settings (hand_settings). No sale del menú: los cinco botones vuelven a su from_px en 30 ticks, Hand Settings regresa a su lugar y entran la pregunta («Left/Right handed?», question) y las dos manos (hands, de chr/select_hand.can). Tocar una mano suena 3, guarda 1 para la de la izquierda y 0 para la de la derecha, y vuelve el menú. Qué valor es zurdo no está confirmado.
• En el DS esta pantalla no tiene Opciones ni Salir.

/data/title-screen.md trae los mismos datos en tablas.

Personajes

/data/characters.json lista los 19 personajes que hablan en la historia, con su nombre (name), cuántas líneas tienen (lines) y faces: una imagen por expresión, en el orden del juego. Las escenas usan estos retratos a través de /juego/data.json (ver "Escenas").

Mapas de batalla y batallas

/data/maps.json lista cada mapa de batalla: la imagen completa (image), el minimapa del juego (minimap) y sus batallas (battles). Una batalla tiene su número (battle), las misiones de la historia que la usan (missions) y las unidades que están en el campo al empezar (units):

• uid y unit (el slug en /data/units.json) dicen quién es.
• x, y es su posición en el mapa. Con el origin del sprite en ese punto, las unidades quedan sobre el suelo transitable del mapa.
• level, y named: true para los personajes de la historia (jefes y aliados), false para los monstruos comunes.
• orders: lo que hace por su cuenta desde que entra al campo (ver «Órdenes de las unidades en las batallas»).

Cada misión de missions trae además objective (el texto que muestra el juego), conditions (cómo termina: result victory, defeat, defeat_passed —una derrota que cuenta como superada— o draw, cuando se cumple trigger: no_enemies, boss_dies, isaac_dies, time (value en segundos), all_crystals, no_crystals, crystals_held (value cristales), isaac_reaches_area, boss_reaches_area, spell_cast (value = id del hechizo), chest_opened, capture, draw…), time_limit_s (sin límite propio, 3600) y music (el n de la canción en /data/audio.json). Si la misión tiene varias batallas, la lista vale para todas.

chests son los cofres de la batalla: posición x, y y odds, lo que puede dar (item de /data/items.json, chance y la probabilidad de cada nivel en levels).

seals son los sellos de aparición del suelo de la batalla: punto x, y y units, los índices en units de las unidades ocultas que están sobre él. Cómo dibujarlos está en «Sellos de aparición».

animation existe en los mapas que el juego anima: la nieve que cae (juego de teselas ac03, 8 cuadros de 11 ticks) y la arena que corre (ac04, 4 cuadros de 7 ticks). Cada cuadro dura un tick más que el valor del archivo, porque el reloj del juego cuenta hasta 0 y cambia de cuadro en el tick siguiente. base es el mapa sin esa capa; frames tiene los cuadros apilados de arriba abajo, cada uno del tamaño de base y transparente donde no hay capa. Se dibuja el cuadro i encima de base durante ticks[i] ticks de 1/60 s y se repite. image es base con el primer cuadro. En los demás mapas, animation es null.

decorations son los objetos del juego que van sobre el mapa: puentes, copas de árboles y otros. Cada uno trae su punto x, y en px del mapa, alpha (opacidad de 0 a 31) y height: el juego los dibuja en orden de y + height. frames es una tira de cuadros de frame_size, apilados de arriba abajo; origin es el punto dentro de cada cuadro. El cuadro i se muestra ticks[i] ticks y se repite; con un solo cuadro, la decoración está quieta. sprite agrupa las que comparten dibujo.

lava existe en los mapas de magma (025–028, 044, 305): la lava brilla porque el juego cambia los colores de una fila de su paleta. mask es una imagen del tamaño del mapa: su rojo es el color (1–15) de esa fila en cada píxel, y 0 fuera de la lava. El cuadro i pinta esos píxeles con palettes[i] (16 colores #rrggbb; el 0 no se usa) durante ticks[i] ticks, y se repite. El cuadro 0 es la imagen del mapa.

terrain es la colisión y el terreno del mapa, en px del mapa (las formas pueden salir del borde). No hay cuadrícula: las unidades se empujan fuera de las formas cada fotograma.

• boxes (centro x, y ± half_width, half_height) y circles (x, y, radius), cada una con su kind:
  • high_obstacle: detiene a las unidades que caminan, a las que vuelan y a los disparos. low_obstacle: solo a las que caminan.
  • Zonas, solo para unidades que caminan (las que vuelan nunca se ven afectadas): magma y damage_floor hacen 50 de daño cada 60 tics (fuego y sin elemento); ground igual, solo si un hechizo lo calentó; ford mitad de velocidad salvo congelado, apaga y bloquea las quemaduras; ice nada, mitad de velocidad si un hechizo lo derrite; bog mitad salvo seco; sand nada, mitad si se vuelve pantano; quicksand empuja 0,25 px por tic hacia push.
  • El daño de 50 se multiplica por (118 + azar(0..20)) / 128; una unidad del mismo elemento se cura 6 y una del opuesto recibe 75. Las de agua ignoran la lentitud del vado y del hielo derretido; las de tierra, la de ciénaga, arena y pantano y el empuje.
  • event_area (con su número area): las misiones preguntan si hay unidades dentro; no detiene a nadie.
• squad_starts: donde aparecen los escuadrones del jugador. Las unidades de un escuadrón se colocan en ese punto más team.formation_px de /data/rules.json.
• Los hechizos de terreno (terrain en /data/spells.json) cambian cómo actúan las zonas dentro de un círculo durante 20 s; no cambian las formas.

terrain_effects resume las zonas con efecto de cada mapa (kind, y en quicksand las direcciones push). Las reglas completas están en terrain de /data/rules.json:

• effects dice qué hace cada kind a una unidad que camina dentro: push_px_per_tick, speed_multiplier, o damage cada every_ticks con su element. spared_elements son los elementos que se libran de su freno o empuje, y altered es el efecto mientras un hechizo de terreno la cambia (heat, harden, swamp, dry, freeze).
• damage: la unidad del mismo elemento se cura same_element_heals_fraction del daño, la del opuesto recibe opposite_element_multiplier, y el resultado se multiplica por un valor al azar entre los dos de random_multiplier.
• flying_units_affected es false, y sides_affected dice que Isaac, sus escuadrones y los enemigos se tratan igual.
• Las capas animadas de los mapas solo dibujan: la arena que corre coincide con las zonas quicksand, la nieve no tiene zona propia y la lava es magma.
• Cada unidad trae terrain_spared en /data/units/<slug>.json: all si vuela, el kind cuyo freno o empuje no la afecta, fire_heals si el daño de fuego del terreno la cura, y fire_x1.5 si le hace 1,5 veces.

Sellos de aparición

Algunas batallas de la historia dibujan sellos hexagonales en el suelo, en los puntos donde aparecen enemigos (98 sellos en 34 batallas; la batalla 1 tiene seis, uno bajo cada Hongo bruma). /data/appear-seals.json trae las imágenes, las reglas y, en battles, los sellos de cada batalla con las unidades que están sobre ellos; seals en /data/maps.json trae los mismos puntos. Px del mapa, tics de 1/60 s y alfa sobre 31 (opacidad = alfa / 31). Sale del código del juego; los colores, la profundidad, el parpadeo y la columna de luz se comprobaron en un emulador en la batalla 1.

• Cuándo. Cada sello está en el suelo desde que empieza la batalla hasta que termina. No reacciona a las unidades: no crea ninguna y no cambia cuando una aparece sobre él.
• Imagen. seal.image es una tira de cuadros de 32 × 25, de izquierda a derecha base, fire, wind, water, earth, light. El pivot (16, 12) del cuadro va sobre el punto del sello. El sello se dibuja debajo de todas las unidades.
• Base. El cuadro base (gris), siempre opaco.
• Capa de color. Un cuadro de color sobre la base; empieza en fire. Cada step_ticks (4) sube un contador de pasos; el alfa de la capa es alpha_by_step[paso − 1] (de 1 hasta 30 y luego hasta 2). Tras steps_per_color (59) pasos, color_ticks (236), pasa al color siguiente de colors, y de light vuelve a fire. Así el sello brilla y se apaga despacio en fuego (amarillo anaranjado), viento (verde), agua (azul), tierra (naranja) y luz (amarillo).
• Tamaño. El sello no cambia de tamaño (scale 1).

Una unidad que aparece. Una unidad oculta sale cuando el guion de la misión la hace aparecer, en su propio punto (en la batalla 1 es un sello) o en otro. No suena nada. Pasan dos cosas a la vez, desde el tic 1:

• Parpadeo. Un contador va de counter_from (63) a counter_to (127), uno por tic. Mientras sube, la unidad solo se dibuja cuando counter & 2 no es 0: 2 tics se ve y 2 no, durante 64 tics. Luego queda opaca.
• Columna de luz. column.image tiene dos cuadros de 32 × 40 con el pivote en (16, 32): back, detrás de la unidad, y front, delante. El pivote va en el punto de la unidad bajado su radio (radius_px en /data/units/<slug>.json), con alfa 16. Los dos se espejan en horizontal un tic sí y otro no (mirror_frames). En los tics 1 a 29 su alto es t / 30 del total y crece hacia arriba desde el pivote; desde el tic 30 tienen su tamaño y su alfa es 16 − floor(0,4 × (t − 30)); después del tic 70 desaparecen. La columna sigue a la unidad.

Mapa del mundo

/data/world-map.json describe el mapa por el que viaja Isaac entre misiones. picture es /juego/mundo.png; las posiciones están en píxeles de esa imagen.

• places: los 44 lugares, con id, x, y y neighbors, los lugares unidos a él por un camino. region es su posición en regions: el nombre y la descripción que muestra el juego (name, description, en en, es, fr y de); varios lugares comparten región.
• availability_group (0 a 15) es el interruptor que habilita el lugar, y unlock_flag la bandera de /juego/data.json que lo enciende. Según el código, un lugar se habilita cuando su bandera está encendida, y un camino cuando lo están sus dos lugares.
• paths: los 50 caminos, como pares de id. Son rectos y se recorren en los dos sentidos. Isaac solo va a un lugar unido por un camino, y cada tramo dura movement.leg_frames (60) cuadros, sea largo o corto.
• offers: las misiones y pueblos que el mapa ofrece en cada lugar.
  • chapter es el capítulo de /juego/data.json (qc01 a qc06; sc01 a sc03 para los secundarios) y step, el paso dentro del capítulo. optional es true si completarla no cierra el paso.
  • objective es el texto de sus batallas; vacío si solo tiene escenas. scenes son ids de /juego/data.json y battles trae battle y map de /data/maps.json (null si la batalla no tiene página de mapa).
  • Un mismo guion puede aparecer en dos lugares: el juego lo ofrece en uno u otro según una condición.
• free_battles: las batallas libres que el juego registra en cada lugar, con su capítulo.
• Al llegar a un lugar con algo, empieza, y el juego guarda un punto de control.
• markers: los tres marcadores del mapa. El rojo marca un lugar donde se ofrece una misión o un pueblo; el azul, otro tipo de evento sin identificar; el verde, no se sabe qué lo muestra.
• confidence dice cómo se sabe cada parte: rom sale de los datos del juego; code, de leer su código, sin comprobarlo en una partida.

La historia: /juego/data.json

Este archivo es la lógica de la historia, leída de sus scripts: qué misiones están disponibles, qué ocurre en cada una, qué cambian las respuestas del jugador y a qué final llevan. Las rutas dentro de él son relativas a /juego/. Los textos están en /juego/textos/<idioma>.json, con los mismos ids.

Estado de la partida

Una partida son cuatro cosas, todas vacías al empezar:

• Banderas: interruptores numerados, encendidos o apagados.
• Contadores: valores numerados de 0 a 127. El contador rules.compassion es el que decide entre dos finales.
• Respuestas: para cada escena, la opción elegida en cada punto de decisión.
• Completadas: las misiones terminadas.

Condiciones

Muchas entradas llevan una lista de condiciones, y todas deben cumplirse. Cada una es [negate, test] (si negate es true, la prueba debe fallar):

Capítulos y misiones

chapters lista los capítulos en orden: qc01 a qc06 para la historia principal y sc01 a sc03 para las misiones secundarias. Cada capítulo es una lista de pasos en el mapa del mundo; cada paso ofrece misiones como [mission, offer, conditions] y tiene flags que se encienden al terminarlo:

• Solo se ofrecen las misiones cuyas condiciones se cumplen.
• offer 159 marca una misión opcional. Un paso termina cuando se completa una de sus otras misiones (o cualquiera, si todas son opcionales); entonces se encienden sus flags y se abre el paso siguiente.
• Si no queda ningún paso abierto (falta encontrar algo), el último paso que ofreció misiones sigue abierto para que sus lugares se puedan volver a visitar.
• El capítulo actual es el primer qc0N cuya bandera en rules.chapterFlags (una por capítulo, del 1 al 4) está apagada. Con las cuatro encendidas, la historia sigue en qc06 si la bandera rules.route6Flag está encendida, y en qc05 si no. Los capítulos secundarios transcurren al mismo tiempo.

missions describe cada misión: kind (m batalla, t pueblo, r batalla libre) y una línea de tiempo (timeline) que se recorre en orden, saltando las entradas cuyas condiciones (el último elemento) no se cumplen:

Al final, la misión cuenta como completada. Los nombres de las misiones y de los capítulos están en los archivos de textos (missions, chapters).

Escenas

scenes[id].blocks tiene los bloques de la escena; empieza en main y ejecuta sus elementos en orden:

La escena termina cuando un bloque se queda sin elementos. Las líneas conservan los saltos de línea del juego (\n). Isaac es el nombre por defecto del protagonista. [L], [B] y [+Control Pad] (con las palabras de cada idioma) representan los botones de la consola.

Para dibujar la pantalla de arriba (256×192):

• Fondo: bgs[background] es [picture, width, height]. Muestra la parte que empieza en x = clamp(-cameraX, 0, width - 256), y = clamp(-cameraY, 0, height - 192).
• Personajes: cada [actor, x, y, expression, mirror] de cast es un retrato. portraits["<actor>_<expression>"] es [picture, dx, dy, width, height]: su esquina superior izquierda va en (x + dx, 160 + y + dy), reflejada en horizontal cuando mirror es 1. names[actor] dice quién es.

Finales

Cuando una misión enciende la bandera endings.gameOverFlag, el juego termina. La escena final es la que va con la primera bandera encendida de endings.byFlag ([flag, scene]), o endings.default si ninguna lo está. Sus títulos están en los archivos de textos (endings).

Batallas en la historia

battles[id] es una batalla de la historia: map (su imagen), size y units como [uid, x, y, level, character] (character no es 0 en los personajes de la historia). Las mismas batallas, con nombres, están en /data/maps.json.

Archivos de textos

/juego/textos/<idioma>.json tiene, para ese idioma: names (quién habla, por número), scenes (el title y las lines de cada escena), missions, chapters, endings y units (los nombres de las unidades por uid). Su ui tiene las etiquetas que usa la novela del sitio; puedes ignorarlo.

Audio

/data/audio.json tiene music (code es el nombre de la canción en el juego) y effects, agrupados por category. Las canciones con bucle están grabadas tocando el bucle dos veces y desvaneciéndose al final. En el juego, una canción con loop_end_s vuelve a loop_start_s al llegar a loop_end_s y suena para siempre; una con end_s suena una vez. missions y scenes cuentan las misiones y escenas que la usan (la de cada misión está en /data/maps.json), y screen es la pantalla fija que la usa: world_map, mission_complete, victory y defeat (al terminar una batalla), game_over, title o ending.

sound_events dice qué hace sonar los efectos de los menús, el mapa del mundo, la pantalla de resultados, los cofres y los cristales de maná. Sale de leer el código del juego (evidence: static): cada lugar que reproduce un sonido y el número que carga; no se observó en un emulador. El juego reproduce el sonido número N como la entrada N − 1 del archivo de sonidos elegido. Normalmente es SEQ_SE, la categoría «Juego» de effects.

• events: group (menu, world_map, results, chest, crystal), event, sounds (id, name, url) y calls, los lugares del código que lo hacen sonar. En los menús, cursor, confirm y cancel están identificados; other junta el resto de los sonidos de menú, de los que no se trazó qué acción los dispara en cada pantalla. En el mapa: move (un tramo de camino), enter_event (llegar a una escena o un pueblo) y enter_battle. En resultados: exp_count (cada paso del conteo de experiencia) y level_up. Cofre: open e item (el objeto obtenido). Cristal: captured y lost.
• download: mientras está abierta la pantalla Download del modo duelo, el juego usa otro archivo, SEQ_SE_CURSORS. En él, los números 2, 3, 4 y 108 suenan con sus propias versiones (replaces es el sonido normal de ese número). url es null si el sitio no tiene ese clip.

Otras imágenes

/data/gallery.json agrupa el resto del arte por sección: runas (la forma de cada una, como imagen), hechizos y efectos de batalla, fondos, el mapa del mundo y sus marcadores, la interfaz, y arte sin usar o de prueba. /juego/mundo.png es el mapa del mundo.

Lo que no está en los datos

Tu versión tiene que definir esto:

• Qué órdenes producen los estados 6, 7 y 12 de la IA (unresolved_states de /data/ai.json) y cómo se ve la IA en una batalla: lo publicado sale del código, no se observó en un emulador.

Los gráficos, los textos y la música pertenecen a Taito y Ubisoft.