Guide for coding agents

LostMagic: game data for building your own version

LostMagic (Taito, 2006, Nintendo DS) is a tactics game. Isaac, the hero, casts spells by drawing runes on the touch screen and fights alongside the monsters he recruits, through a story whose choices lead to four endings.

These files hold what was extracted from the game's cartridge (US release): sprites and animations of every unit, character portraits, battle maps with where each enemy starts, the full story with its choices and the logic that orders the missions, texts in English, Spanish, French and German, music, sound effects and the rest of the art. Use them to build a version of the game on any platform.

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

Paths inside the JSON files start with / and are relative to the base URL.

To download everything at once: https://lostmagic.skapxd.dev/data/files.txt (one URL per line).

Files

Conventions

• Every file under /data/ comes in two formats with the same content: .md, as tables, easier to read and lighter in tokens, and .json, to load the data in a program. The fields described below are the JSON keys; the Markdown tables use the same names as column headers (name.en, name.es for the two languages).
• Each of the DS's two screens is 256×192 px. Story scenes are drawn for the top one.
• Coordinates are in pixels, from the top-left corner, with y growing downwards.
• Durations come in ticks of 1/60 s, the console's frame rate. ms fields are the same, rounded.
• The art is pixel art: scale it by whole numbers with nearest-neighbour sampling to keep it sharp.
• Names come in English and Spanish as { "en": …, "es": … }. The story has four languages.
• Pictures are PNG; animated GIFs are previews only. Audio is AAC in .m4a: convert it if your platform does not play AAC.

Units and their animations

/data/units.json lists every unit: uid (the id battles and the story use; null for unnamed appearances), slug, name, element (fire, wind, water, earth, dark, light or null), a portrait picture, the sheet, and details, the URL of its full data.

Each unit has one sprite sheet: a PNG holding every frame the unit uses. sheet.cells gives the exact rectangle of each frame on it (x, y, w, h); the position in that list is the frame's number.

An animation is a loop of frames drawn on a fixed canvas of width × height:

• Each item of frames says which sheet frame to show (cell), where its top-left corner goes on the canvas (x, y) and for how long (ticks). The same cell can appear several times.
• origin is the unit's anchor point on the canvas. It stays fixed while the frames move around it, which is how jumps and attacks move the body. Put the canvas so that origin falls on the unit's position.
• action and facing say when the game plays it: the unit's action and which way it faces (down front view, up back view, left, right; empty when the action has no facing). used is false for the ones that are drawn but never played.
• preview is the same animation as a GIF, to see what it shows. GIFs store times in 1/100 s and merge repeated frames, so use frames for timing.

The actions:

When a unit has no animation of its own for an action, it keeps its idle pose. Right-facing animations are separate drawings, not a mirror made at play time.

{
  "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 lists the story battles the unit takes part in.

To draw frame i of an animation: take the rectangle sheet.cells[frames[i].cell] and paste it on the canvas at (frames[i].x, frames[i].y). Show it for frames[i].ticks / 60 seconds, then go to the next frame and back to the first at the end.

Stats

Each named unit's /data/units/<slug>.json also has its numbers from the game's tables:

• stats: hp, mp, attack, defense, magic, magic_defense, speed, accuracy and evasion, each as [level 1, level 50]. At level L a stat is level1 + floor((level50 − level1) × factor / 128), where factor is the value of the unit's growth curve (early, late or linear) for level L in /data/levels.json.
• speed_px_per_tick: how far it walks per tick at levels 1 and 50; it is speed / 32. Flying units use the same speed.
• flying, ranged (its normal attack is a projectile), attack_interval_ticks (time between attacks), attack_reach_px (it attacks when the gap between the two units' edges is below this) and radius_px (its body is a circle of this radius).
• head_px: the height of its head above its point; the HP bar and the status icons go over it.
• up_cost (what it takes from the Line Up's capacity) and squad_size (how many units one squad brings).
• attack_used_by: what its attack stat is for. normal_attack, its normal attack. The units that never attack (attack_reach_px 0) have dance_spells (Isaac: only the dance spells use it, hitting with his full attack minus a quarter of the target's defense) or nothing (the mages, the story bosses and the Villager: it is never used). attack_note explains it in English and Spanish, and says how the unit deals damage. /data/units.json has both fields for every unit.
• element is the unit's element, and description the game's text about it, in English and Spanish.

/data/levels.json has, per level: exp_to_next (the experience to reach the next one), the factors of the three curves (growth, out of 128) and lineup_up, how many UP of units the Line Up holds at that level of Isaac's.

Movement and AI

/data/ai.json describes how units move and what they do on their own. It is read from the game's code (evidence: static); it was not observed in an emulator.

• movement: routes are straight (route: straight), with no path finding and up to route_points_max points; a unit reaches a point when it is less than point_reached_distance_px away. A group sent to a point spreads around it: each unit goes to the point plus its direction from the group's centre × (its radius + group_spacing_extra_px). A unit walks speed / 32 px per tick, without acceleration; obstacles and other units push it out.

• Target: every retarget_every_ticks ticks, in the states_with_target_search states, it looks for enemies less than search_px away and picks the nearest, the one with most HP or the one with least HP (these two prefer targets within its reach).

• orders: each order (order, with the game's classes in classes) sets a decision state (state):

  • wait with mode 0 (state 0) attacks without chasing whoever comes within its reach + attack_in_place_extra_px; with another mode (state_other_mode, 1) it chases within its sight radius.
  • move follows the route without attacking; move_auto attacks on the way without leaving it; move_attack chases within its sight radius or follows the route; move_wait_auto follows the route, chases and, once stopped, waits.
  • guard (states 9 and 10) watches over a point: guard says when it walks back (distance > sight) and how far (distance <= sight / 2).
  • escape (11) runs straight away while the distance between centres is under the unit's keep_distance (/data/units.json).
  • take_crystal (8) goes to the nearest mana crystal of another side within order_list.take_crystal_radius_px and stays until it is its side's.

  The sight radius is each unit's sight, and missions change it.

• unresolved_states: states that exist but whose producing order is not known yet.

Unit orders in battles

Each unit of a battle in /data/maps.json has orders, its list of orders; when it is empty, the unit gets none at the start. unit_orders in /data/ai.json describes each order: state is the state it leaves the unit in (null: unchanged), target how it gives the point and ends when it ends.

• Points: x, y is a map point in px; dx, dy are added to the unit's position when the order starts. The unit walks straight to it.
• wait: ticks (null: forever); chase: false is state 0 (attacks without moving), true state 1 (chases within its sight).
• back: goes back steps orders, never before the first one. This is how patrols repeat.
• target_nearest, target_most_hp, target_least_hp: the rule it picks targets by from then on. set_sight: its sight radius becomes sight_px.
• change_max_hp: its max HP becomes floor(max × percent / 100); set_max_hp: hp. Its HP becomes that same value, never above the max it had.
• guard never ends: the list stays there.

How the list runs (order_list), one step per tick (steps_per_tick):

1. It starts at the first order. The tick an order starts in does not count towards ending it.
2. ends: at_once ends in the tick it starts; route, the first tick after the unit reaches the point (on arrival it is in state route_end_state); ticks, once ticks ticks have been counted after the start tick, on the next one; crystal, when the crystal is its side's, or at once when none is that close; jump is back; removed, like at_once, and the order also leaves the list.
3. The next order starts on the next tick. With a wait of N ticks, the next order starts N + 2 ticks after the wait started.
4. back counts only the orders still in the list: removed_when_done are gone.
5. After the last one ends, the unit keeps the state it is in and gets no more orders.

Example, the first Misty Mush of battle 1: change_max_hp 75 (leaves the list), move to (344, 153), wait 30, move to (344, 133), wait 30, back 4. It patrols between the two points and stays at each one for the wait's 30 ticks plus the ticks the list takes to step; it does not attack while it walks and attacks without moving while it waits.

Duel

/data/duel.json describes the duel mode, where two people play each other. It comes from the game's data and code (DB/chrSelScnDat.cssd, DB/eloRate.elo); it was not observed in an emulator.

• presets: the 8 ready-made teams a player can pick. Each has level (the player's level, 40), element_levels (the six element levels, which the game clamps to 1–50) and squads, three squads (unit_id of /data/units.json, name, slug and level). The cartridge does not name them: they are numbered 1 to 8.
• rating: the rating of Wi-Fi matches, between min and max. Each of the rows has the bound on the difference (difference, own rating − the opponent's) and the points a win (win), a draw (draw) or a loss (loss) adds. A negative difference uses the first row whose bound is at least the difference; any other, the last row whose bound is at most it. Then the rating is kept between min and max. elo_k is 50 because all 53 rows match, within one point, the Elo system with K = 50: K × (result − 1 / (1 + 10^(−difference/400))), with result 1, 0.5 or 0.

Game rules

/data/rules.json has the game's limits, read from its code:

• team: squads_max, the squads that go with Isaac, never more than the map's squad start points; player_units_max; formation_px, where each unit of a squad starts from its start point (y grows downwards); capacity_up_by_isaac_level, the UP the team holds at each of Isaac's levels, from level 1.
• roster: monsters_max, the monsters that can be kept, and captures_per_battle_max.
• items: inventory_max, found_level_max (the highest level of a found item) and found_per_battle_max.
• levels: level_max of Isaac and the monsters, element_level_max and enemy_level_max.
• experience: per_kill_per_level (each unit that dies gives that number × its level), battle_max and level_1_to_max.
• battle: default_time_limit_s, the limit when the mission sets none.
• new_game_plus: the levels enemies gain in each chapter (1 to 5, capped at levels.enemy_level_max) and the extra levels of chest items (capped at items.found_level_max).
• checkpoints: how many map missions and scenes and how many free battles take a checkpoint when they start.

The rules that are not a number:

• Isaac is always in the team and carries no item. Each squad carries one item, which works on every unit in it, and has as many units as its species' squad_size.
• UP is only checked when the team is put together, not in battle.
• Only regular enemy units can be captured, not bosses or allies. They join after a win, at their battle level with 0 experience. Repeated species in the list and repeated items in the inventory are allowed; with the list full, the new one replaces one that is not in a squad, or is dropped.
• Every unit of the enemy side or allied unit of the map that dies gives experience, whoever kills it; captured ones give nothing. On a win, Isaac and every squad each get the whole amount; it is not split.
• A defeat or a draw discards everything gained in the battle. Continuing puts the story and the runes back to the checkpoint, taken when a mission, scene or free battle starts from the map; level, monsters and items are kept, and the mission replays from its start.
• Retiring from the pause menu discards the battle and goes to the title, with no continue.
• In New Game+ Isaac keeps his level, experience, element levels, runes, monsters, team and items; the story starts again with harder battles.
• The results screen, only after a win, shows in order: experience and element levels, items found, captured monsters and new spells. There are no ranks or grades.
• There is no money or shop, and no maximum of units on the field or of active spells. Isaac can cast as soon as the previous cast animation ends; MP is the limit.

Items

/data/items.json has the 8 items. Each squad carries one, applied to every unit in it when the battle starts; Isaac carries none.

icon is the 16 × 16 px icon the menus show. It depends on the stat the item raises, so several items share one. Battles draw no item icon: chests always look the same.

pictures are each item's icons at levels 1 to 6, made with AI for this site: they are not in the game. sheet is the 120 × 160 px sheet and by_level gives each level's 20 × 20 px cell (x, y, w, h). From level 2 the icon has an aura of another color, and from level 4, sparkles. To keep them sharp, scale them by whole numbers with image-rendering: pixelated.

• stat: the stat it changes (hp, speed, attack, interval, accuracy, evasion, defense or magic_defense).
• bonus_by_level: the value v at levels 1 to 10, out of 128. Chests only give levels 1 to items.found_level_max of /data/rules.json.
• effect, how v applies to the unit's stat x:
  • multiply: x + floor(x × v / 128). With hp, the unit also starts with its HP full.
  • reduce: x − floor(x × v / 128), at least 1.
  • double: x × 2, at any level.
  • gap_to_100: x + floor((100 − x) × v / 128).
• in_battle (Wind Shield, Hunter Eye, Angel Coat and Dragon Scale; null for the rest): what the item changes in a battle, in en and es: what (what the stat is), examples (worked examples with level-1 units), good, bad, caution, level (when the item's level does not matter) and anchor (the section of /logic/combat/ with the rule). examples has the same examples as numbers: accuracy, evasion and hit_percent as [without the item, with it].
• chests: the story chests that can give the item: battle (the same number as in /data/maps.json), map, the position x, y in map pixels, chance (0 to 1), levels, the chance of each level, and new_game_plus_levels, the same chances in New Game+.

Level 6 is almost never found in the story: chests give up to level 5, except one Demon Horn chest on map 038 (1.1 %). In New Game+ the game adds new_game_plus.chest_level_bonus (2) to the chest's level, capped at items.found_level_max (6), so chests of levels 4 and 5 give level 6.

How accuracy and evasion decide a hit (stats at a level in /data/units/<slug>.json; Hunter Eye doubles the attacker's accuracy, Angel Coat the defender's evasion, at any item level):

• Melee hits when a random number from 0 to 100, plus accuracy, minus evasion, reaches 100: a chance of clamp(accuracy − evasion + 1, 0, 101) / 101.
• A shot hits when a random number from 0 to 99 is under (accuracy − evasion) & 0xff: the game keeps one byte of the difference. So it always hits when evasion is higher than accuracy, and from a difference of 256 it starts again from 0 (a shooter with Hunter Eye can hit less). This comes from reading the game's code (ov1 0x2130f40); it was not tested in an emulator.

godot says how each item will work in our Godot port (approved design, version 1), apart from the original's fields: same_as_original, effect and bonus_by_level as above (plus add: x + bonus_by_level, in points), line_up_shows_effect (the Line Up screen shows the effect of all 8), the text in en and es (same, the same as same_as_original; change, what changes and why, or "Same as the original"; examples; notes) and, for Hunter Eye and Angel Coat, examples as numbers: hit_percent without the item, by_level with it at levels 1, 3, 5 and 6, and original_hit_percent with the original's item. In Godot:

• Hunter Eye: multiply, accuracy × (1 + v/128), like Demon Horn.
• Angel Coat: add, 4 points of evasion a level (v × 40 / 128, rounded).
• A shot hits with a chance of clamp(accuracy − evasion, 0, 100) / 100: with higher evasion, it always misses.
• The other items, the levels (1 to 6, +2 in New Game+) and who carries items stay as in the original.

When the battle loads, the game draws each chest's item and level. The item goes to the player's unit that opens the chest and is received on a win. In New Game+ the level rises by 2, with the same cap.

/data/chest.json is the chest as a sprite:

• closed is the closed picture the maps draw, placed at the chest's point plus (dx, dy).
• sheet holds cells equal cells of cell.width × cell.height px in columns columns. The chest's point is at cell.origin in each cell.
• animations: idle0 (closed), open (opening), loop (open with the reward), suka (smoke) and emptybox (empty). Each frames is a list of cell and ticks of 1/60 s. loop says whether it repeats, and preview is a GIF or PNG to look at.
• flow: with a reward the game goes from idle0 to open and stays in loop; without one, from idle0 to emptybox. suka has used_by_game false: the game never picks it.

Spells and runes

Runes

/data/runes.json has the 18 runes: id (1 to 18), element, level (1 to 3), its picture, spell (the spell it casts alone) and learned (the missions where it is learned). Isaac casts a spell by drawing 1 to 3 runes in order while holding L (R with the left-handed option); releasing the button ends the chant. Each rune is a single stroke: lifting the stylus closes it.

templates are the strokes the game accepts for each rune: points on a 0–63 grid (y down), in drawing order. from_dot marks the ones that start at the dot of the rune's picture; the rest are the same drawing from another start or in the other direction.

To recognize a stroke:

1. Keep one point per frame while the screen is touched. After the first, keep only the points that move at least 1 px in x from the last one kept: the game ignores movement in y. A stroke of fewer than 4 points cancels the chant.
2. Take a square centred on the stroke, with side max(width, height), so the proportions are kept. Simplify it: keep both ends and, piece by piece, the point farthest from the chord if it is max(1, 2 × side / 64) px away or more, up to 40 points. Map it to the 0–63 grid with (p − origin) × 64 / (side + 1) and drop repeated consecutive points.
3. For each point k ≥ 1 compute angle[k], the direction of the segment that reaches it, and ratio[k], the share of the total length that segment is. Point 0 takes the direction of the first segment.
4. Compare the stroke (I, with nI points) with each template (P, with nP points) by walking both lines together along their length:

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. The template with the highest score (0 to 1) wins; on a tie, the first one. If it reaches accept (0.70), the stroke is its rune. Rotation is not forgiven: about 30° off is already at the limit.

A recognized rune must also be learned, the runes drawn so far must begin some spell, the runes-per-spell limit cannot be passed (runes_per_spell: the missions that allow 2 and 3) and there must be enough MP for that rune. If anything fails, the chant is cancelled.

A spell's quality is the average score of its runes. If it reaches great (0.85), 0.5 is added: the factor goes from 0.70–0.85 to 1.35–1.50.

/logic/runes/practice/ lets you practise drawing with this recognizer, ported to TypeScript with the same integer arithmetic: it gives the rune, the score, whether it passes accept or reaches great, the factor and the three closest templates. /data/rune-strokes.json holds 640 test strokes with what the game's recognizer gives for each; a port must give the same. Each one is samples (one point per frame at 60 Hz, in pixels of the 256 × 192 touch screen) and kept (how many the capture keeps); with fewer than 4, cancelled is true; else top is the three closest templates as [rune, template, score], the template numbered as in templates of /data/runes.json (runes in order) and the score out of 4096: accepted from 2868, great from 3482.

Spells

/data/spells.json has the 396 spells:

• name: the cartridge's name in English and Spanish. The Spanish ones are often abbreviated (none is longer than 12 characters, for example «Torbell. f.»); the site keeps them as they are, without expanding or translating them, and shows the English one beside them.
• runes: its runes, in order. element: its element, which is its last rune's: 294 of the 396 mix runes of different elements.
• kind: the family (cloud, wall, bullet, blast, falling_objects, aura, zone, unit_effect, object, dragon). variant: the exact behaviour within the family.
• mp_by_rank: the MP cost with the element at rank 0 to 4. Rank is floor((element level − 1) / 10). The cost is the sum of its runes: mp_per_rune[position][rank of that rune's element][rune level − 1] from /data/runes.json. Each rune is paid as it is drawn.
• targeting: how it is aimed (circle: centre and radius; line: start and end; fixed_circle and point: a point; direction: it leaves Isaac towards where the stylus is released; unit: a unit; instant: no aiming). targets: enemies, allies or all; null for the three that touch no unit (Transport and Flight move whoever casts them, Restore only changes the ground). numbers.cast_range_px is the farthest distance from Isaac.
• effect_group: only on unit_effect (null for the other kinds), what it does to units. heal restores HP or removes statuses: the heal flag, a status of group cure or regeneration, or the variants that move HP to the caster's side (life_thread, life_shine, light_transfer). boost puts a status on allies and weaken on enemies: every status the game casts on allies helps them and every one it casts on enemies hinders them. other is the rest: no status and no healing, or a status on both sides. It is the spells page's filter, not a field of the cartridge.
• power: with power_scaled, the power at cast is floor(floor((power + caster's magic) × quality factor) × (rank + 4) / 4); without it, power is used as it is. With the heal flag, it heals.
• status: the status it can cause: its record (id), group, chance (at rank 0 and factor 1; multiply by the factor, by (rank + 4) / 4 and by the element factor in elements.status_chance of /data/combat.json), duration_ticks and power.
• terrain: how it changes the ground (heat turns it into magma, harden hardens magma, freeze freezes water, dry dries swamp into sand, swamp turns quicksand into swamp, restore restores it).
• terrain_overlay: what the spell draws over the map while its zone lives, lasts_ticks (1200, 20 s). The zone is a circle: area.radius_px, or one circle of area.per_object_radius_px for each falling object. The 8 × 8 px cells whose centre is inside the circle are painted. paints is the layer it puts and on which surface (on); image is its 32 tiles animated, each frame lasting frame_ticks (null: still). clears are the layers it removes inside its circle while it lives, even when another spell put them, before or after. That is how opposites cancel: Storm removes Fire Rain's magma, Fire Rain removes Ice Maiden's ice, and restore removes everything. It appears at once and, when the zone ends, vanishes with no animation: there is no entry or exit animation, and the frame_ticks frames loop the whole layer. It is only the picture: the terrain statuses give the effect on units. on_any_map says whether that surface exists on any map. dry paints mf04 on swamp, but no map has swamp (on_any_map: false): in the game it only removes the swamp swamp leaves.
• flags: piercing, homing, rapid (bursts), spread (fan), lock_on (one shot per target), flying_only and walking_only limit who it affects, knockback, knockdown.
• numbers: its family's numbers, in ticks of 1/60 s and px.

Spell families

/data/spell-families.json groups the 396 spells by the game code that runs them: the effect class and subkind in their data. The generic spell on units (direct) is split by role (heal, damage or status-only) and status group, and Prank, Joke and Trick go together as tub. Each family has page (its page on the site, /logic/families/<family>/, or /es/logic/families/<family>/ in Spanish: its types and its spells in an element × variant matrix (rows such as Level I, Rapid or King, and «Others» for the spells that fit none) when most of them fit, or as cards, each with its animation and a panel with all its numbers; /logic/families/ is the catalog of all of them), spells (the slugs of /data/spells.json), same (the fields equal in all, with their value) and differs (the ones that change). The fields are those of /data/spells.json: numbers.<name> and status.<field> are flattened, and runes is how many it has. power is only compared within a family, because each one uses it differently. note (EN/ES), when present, says when one pays off over another, only where the research supports it; it comes from reading the code, not from playing. Families of one spell have empty same and differs.

total_effect gives, per spell, what one unit receives over the whole spell, at the fixed reference in total_effect_reference: the caster has magic 30 (Isaac at level 1), the element at rank 0 (level 1–10) and a perfect stroke (quality 1, factor 1.5); the receiver has defense and magic defense 0, a neutral element and no weakness or shield; no random factor. kind is damage, heal, status or other; hp is the damage or healing in HP when there is one (else null); text (EN/ES) says how it adds up or what it does. The rules: the damage per hit is floor(floor((power + 30) × 1.5) × (0 + 4) / 4), except clouds, which hit with their raw power numbers.hits times; burn and poison add status.power every 60 ticks, floor((status.duration_ticks − 1) / 60) times, if the status lands (the unit's status pass counts the life down before each tick), and regeneration heals once more because its first one is at once; the status chance is status.chance × 1.5, at most 1. up_to marks a maximum: every shot or object lands (bursts and falling objects), or the unit stays where the spell reaches it. Normal poison only ticks while the unit moves or attacks. A dragon flies through a unit, goes on 192 px and comes back, so it hits a unit that stands still on every pass: numbers.passes_max at most, passes_typical in most spots, passes_min in the worst. An armor hits an enemy that stays within its pulse numbers.touches_max times with the power and numbers.aura_ticks_max times with status.power. A dance is numbers.hits_max hits of numbers.hit_attack (Isaac's attack at level 1, against defense 0). A whirlwind hits once per contact and only steers to units ahead, so it hits a unit again only if that unit comes back into its path. confirmed: false marks what the code read so far does not settle; since #256 no spell has it.

Each family has description (EN/ES): a sentence with no numbers on what it does, built from its data with a template per kind or variant and the effects of at least half its spells («some also…» adds up to three of the rest). What each spell does, worked out from its data and never written by hand, comes in two levels: tags, specific effects (damage, heal, protect, empower, haste, weaken, burn, poison, freeze, sleep, charm, pacify, immobilize, knock, capture, summon, movement, terrain), and types, their eight general groups (attack, heal, buff, debuff, control, summon, movement, terrain). The tags and types at the top of the file give the name (EN/ES), the rule and, for each tag, its type. The rules: damage if its total effect is damage (or switch_life); heal with heal in flags, a total effect that heals, a cure or regeneration status, or light_transfer; the status it applies, with every branch of a random status, gives the rest: a stat change up protects (defense, magic defense, evasion), strengthens (attack, magic, accuracy) or speeds up (speed, or less interval), and down slows (speed; all of it or a bubble roots) or weakens (anything else, weakness, virus, recoil, forget); burn and poison are burn and poison; sleep, freeze and charm, their own; no attacking and terror, pacify; berserk strengthens an ally and, cast on an enemy, counts as charm. knockdown and knockback are knock; capture traps, capture; kind wall, object or dragon, summon; variant transport, gather or self_cannon, movement; terrain or a terrain status, terrain. Holy Pulse applies no status of its own: it strengthens the allies and weakens the enemies. In each family, tags and types list its spells', the most common first, with spells = how many have it; spell_types gives each spell's.

Best spells

/data/best-spells.json says which spells pay off for the player, worked out from the data (evidence: static), not from playing. Each spell's effect is hp_expected: the total effect of /data/spell-families.json at the same reference, with burn and poison counted by their chance (for clouds, the chance it lands at least once over their hits). spells gives per spell its mp, chapter (the chapter in which Isaac has learned all its runes and can chain that many), stroke, reach_px (the larger of the cast range and the shot range), area_px (its radius, if any) and badges: per_mp, jump, easy and not_worth.

• rankings.per_mp: effect per MP at least twice its family's median (vs_family), or effect at least twice the median of the other spells of its family with the same MP (vs_same_mp).
• rankings.jumps: the next spell by MP of the same family and element, with effect ×2 or more and effect_ratio / mp_ratio ≥ 1.5.
• rankings.not_worth: another spell of its family and element (better) costs less MP and is as good in everything; when gains_only is not empty, the dearer one only gains in those numbers.
• rankings.easy: every spell, from the easiest stroke to the hardest.
• By situation, only spells that deal damage: grouped (with an area, by the effect on each unit inside), scattered (no area that also hits allies; by mp_per_kill = MP × casts to take the weak enemy's HP, then by stroke, then by reach) and boss (by the effect on one unit). The weak enemy (reference.weak_enemy) has the median HP of the unnamed units in the battles of chapters 1 and 2, at their level.

The stroke score (method.stroke) is an estimate of how hard a rune is to draw by hand, not a value of the game. For each shape the rune accepts (templates of /data/runes.json, 0..63 grid = one rune width), points closer than min_step to the previous one are dropped and the score adds: the length in widths, w_sharp per corner sharper than sharp_deg degrees, w_turn per full turn (the sum of turning angles / 360°) and w_against per width the stroke goes up or to the left. A rune takes its easiest shape (runes[].template, runes[].points) and a spell adds its runes plus w_extra_rune per rune after the first. The easiest quarter of the spells gets the easy badge.

Spells with rules of their own, by variant:

Spell scenes

/data/spell-scenes.json (also .md) maps every spell to graphics, sounds and actual bosses, with 90 unit appearances and 141 statuses. Each spell page offers caster, receiver, four facings, distance, stroke quality, selected outcome, replay and sound. Receiver affiliation follows targets; example outcomes/status application are user choices, not battle rolls. Transport and Flight have no receiver or outcome: their scene moves the caster to the destination.

• assets[id]: PNG, CAN/NCER/NANR and exact palette; cells holds [x,y,w,h] sheet rectangles and origins their anchor-relative positions. Empty frames still consume their time.
• sequences[].frames: [cell,ticks,dx,dy,rotation degrees,scaleX,scaleY]. Single-frame animations are retained. mode: 1 once,2 loop,3 ping-pong once,4 ping-pong loop; loop_start is the loop's starting frame. ticks and seconds retain original durations.
• units[].actions[action][facing]: sequence, own and fallback. Monsters without chant/cast actions use idle. launch_px positions the shot; boss_spells identifies actual battle use.
• spells[].graphics: role, atlas, sequences, palette, evidence and confidence. times_seconds converts spell time fields; distances remain px. Projectile travel is distance/speed, rounded up to a tick.
• sounds: audio, anchor (chant,stroke,rune,cast,release,shot,hit,status,death,vanish,capture,capture_close), offset seconds/ticks, condition and confidence. timing_confidence separates sound dispatch from example phase placement. Rune/stroke repeat per rune; hit per shot. Quality <0.85 uses KAKUNIN/INVOKE; ≥0.85 uses MENU_MAGIC/INVOKE2. Sound requires interaction.
• statuses[].overlay, popup, sounds and duration_seconds describe each status. /data/statuses.json also includes this as visual.
• Knockdown requires flag 0x800: 40 ticks grounded and 10 getting up. Push requires 0x400 and decelerates over 30 ticks. Defeat plays die, waits 30 ticks, uses puff 272 for monsters, then removes after 80. Resolved capture uses capture_timing: success closes at tick 2 and removes the unit at tick 33; failure closes/releases at tick 60. Book sequences 199/200 determine the end, independently of armed trap lifetime.

Walls (class 1) create ground structures, without a receiver or hit outcome. structure_timing preserves the 5 ticks between posts; targeting distinguishes line and circle. Elemental statuses apply on contact, not placement. The viewer allows adjusting line length.

Projectile orientation is in graphics[].rotation: the original artwork points upward and the ROM adds 90° to its travel angle. Trails inherit that angle; dark/light spin 16.875°/tick. The preview fixes the random initial phase to 0. The manifest has a revision to prevent browser reuse of earlier exports.

Spatial composition is illustrative, not a complete battle simulation. preview declares drawing speed (0.8 s/rune) and conventions; confidence/evidence distinguish decoded behavior from probable assignments. Follow-up extraccion/investigacion/visuals/SCENE_DISPATCH.md confirms chant/drawing sound dispatch, byte-7 status icons and Fallthing sound tables in code. Zero entries skip that sound. Other families have independent calls; fall and object_hit repeat per object, using a 20-tick descent as a preview convention.

visual_behavior distinguishes shared feedback (Holy Pulse: icon 11; Life Thread/Life Shine: icon 7), actor motion (Self Cannon: unit_motion, 2 px/tick, 12 px collision gap) and conditional statuses (Betrayal/Mutiny/Uprising: choices). dance (the six dances, 361–366) marks Isaac as the dancer: he walks to the receiver at approach_px_per_tick (2), dances beside it for numbers.duration_ticks (300; in the spell's record, as in /data/spells.json) once the gap is start_gap_px (12) or less, and hits on hit_ticks (9, 19, 30) of each cycle_ticks (43) cycle: 21 hits. The receiver does not dance. The element aura starts where Isaac stands (aura_origin); aura_pending says what is not decoded yet. caster_teleport (Transport and Flight) marks the caster's jump: departure flash on casting, arrival flash at arrival_effect_ticks (20) and position change at move_ticks (30), with no receiver or impact. Their probabilities are conditional on success; the viewer selects a branch without simulating a roll. own_graphic_confirmed describes dispatch in the original report, not whether shared feedback exists.

Blast/dragon composition and knockdown still require in-game verification. Phase synchronization, Missile's absolute phase placement, life donors and Self Cannon's self-damage are not fully reconstructed. Follow-up extraccion/investigacion/visuals/SCENE_RENDERING.md adds dragon_assembly (14 indexed parts, emergence 23+index and scales), explosion_assembly (main, ring and inward charging particles) and lock_timing (ticks 8/16/24). Dragon routing and preliminary Explosion positions remain illustrative. How each effect ends is in extraccion/investigacion/visuals/SCENE_ENDINGS.md: rain_assembly (the 6 spells with MagicEffectRain) gives 20 clouds, 10 drops with their alpha cycle (drop_alpha) and 10 splashes, and removed_after_hit_ticks (63) is when the owner deletes itself and takes everything with it. For the other blast and falling-object families, when the effect is removed is not decoded; the scene removes it 120 ticks after the impact. The 27 terrain spells carry terrain_scene:

• map and origin say on which game map and spot the scene stands, so the terrain the spell acts on shows;
• zone says when the zone is born: on the impact (hit), at each falling object (object_hits) or when the area appears (release);
• radius_px and lasts_ticks (1200) give its circle and its duration;
• prior, for the spells that only remove, is the earlier overlay the scene paints so you can see what they remove.

terrain holds each material's rule, the layer the game picks, the neighbour tile tables (tiles), each layer's sheet with its ticks per frame and the NHIT grid of each map used (details in extraccion/investigacion/terrain_morph/STATIC_REVIEW.md). sounds[].duration_ticks stops chanting at cast and drawing at each stroke end; *-sustain clips use ROM samples/instruments with a 3 s preview hold. Resume continues held notes with their current offset and remaining duration. None of these findings is emulator-validated.

Aiming a spell

/data/aiming.json says what the battle shows between the end of the chant and the cast, by the spell's targeting (see "Spells and runes"). It is read from the code (evidence: static), not measured in an emulator; confidence says how sure each point is. Positions are px of the bottom screen (256 × 192), times are ticks of 1/60 s and angles are degrees with 0 = right and 90 = down (y grows downward).

• Modes (modes). Each targeting has its icon (icon) and its way to confirm (confirm). arrow says whether it uses the arrow; range_graphics_3d, whether it draws something on the ground (circles or shade). direction draws nothing on the ground: only the arrow and the icon.
• Arrow (arrow, direction only: Fireball and the other shots). The picture image (32 × 56) points up. Its point pivot_px (15, 36), the centre of the ring, goes on Isaac's point (anchor: caster_point, his feet) and the picture turns around that point. The tip is tip_px (36) px ahead of Isaac and the handle tail_px (15) px behind, so the arrow comes out from under him. Drawing angle = atan2(dy, dx) in degrees + rotation_offset_deg (90), where (dx, dy) goes from Isaac's point to the stylus, turning clockwise on screen: the arrow always points at the stylus. The turn is free (turn_steps 4096 per turn), with no snapping to 4 or 8 directions. It does not stretch or scale with distance (scale 1) and is opaque (alpha 1). It is drawn under Isaac (layer: under_caster). Colours: the picture's own, the same for every element.
• When (direction_flow). The arrow appears as soon as aiming starts, pointing up (rest.end_offset_px (0, −10): −90°). Once the stylus touches the screen (anywhere), every tick the arrow points at the stylus and Isaac turns toward it in 4 directions (right, down, left, up, split at 45°). Lifting the stylus casts the spell from Isaac toward the stylus's last point, and the arrow and the icon disappear. There is no distance limit (range_limit: null): the shot travels its shot_range_px from /data/spells.json. Before touching, pressing the chant button (L, or R with the left-handed option) cancels: SE_CANCEL (effect 4) plays and nothing is cast; once touched, it can no longer be cancelled.
• Icon (icon). While aiming, the mode's icon (32 × 32, point at its centre) stays put on the screen at at_px: (20, 172), bottom left, or (236, 172) with the left-handed option, above the field. If the arrow points into that corner (between the angles of move_when_arrow_deg: 90–180 right-handed, 0–90 left-handed) it jumps to moved_at_px (236, 20 or 20, 20) so the hand does not cover it.
• Circle (circle_flow, targeting: circle). Outside the reach (cast_range_px from Isaac) the field is shaded with shade_outside_range (#525252, alpha 20/31). A touch outside the reach does not count; one inside sets the centre. Dragging picks the radius, from radius.min_px (5) up to the spell's radius_px; releasing casts with that centre and radius. The area is coloured by targets (area_colour_by_targets: red enemies, blue allies, yellow all; area_colour_other for the spells it lists) and with area_colour_at_max_radius once it reaches the largest radius. Shape (area): a 24-sided disc on the chosen centre, of the dragged radius, alpha 24/31. While the radius is below the largest it has four small triangles (handles) 4 px outside the edge, 5 px long with an 8 px base, pointing out and turned so that one points at the stylus; at the largest radius they go away. The shade outside the reach only shows before the touch.
• Instant (instant_flow). Any touch casts the spell; the chant button cancels.
• Line (line_flow, walls such as Fire Wall). The first touch has to land strictly inside the reach; it sets the start. A touch outside does nothing. From then on the end follows the stylus, at most the spell's max_length_px long. If the stylus leaves the reach, the end stops where the line from the start to the stylus crosses the reach's edge: the whole line stays inside. Isaac turns toward the stylus only before the start is set. Releasing casts from the start to the end (the same call as the arrow). It draws (graphics, colour #e6b552, alpha 28/31) an 8 px radius disc on each end and an 8 px wide band between them, sticking out 4 px past each end. The shade outside the reach always shows.
• Point (point_flow) and fixed circle (fixed_circle_flow) are the same code. The first touch has to land strictly inside the reach. Then the point follows the stylus and, if the stylus leaves the reach, stays on the edge in the stylus's direction. Isaac turns toward the stylus. Releasing casts at the point. point draws the reticle (reticle, 16 × 16 px at scale 1.5: 24 × 24 on screen, centred on the point, above the field) and no area. fixed_circle draws at the point a 24-sided disc of the spell's radius (radius_px, trigger_radius_px or ring_radius_px by class), always #ffa5a5 alpha 24/31 and without triangles, because the code draws it at the largest radius. It would only show the reticle with radius 0, which no spell has. The cast call also gets a fixed 20 px radius (cast_radius_arg_px); what it does with it is unknown. The shade outside the reach always shows.
• Unit (unit_flow). Any touch starts. A cursor follows the stylus; if the stylus leaves the reach, the cursor stays on the edge. Isaac turns toward the stylus. Every tick the nearest unit to the cursor is picked among those targets allows whose touch box holds the cursor. Box: in x, the unit's x ± (touch_box_by_unit[slug][0] + 4 px); in y, from the unit's y − ([1] + 4 px) to its y + (the unit's radius_px + 4 px). It draws a three-line marker (marker.lines_px, px from its point) in red #ff5252 on the picked unit, also for ally spells, or in yellow #ffff52 on the cursor when there is none. Releasing casts on that unit. With no unit it goes back to waiting for a touch, and the chant button cancels again. The shade outside the reach always shows.
• cross (a cross) is loaded for every mode but none shows it. numbers are digits from the same file that aiming does not use: they are the damage numbers' digits (see "Damage numbers").

Status effects

/data/statuses.json has the 141 status records; a spell's status.id points to one. duration_ticks is how long it lasts (0: it acts once) and caused_by, the spells that cause it. The strength of the ones that hurt or heal is the spell's status.power. key says what it does:

Each item of changes has a stat (attack, defense, speed, magic, magic_defense, interval = time between attacks, accuracy, evasion) and a mode: percent → stat × (1 + amount); flat → stat + amount; gap → stat + (100 − stat) × amount.

• Statuses do not stack: applying one again restarts its time. Stat changes, auras and curses do stack, and they multiply.
• Every frame stats are rebuilt from the unit's own, applying its statuses from newest to oldest, then clamped: none below 0; attack, defense, speed, magic and interval at most twice the unit's own (interval at least 1); magic defense at most 99; accuracy and evasion at most 150 over the unit's own.
• Isaac and bosses are immune to berserk, charm, terror and forget.

Combat

Battle logic runs at 60 ticks per second. /data/combat.json has the constants from the code; each unit's own are in /data/units/<slug>.json.

Normal attack. gap = distance between centres − both units' radius_px.

• It starts a swing at gap < attack_reach_px and keeps it while gap < attack_reach_px + attack.reach_pad_px. With attack_reach_px 0 it never attacks; when chasing it stops at attack.stop_gap_px.
• Rhythm: wait attack_interval_ticks, play the attack animation; the hit or the shot comes out attack_strike_ticks after it starts; when the animation ends, wait again.
• Melee hit: random(0..100) + accuracy − evasion ≥ 100. Ranged: random(0..99) < (accuracy − evasion) mod 256 (a negative difference always hits).
• Damage: d = floor(attack / 2) − floor(defense / 4); if d ≤ 0, nothing. With an attack_element: ×½ against the same element, ×1.5 against the opposite one (opposite). Shots do ×1.5 to flying units. Finally floor(d × (128 + r) / 128), with r a random integer from −10 to 10.

Shots (the unit's projectile_type, projectiles in /data/combat.json): they leave from shot_start_px for the facing, straight towards where the target's centre was, at speed_px_per_tick, without following it. They travel at most attack_reach_px + reach_pad_px. They hit the nearest opposing unit within shot_hit_radius_px + its radius and do not go through. High obstacles stop them; water and pits do not. on_hit: stick stays stick_ticks on the target, vanish disappears. On a miss they bounce back and fade in shot_fade_ticks.

Sight. Every search_every_ticks a unit looks for enemies within max(sight_px, search_px) and chases while gap < sight_px. Mission scripts often change sight_px.

Spell damage. With the power at cast P (see "Spells and runes"), on each target:

1. Element: no element, P; same element as the target, −floor(P / 8); opposite, floor(3P / 2).
2. If above 0, × (100 − magic defense) / 100 (magic defense ≤ 99); if 0 or less, halve it (the same element heals about P/16).
3. × (128 + r) / 128, with r random from −10 to 10.
4. If the target has more weakness than halving statuses for that element, ×2; with more halving, ×½. Spells with heal add P with no element, defense or randomness.

Element against element (elements in /data/combat.json). The unit's element (null: no element) is compared with the hit's. elements.spell_table is step 1 above, by the spell's element (rows) and the target's (columns): -0.125 is the same element, which heals; 1.5, the opposite one; 1, the rest, and always when either side has no element. A fire spell heals a fire creature instead of hurting it, whatever its magic defense. No unit is immune to an element's damage.

• Normal attacks (elements.attack): ×½ against the same element, ×1.5 against the opposite one.
• Chance of the spell's status (elements.status_chance): ×½ if the target has the spell's element, ×1.5 if it has the opposite one. The spell's element is what counts, not the status's. No status has an element exception: a fire creature can be burned and a water one can be frozen, at half the chance when the spell is of its element.
• Damage dealt by statuses (elements.status_damage): burn is fire and poison is dark, and both go through steps 1 to 4. On a fire creature, each burn tick heals it instead (1 or 2 HP at power 10); on a water one it does ×1.5. Freeze carries water but deals no damage.

Bosses. Only each battle's boss unit casts spells (casts_spells in its file), when its script tells it to; there is no range check. It has its own MP (its mp stat), pays each rune at rank 0, and its power is power + magic, with no quality or rank.

Isaac's element levels. They start at growth.start. They only change on a battle's results screen. With old the level before the battle, c the spells of that element cast in it (one per spell, its last rune's element; cancelled chants don't count) and fav the element cast strictly the most (none on a tie):

• old ≤ low_band_max: +low_band_many_gain if c ≥ many_casts, +1 if 1 ≤ c < many_casts; +1 more if it is fav.
• old ≤ mid_band_max: +1 if c ≥ many_casts; +1 more if it is fav.
• Otherwise: +1 only if it is fav, and then the opposite element loses 1 if its level was decay_min or more.
• Then each level is clamped to level_min–level_max. The level only changes the rank (floor((level − 1) / 10)), and the rank only changes the runes' MP, the power (×(rank + 4) / 4) and the status chance (×(rank + 4) / 4).

HP bar

hp_bar in /data/combat.json is the HP bar the game draws over every unit on the field, all the time. It is made of solid rectangles, with no picture (drawn_by_site: true). Sizes are in px from the unit's point (x, y in /data/maps.json) raised by its head height, head_px in /data/units/<slug>.json: a rectangle with left_px and top_px spans width_px × height_px from (x + left_px, y − head_px + top_px).

1. frame: the frame, in frame.color, under everything. What the bar does not cover shows that colour.
2. bar: the HP, floor(width_px × HP / max HP) px wide, with the effective max HP (after change_max_hp). Its colour, color_by_side: player for Isaac's side, enemy for enemies, ally for allies and characters on no side.
3. change: for change.ticks ticks after the HP changes, another bar at the same place and height sits between the frame and bar. Only the last change counts.
   • After damage, bar shows the new HP and the one under it the HP before, in damage_color.enemy on enemies and damage_color.other on the rest.
   • After healing, bar shows the HP before and the one under it the new HP, in heal_color.

The bar does not rise with units lifted off the ground. A defeated unit keeps it through its die animation and the 30-tick wait, and loses it when the puff it vanishes in starts (hidden_from: vanish).

Enemy marker

/data/enemy-marker.json is the small letter the game draws just left of every enemy's HP bar. It marks the side: only enemies carry it; Isaac, his squads and allies carry none (carried_by).

• Picture. letters: "E" with the game in English, French or Spanish and "F" in German (languages; the game takes the console's language and any other counts as English). Each is 8 × 8 px (size_px), pink and white, not animated.
• Position. From the unit's point (x, y in /data/maps.json) raised by its head height (head_px): the picture's pivot_px goes at (x + offset_px[0], y − head_px + offset_px[1]), that is (x − 14, y − head_px − 6). It sits gap_to_hp_bar_frame_px (5 px) left of the HP bar's frame. Scale 1, opaque, in front of its unit. Example (example): on a Misty Mush (head_px 14) the picture spans (x − 18, y − 24) to (x − 11, y − 17).
• When it shows. While the enemy is on the field and on screen, all the time; it does not depend on selection or damage. Every unit has an appear counter from 0 to fade_max (127): it enters the field at 63 and goes up 1 per tick to 127; while the unit blinks as it appears, the letter stays steady (blinks: false). An enemy with the hidden status goes down 1 per tick and the letter goes when it reaches 0. When it dies, the letter stays during the vanishing puff, even though the HP bar is no longer drawn, and goes when the unit is removed.

Mana crystals

Mana crystals (MP pillars) stand on the field in many battles. Each battle in /data/maps.json has crystals: the position x, y in map px and owner, who holds it when the battle starts (player, enemy or neutral). The rules are in mana_crystals of /data/combat.json, in px and ticks of 1/60 s:

• It is a solid circle of radius_px that stops walking and flying units and shots. It has no HP: it only changes hands.
• Capture. Every tick, each unit that can capture (can_capture_crystals in /data/units/<slug>.json), alive and within capture_radius_px, adds gauge_per_unit_per_tick to the gauge. When nobody adds, the gauge drops gauge_decay_per_tick. Over capture_gauge.neutral (nobody's crystal) or capture_gauge.owned (a held one), it goes to the side taking it, and the gauge goes back to 0.
• Blocking. Nobody takes it while a unit of its owner is within presence_radius_px. A crystal of nobody does not move on either while units of two sides are that close.
• Sides. sides_that_capture: in the story only Isaac and his squads take crystals; the enemies never take or defend them.
• Healing. Its owner's units within heal.radius_px recover heal.hp HP every heal.every_ticks while they are hurt.
• MP. Every mp_regen.every_ticks, Isaac's MP rises by mp_regen.base_mp, plus mp_regen.mp_per_crystal for each crystal he holds, plus 1 for each earlier rise in a row without chanting, up to mp_regen.streak_max. Without crystals he still recovers: the base and the streak. After a chant the first rise comes after mp_regen.chant_wait_ticks; with crystals, after chant_wait_ticks − chant_wait_cut_ticks_per_crystal × crystals, at least chant_wait_min_ticks.
• Picture. pictures has one picture per owner, of picture_size. Its top-left corner goes at the crystal's point plus picture_offset.
• Capture bar. capture_bar describes the bar the game draws with rectangles, not with a picture. drawn_by_site is true because the site redraws it from these rules:
  • It is height_px tall and sits above_px above the crystal's point.
  • The background, in colors.background, starts at background.<neutral|owned>.left_px and is width_px wide.
  • Over it, from the same edge and in colors.remaining, goes what is left: (capture_gauge − gauge) / remaining_divisor px, with the gauge of the last push.
  • Each push shows it for fade_ticks ticks, with opacity ticks left / 2 out of alpha_max.
• Missions. The objective "Purify the Mana Crystals!" is won when they are all the player's (all_crystals in conditions).

Battle camera

/data/camera.json has the constants from the code, in px of the map and px per frame (60 a second). The view is view_px (256 × 192): the bottom screen, the touch screen, where the game puts the main graphics engine (3D and the map's backgrounds). The top screen is covered by "Top screen" below.

• Position. It is the view's top-left corner. It goes from 0 to each map's view_x_max_px and view_y_max_px in maps (the map's size minus the view); every move is clamped to those limits. They are the world bounds (world_bounds.always): there is nothing outside the map, so the camera stops on each axis when it reaches the edge and keeps going on the other axis if it still can. The game has a flag to lift them, but only the camera's init writes it, with 0; nothing turns it on. Units and effects are drawn at position on the map − camera position, in whole px. A unit more than 40 px outside the view (unit_draw_margin_px) is not drawn.
• It follows nobody. The camera does not move by itself when Isaac walks, and it does not follow spells, targets or captured creatures. Only the four cases below move it, with no smoothing or dead zone: constant speed and an exact arrival.
• At the start of a battle it centres Isaac: it puts him at battle_start_isaac_at_px (128, 96) of the screen, clamped to the limits.
• D-pad. While held, the view moves dpad.px_per_frame (7) that way, or dpad.diagonal_px_per_frame_per_axis (4.9) per axis on a diagonal. With the left-handed option, A, Y, B and X act as right, left, down and up. There is no automatic return: the view stays where the player leaves it. It does not move while a spell is being prepared or chanted, or when the mission turns the D-pad off.
• Chant. When L is held (R with the left-handed option) and Isaac is outside the screen rectangle chant_recentre.isaac_rect_px (x 20–236, y 20–172), the chant waits and the view moves toward him at chant_recentre.px_per_frame (10) in a straight line, until he is at target_px (128, 96). With less than jump_below_px (10) to go, it jumps there. It stops early if Isaac enters the rectangle or a map edge stops the view. During the chant it keeps correcting the same way.
• Missions. A script reads the view's position and moves it in a straight line to (x, y) at speed × script_pan.px_per_frame_per_speed_unit (speed / 4) px per frame; missions almost always use 24, that is 6 px per frame. It reports when it arrives. It does not go back to Isaac by itself. If the target is past the limits, the view stops at the edge.
• Shake. Big Drop moves the view by shake.big_drop: ±2 px horizontally, switching side every 2 frames, for 30 frames, then back to 0. The earthquake effect (earthquake_unused, three phases) is in the code, but no spell uses it. The shake does not change the camera position, only what is drawn.
• Top screen (top_screen). It depends on the chant state. In states 0, 1 and 2 (no chant) it shows the minimap, which places four marks from the view's position. While drawing (states 7 and 8) it shows the rune list: a rune_grid of 6 columns, one per element, by 3 rows, one per rune level, next to a bar of Isaac's MP. When the chant gives a spell (state 9) it shows that spell: its number, name and description. It goes back to the minimap as soon as the state is 0, 1 or 2 again. That unlearned runes show as "?" was seen in the game, not traced in the code.
• Backdrops. Every map layer gets the view's position. BACK (the map) and ANIM use it as it is. NORM multiplies it by speed_factor (PARM / 256): with mode 3 or 4 it is a backdrop behind the map (sky, sea, lava) that moves at that fraction; with mode 1 it goes in front. On a map with ANIM, the NORM layer is not shown (shown: false). Reading the code did not confirm whether a backdrop repeats when it reaches its edge.

Damage numbers

/data/damage-numbers.json says how the number that appears over a unit when its HP changes is drawn. It is read from the code (evidence: static); the colour, the place, the duration and the hundreds slip were also checked in the emulator with Fireball in the first battle. confidence says how sure each point is. Positions are screen px (y grows downward) and times are ticks of 1/60 s.

• When (shown_when: hp_changes). Every time a unit's HP changes, from a spell, a normal attack, a shot, a status, the terrain or a crystal's healing (sources), on any side (Isaac, his squads and the enemies alike). It shows the absolute value of the change (value.shown), with no sign, up to value.max (9999). It is the damage worked out, not the HP the unit had left: a hit of 347 on a unit with 20 HP shows 347. A change of 0 shows nothing, and a miss does not change HP, so it shows nothing either.
• A slip of the game at 1000 and above (value.drops_zero_hundreds). The digits are picked like this (value.digits_drawn): the thousands if the value is over 999; the hundreds only if the rest (value mod 1000) is over 99; the tens if the rest (mod 100) is over 9 or a digit was already drawn; and the units. The hundreds step does not check for a thousands digit, so a 0 in the hundreds is lost: 1050 shows "150", 1005 "105" and 2000 "200". To draw it as the DS does, copy that slip.
• Digits (font). Only the digits 0–9, in 8 × 8 px cells with their point at (4, 4), the centre. They are the same in the four languages. The pictures in kinds.<kind>.image are 80 × 8 strips with digit d at x = 8 × d.
• Colour (kinds). It depends only on the sign, not on the side or the element: damage (HP lost) is pink-red #de1852 with a white outline; healing (HP gained) is green #18bd73 with a white outline. Damage to Isaac or an ally looks the same as damage to an enemy.
• Where (place). The number's centre goes on the unit's point (its feet) plus that unit's radius_px downward (/data/units/<slug>.json). It is worked out every tick, so it follows the unit if it moves. It is not drawn while the unit is not drawn (more than 40 px outside the view).
• How the digits are laid out (layout). With n digits, the centre of digit k (from 0, left to right) is at x = −(3n − 3) + 6k from the number's centre, and y = 0. They are 6 px apart (advance_px) although each cell is 8 wide, so the white outlines overlap: each digit is drawn over the one before.
• Motion (timing). None: it does not rise, bounce, scale or fade. It appears whole, stays lasts_ticks (40, two thirds of a second) and disappears at once. If the hit kills the unit (timing.killing_blow), the countdown stops while it dies: the number stays until the unit vanishes in its cloud (about 190 ticks for the first battle's Misty Mush).
• Several at once (stacking). Each unit has one number. If its HP changes again before it goes, the new value replaces it and the 40 ticks start over; numbers are not added up or stacked. Numbers of different units are independent.
• Layer (layer). It is sorted with the rest of the field as if it were 20 px lower than the unit: it is in front of the unit and of whatever is less than 20 px below it.
• Sound. Damage (not healing) plays damage_sound (SE_UNIT_DAMAGE, effect 50).
• Example (example). Fireball takes 347 from a Misty Mush (radius_px 6): three pink digits with their centres at (−6, 6), (0, 6) and (6, 6) from the mushroom's feet, for 40 ticks. example.image is that number already put together (20 × 8), with its centre at point_px (10, 4).

Chant screen

/data/chant-screen.json has the chant screen's graphics, read from the code (evidence: static), not measured in an emulator. Positions are screen px (256 × 192), times are ticks of 1/60 s, and alphas go from 0 (clear) to 1 (opaque; the DS uses 0 to 31).

• When. The circle and the dimming layer appear when drawing starts and vanish at once when the drawing ends, together with the strokes. They do not follow the camera: they stay put on the bottom screen.
• Dimming layer (dim_layer). A rectangle over the whole screen, colour colour (#525252), alpha-blended over the field. Its alpha starts at alpha_from (10/31) and rises 1/31 every step_every_ticks (2) ticks up to alpha_to (20/31): it gets there in 20 ticks. This is what tints the field; the circle does not tint it.
• Circle (circle). The picture image (256 × 192, its own orange palette) goes with its point pivot_px (128, 79) on centre_px (128, 96); the drawing fills art_box_px of the picture, so its centre lands on (128, 103) of the screen. It is drawn opaque (alpha 1) above the dimming layer. When it appears, for appear.ticks (30) it grows from almost 0 by scale_per_tick (0.0332) per tick and turns turns_per_tick (1/30 of a turn per tick): one full turn. On tick 31 it is at scale 1 and angle 0, and it stays still. The direction of the turn is not confirmed. fade_unused is a spinning fade-out that is in the code but the game does not use.
• Stroke (stroke). Each stroke is a ribbon width_px (8) wide around the stylus points (one per tick, up to max_points), with round caps reaching cap_px (4) past the first and last point. It is painted with the texture texture (32 × 32: rim yellow edge, core white centre) shrunk to the ribbon's width: the texture's left half is the start cap, its right half the end cap, and the middle columns stretch along the stroke. The texture colour is multiplied by the stroke colour (per channel, in 0..31: (texture + 1) × (stroke + 1) / 32 − 1) and alpha-blended.
• Stroke colour. While drawing it is white and opaque: the texture shows as it is. When a stroke is recognised as a rune, over rune.ticks (11) ticks each channel drops by step31 per tick down to its element's colour (by_element, in 0..31) and the alpha drops from 31 to 20 (alpha_to); it stays like that. A stroke that is no rune (not_a_rune) stays white and loses 1/31 of alpha per tick down to 1/31 in 30 ticks.
• Rune list (rune_list, top screen, while drawing). Over the background background, which already has a "?" in every cell and the MP bar's track, go the six element icons (elements) and one 32 × 32 picture per learned rune in its cell (cells: column = element, row = level). A rune not learned draws nothing, so the "?" shows. A learned one Isaac cannot pay with his current MP shows no_mp (an X) instead of the rune. preview is the list with all 18.
• Numbers. Each rune that can be paid carries its MP cost, cost.digits (2) digits at cost.offset_px (18, 18) from its cell's corner; the cost is mp_per_rune of /data/runes.json for the chant's next rune. Isaac's current MP goes with 3 digits at mp.at_px (217, 45). The font of those digits is not in this data.
• MP bars (bars). Two 64 × 64 pictures (grey and yellow) with their point pivot_px (29, 64) on at_px (224, 155): they grow upward and, full, are full_height_px (88) tall. Both follow Isaac's MP; which one is in front is not confirmed.
• Sparkle (sparkle). A strip of 32 × 32 frames with their length in ticks, placed over the cell of the rune just drawn.

Battle end

/data/battle-end.json says what the DS shows from the moment a battle is decided to the end of the results screen. It is read from the code (evidence: static), not measured in an emulator; confidence says how sure each point is. Screen px (256 × 192 per screen), ticks of 1/60 s.

• Outcomes (outcomes). A mission's trigger ends the battle with one of four actions (action_id, the action number of the mission scripts). Each one sets the word the field shows (word), the song (song) and whether the results screen follows (results_screen). GameClearStart (3) is a win: WIN and song 11. GameOverStart (2) is a defeat: LOSE, or TIME OVER (word_when_time_limit) when the trigger that fired was the time limit. GameLostClearStart (5) shows LOSE but counts as a win. GameEvenStart (6) is a draw: DRAW. All but the win play song 12.
• The battle stops (battle). From that tick no unit moves, thinks or attacks and no trigger runs; the units are still drawn. There is no victory pose. A chant in progress is cancelled and its sound (stops_sound, SE_MAGIC_EISHO) stops. The battle waits settle_ticks (30) and until the effects in flight are over.
• Banner (banner). Then the song starts and the banner runs, on the bottom screen, fixed to the screen at at_px (128, 96); each picture of words (one per language, from the console's language: French, German, Spanish, any other one English) goes with its pivot_px on that point.
  1. For ticks.circle_only (31) only the chant's magic circle and dim layer show, entering as when Isaac chants (/data/chant-screen.json, circle and dim_layer). The word is not drawn yet.
  2. The word appears, opaque, for ticks.shown (31) and stays ticks.held (61) more.
  3. Then the word goes at once (the code means to fade it, but its alpha starts at 0; seen in the emulator), and for ticks.circle_leaving (31) the circle leaves (circle.exit): it turns 24° per tick and its alpha drops 1/31 per tick.
  4. At ticks.total (154) the circle and the dim layer go at once.
• Then. With song 12 the battle also waits for that song to end (waits_while_song_plays; it plays once, 4.287 s), so a defeat lasts longer than a win. Last, both screens fade to black (fade_out, 30 ticks). After a win comes the results screen; after a defeat or a draw, Continue (section "Game rules").
• START (banner.start). Before play the battle shows START the same way, unless the mission calls native 46 first. The first battle (qc01_m001) calls it, so it starts with no banner; its New Game+ version shows START.

Results screen

results. It only follows a win. Song results.song (10, SEQ_QUESTCL) starts with it and plays through all of it. It has up to four phases in the order of results.phases; a phase with nothing to show is skipped. Each phase fades in from black and out to black (30 ticks). After the last one comes the chapter title, if one is pending, or the world map.

Experience (results.exp), always shown. previews has both screens put together from these fields, in English and Spanish, without the text. The game's menu font is not decoded: texts are drawn with fixed 7-px characters from their point, in a font of your choice.

• Top screen: top.background (it already has Isaac's portrait, the LV box and three dark rows). Isaac: the LV label at isaac.lv_label_at_px (the _fr_es one in French and Spanish), his level as %2d at level_text_at_px, the EXP bar at exp_bar_at_px (bar_frame_64, then bar_back_64, then bar_fill stretched to exp_bar_fill_px (62) × EXP / EXP to the next level). Each squad of the team, in roster order, at most 3: its unit's icon at squads.icon_at_px, the plate, its name and level and its bar at the offsets of squads from the icon (bar 46 px, bar_frame_48 and bar_back_48). The element levels are not on the top screen.
• Bottom screen, page 1 (bottom.pages 1): the four bars at their at_px, and the texts: clear_time the battle time in seconds (at most its time limit) as hh:mm:ss; defeated the kills; survival the squad monsters alive × 10000 / those deployed, as %3d.%02d%%, or ---.--% with no squads; exp_pool the EXP still to give, which counts down.
• Bottom screen, page 2 (bottom.pages 2, 192 px further down): the element radar. The six element icons at radar.icons, and two translucent hexagons centred on radar.centre_px, one vertex per element (top light, upper right fire, lower right earth, bottom dark, lower left water, upper left wind). Red: radius floor((level + 10) × 68 / 50); green: floor(rank × 10 × 68 / 50), rank floor((level − 1) / 10) + 1. The green one is drawn in front of the red one (seen in the emulator); their alpha is not decoded.
• Timeline (waits_ticks 30, 60, 30, 60):
  1. Wait 30 ticks.
  2. Count-up, every tick: step = max(1, floor(pool / 80)), pool − step, and Isaac and every squad each get step. Sound count_step (18, SE_KASAN) every tick; each level gained plays level_up (19, SE_LEVELUP) and shows level_up ("UP!", its frames move it by dy_px) at Isaac's level_up_at_px or on the squad's icon. Bars, levels and exp_pool change every tick. At 0 the Next button shows and the screen waits.
  3. Wait 60 ticks, then page 2 scrolls up into view in 64 ticks (3 px per tick).
  4. Wait 30 ticks, then the element levels go from the old to the new ones (growth rule in "Game rules") in 30 ticks, the hexagons redrawn each tick; element_step (20, SE_ZOKUSEI) plays at 0, 10 and 20 ticks. The Next button shows and the screen waits.
  5. Wait 60 ticks and fade out.
• Input. The Next button (next_button, by language) is at (232, 168), or (24, 168) with the left-handed option; it fires when the stylus is lifted within 20 px of that point. A new press of A, B, X, Y or the D-pad also counts as Next. During the count-up any touch or one of those buttons gives the rest at once (each member gets ceil(pool / members), a quirk of the game) and skips that Next. A touch during the scroll jumps to page 2.

Items and monsters (results.getting): one screen per item found, then one per monster captured, in the order the battle got them. Bottom screen: the background (item or monster), the title text (70 "You found an item!" or 75 "You captured a monster!", centred at x 128, y 24), the found row at found_row_at_px (its background button_images 11 for items, 10 for monsters; icon, name 16 px to the right, LV and level), and the two option buttons buttons.options (104 × 48, texts 71/72 or 76/77). "Add" adds it to the list; with the list full the title becomes 73/78 and Next opens the list (item_list/monster_list, 6 rows 18 px apart, list_images, page arrows 30/31) to pick one to replace; equipped items and monsters in a squad can't be picked. "Throw away"/"Let go" asks with buttons.confirm (YES 8, NO 9). Touch only; a button fires when the stylus is lifted inside it. The top screen shows the item's name and description (item_top, item_top_window).

New magic (results.magic): one screen per new spell, spells learned first and then the ones only seen (their runes show as "?"). Bottom: background and a row at row_at_px (32, 76): bar coloured by element (images 9–14), %03d: number, name 32 px right, runes at 132, 152 and 172 px (images 15–32, "?" 34). The top screen shows the spell as the battle's top screen does. Next button or A/B/X/Y/D-pad goes on.

/data/battle-end.md has the same data as tables.

Title screen

/data/title-screen.json is the menu that follows TOUCH TO START: the logo above and five buttons below. It is read from the code and checked in an emulator (evidence: static_and_emulator); confidence says how sure each point is. Screen px (256 × 192 per screen, from the top-left) and ticks of 1/60 s.

• Backgrounds. top.background already holds the logo and "©TAITO CORP. 2005, 2006"; bottom.background the sky, Isaac on the hill, the staff and the birds. Both go at (0, 0) and nothing moves: the birds are painted.
• Buttons (buttons, in order: New Game, Load Game, Multiplayer, Wi-Fi Connection, Hand Settings). Each one is the panel panel (128 × 24) with its text (label, en, es, fr, de) centred at label.offset_px (64, 4) from its corner. images has the finished button in each language, captured from the emulator: the menu font is not decoded. The game picks the language from the console's (French, German, Spanish; any other one, English).
• Entry (entry). When the menu appears both screens brighten from black in 30 ticks (fade_in) and, at the same time, each button moves in a straight line from from_px to to_px in 30 ticks: New Game and Multiplayer from the left, Load Game and Wi-Fi from the right, Hand Settings from below. The step per tick is step_px, truncated as the game does (entry.position), so New Game ends at x 29 and Multiplayer at x 40, 1 px short of table_to_px. Touches don't count until all of them stop.
• Touch (press). Touch screen only: the D-pad and the buttons do nothing here. A touch that starts inside a button (hit_box, the edge not included) marks it; while the stylus stays inside, the button is drawn 2 px right and 2 px down, and it goes back 1 px per tick once released. Lifting the stylus inside chooses it: press.sound (3, SE_KETTEI) plays and the other buttons stop responding. There is no cursor or cancel sound.
• On choosing (choose). The buttons don't leave: both screens fade to black in 30 ticks and the game goes where does says. New Game starts the prologue. Load Game opens the load screen even with no save: its three slots say "No Data". The menu never disables a button; a disabled one would have grey text (label.colour_bgr555.disabled) and not respond.
• Music. The song music (21, SEQ_DM_TITLE) is started by the title demo, before TOUCH TO START, and the menu doesn't start another. Touching TOUCH TO START plays 2 (SE_CURSOR), fades to black in 30 ticks and stays black about 57 while the menu loads.
• Idle (idle). Left alone nothing changes and it doesn't go back to the demo.
• Hand Settings (hand_settings). It doesn't leave the menu: the five buttons go back to their from_px in 30 ticks, Hand Settings returns to its place, and the question ("Left/Right handed?", question) and the two hands (hands, from chr/select_hand.can) come in. Touching a hand plays 3, saves 1 for the left one and 0 for the right one, and the menu comes back. Which value means left-handed is not confirmed.
• On the DS this screen has no Options or Quit.

/data/title-screen.md has the same data as tables.

Characters

/data/characters.json lists the 19 characters who speak in the story, with their name, how many lines they have (lines) and faces: one picture per expression, in the game's order. The story scenes use these portraits through /juego/data.json (see "Scenes").

Battle maps and battles

/data/maps.json lists each battle map: the full image, the game's minimap, and its battles. A battle has its number (battle), the story missions that use it, and the units on the field when it starts:

• uid and unit (the slug in /data/units.json) say who it is.
• x, y is its position on the map. With the sprite's origin on that point, units stand on the walkable ground of the map.
• level, and named: true for story characters (bosses and allies), false for regular monsters.
• orders: what it does on its own from when it enters the field (see "Unit orders in battles").

Each mission in missions also has objective (the text the game shows), conditions (how it ends: result victory, defeat, defeat_passed —a defeat that counts as passed— or draw, when trigger is met: no_enemies, boss_dies, isaac_dies, time (value in seconds), all_crystals, no_crystals, crystals_held (value crystals), isaac_reaches_area, boss_reaches_area, spell_cast (value = spell id), chest_opened, capture, draw…), time_limit_s (3600 when it sets none) and music (the song's n in /data/audio.json). When a mission has several battles, the list covers them all.

chests are the battle's chests: position x, y and odds, what it can give (item from /data/items.json, chance and the chance of each level in levels).

seals are the appear seals on the battle's floor: point x, y and units, the indexes in units of the hidden units that stand on it. How to draw them is in "Appear seals".

animation is set on the maps the game animates: falling snow (tile set ac03, 8 frames of 11 ticks) and running sand (ac04, 4 frames of 7 ticks). Each frame lasts one tick more than the value in the file: the game's clock counts down to 0 and changes frame on the next tick. base is the map without that layer; frames holds the frames stacked top to bottom, each the size of base and transparent where the layer is empty. Draw frame i over base for ticks[i] ticks of 1/60 s, in a loop. image is base with the first frame. On other maps animation is null.

decorations are the game's objects drawn over the map: bridges, tree tops and others. Each has its point x, y in map px, alpha (opacity 0 to 31) and height: the game draws them in order of y + height. frames is a strip of frames of frame_size, stacked top to bottom; origin is the point within each frame. Frame i shows for ticks[i] ticks, in a loop; with one frame the decoration is still. sprite groups those that share a picture.

lava is set on the magma maps (025–028, 044, 305): the lava glows because the game changes the colours of one row of its palette. mask is a picture the size of the map: its red is that row's colour (1–15) at each pixel, and 0 outside the lava. Frame i paints those pixels with palettes[i] (16 colours #rrggbb; 0 is unused) for ticks[i] ticks, in a loop. Frame 0 is the map's picture.

terrain is the map's collision and terrain, in map px (shapes may sit off the edge). There is no grid: units are pushed out of shapes every frame.

• boxes (centre x, y ± half_width, half_height) and circles (x, y, radius), each with its kind:
  • high_obstacle: stops walking and flying units and shots. low_obstacle: walking units only.
  • Zones, for walking units only (flying units are never affected): magma and damage_floor deal 50 damage every 60 ticks (fire and no element); ground the same, only when a spell heated it; ford half speed unless frozen, puts out and blocks burns; ice nothing, half speed when a spell melts it; bog half unless dried; sand nothing, half when turned to swamp; quicksand pushes 0.25 px per tick towards push.
  • The 50 damage is multiplied by (118 + random(0..20)) / 128; a unit of the same element heals 6 and one of the opposite element takes 75. Water units ignore the ford and melted-ice slowing; earth units ignore bog, sand and swamp slowing and the push.
  • event_area (with its number area): missions ask whether units are inside; it blocks nothing.
• squad_starts: where the player's squads appear. A squad's units are placed at that point plus team.formation_px from /data/rules.json.
• Terrain spells (terrain in /data/spells.json) change how zones behave inside a circle for 20 s; they do not change the shapes.

terrain_effects lists the zones with an effect on each map (kind, plus the push directions of quicksand). The full rules are in terrain of /data/rules.json:

• effects says what each kind does to a walking unit inside it: push_px_per_tick, speed_multiplier, or damage every every_ticks with its element. spared_elements are the elements spared its slowing or push, and altered is the effect while a terrain spell changes it (heat, harden, swamp, dry, freeze).
• damage: a unit of the same element heals same_element_heals_fraction of the damage, one of the opposite element takes opposite_element_multiplier, and the result is multiplied by a random value between the two in random_multiplier.
• flying_units_affected is false, and sides_affected says Isaac, his squads and the enemies are treated alike.
• The animated map layers only draw: the running sand matches the quicksand zones, the snow has no zone of its own and the lava is magma.
• Each unit has terrain_spared in /data/units/<slug>.json: all if it flies, the kind whose slowing or push it ignores, fire_heals if fire terrain damage heals it and fire_x1.5 if it takes 1.5 times.

Appear seals

Some story battles draw hexagram seals on the floor at the points where enemies appear (98 seals in 34 battles; battle 1 has six, one under each Misty Mush). /data/appear-seals.json has the pictures, the rules and, in battles, each battle's seals with the units that stand on them; seals in /data/maps.json has the same points. Map px, ticks of 1/60 s, alpha out of 31 (opacity = alpha / 31). It comes from the game's code, and the colours, the depth, the blink and the light column were checked in an emulator on battle 1.

• When. Every seal is on the floor from the start of the battle to its end. It does not react to the units: nothing spawns from it and nothing changes when a unit appears on it.
• Picture. seal.image is a strip of 32 × 25 frames, left to right base, fire, wind, water, earth, light. Put the frame's pivot (16, 12) on the seal's point. The seal is drawn under every unit.
• Base. Frame base (grey), always opaque.
• Colour layer. One colour frame over the base, starting with fire. Every step_ticks (4) a step counter goes up; the layer's alpha is alpha_by_step[step − 1] (1 up to 30, then down to 2). After steps_per_color (59) steps, color_ticks (236), it passes to the next colour in colors, and from light back to fire. So the seal slowly glows and fades in fire (yellow-orange), wind (green), water (blue), earth (orange) and light (yellow).
• Size. The seal does not change size (scale 1).

A unit appearing. A hidden unit comes out when the mission's script makes it appear, on its own point (in battle 1 that is a seal) or on another. Nothing sounds. Two things happen at once, from tick 1:

• Blink. A counter goes from counter_from (63) to counter_to (127), one per tick. While it rises, the unit is drawn only when counter & 2 is not 0: 2 ticks shown, 2 hidden, for 64 ticks. Then it stays opaque.
• Light column. column.image holds two 32 × 40 frames with the pivot (16, 32): back, drawn behind the unit, and front, drawn in front of it. Put the pivot on the unit's point moved down by its radius (radius_px in /data/units/<slug>.json), with alpha 16. Both mirror horizontally every other tick (mirror_frames). For ticks 1–29 their height is t / 30 of the full height, growing up from the pivot; from tick 30 they are full size and their alpha is 16 − floor(0.4 × (t − 30)); after tick 70 they are gone. The column follows the unit.

World map

/data/world-map.json describes the map Isaac travels between missions. picture is /juego/mundo.png; positions are pixels of that picture.

• places: the 44 places, with id, x, y and neighbors, the places a path joins to it. region is its position in regions: the name and description the game shows (name, description, in en, es, fr and de); several places share a region.
• availability_group (0 to 15) is the switch that enables the place, and unlock_flag the flag of /juego/data.json that turns it on. According to the code, a place is enabled when its flag is on, and a path when both its places are.
• paths: the 50 paths, as pairs of id. They are straight and go both ways. Isaac only goes to a place joined by a path, and each leg takes movement.leg_frames (60) frames, short or long.
• offers: the missions and towns the map offers on each place.
  • chapter is the chapter of /juego/data.json (qc01 to qc06; sc01 to sc03 for the side chapters) and step, the step inside the chapter. optional is true when completing it does not close the step.
  • objective is the text of its battles, empty when it only has scenes. scenes are ids of /juego/data.json and battles carries battle and map of /data/maps.json (null when the battle has no map page).
  • The same script can appear on two places: the game offers it on one or the other depending on a condition.
• free_battles: the free battles the game registers on each place, with their chapter.
• Arriving at a place that holds something starts it, and the game takes a checkpoint.
• markers: the map's three markers. Red marks a place where a mission or a town is offered; blue, another kind of event, not identified; for green, what shows it is not known.
• confidence says how each part is known: rom comes from the game's data; code, from reading its code, not checked in a play session.

The story: /juego/data.json

This file is the game's story logic, read from its scripts: which missions are open, what each one plays, what the player's answers change and which ending they reach. Paths inside it are relative to /juego/. Texts are in /juego/textos/<language>.json, under the same ids.

Game state

A game is four things, all starting empty:

• flags: numbered switches, on or off.
• counters: numbered values from 0 to 127. Counter rules.compassion is the one that decides between two endings.
• answers: for each scene, the option chosen in each choice slot.
• done: the missions completed.

Conditions

Many entries carry a list of conditions; all must hold. Each is [negate, test] (when negate is true, the test must fail):

Chapters and missions

chapters lists the chapters in order: qc01 to qc06 for the main story, sc01 to sc03 for side missions. Each chapter is a list of steps on the world map; each step offers missions as [mission, offer, conditions] and has flags to turn on when it ends:

• Only missions whose conditions hold are offered.
• offer 159 marks an optional mission. A step ends when one of its other missions is done (or any mission, if all are optional); then its flags turn on and the next step opens.
• If no step is open (something must still be found), the last step that offered missions stays open so its places can be visited again.
• The current chapter is the first qc0N whose flag in rules.chapterFlags (one per chapter, 1 to 4) is off. With all four on, the story continues in qc06 if flag rules.route6Flag is on, and in qc05 otherwise. Side chapters run at the same time.

missions describes each mission: kind (m battle, t town, r free battle) and a timeline played in order, skipping entries whose conditions (the last element) fail:

At the end the mission counts as done. Mission and chapter names are in the text files (missions, chapters).

Scenes

scenes[id].blocks holds the scene's blocks; it starts in main and runs its items in order:

The scene ends when a block runs out of items. Lines keep the game's own line breaks (\n). Isaac is the hero's default name. [L], [B] and [+Control Pad] (in each language's words) stand for the console's buttons.

To draw the top screen (256×192):

• Background: bgs[background] is [picture, width, height]. Show the part that starts at x = clamp(-cameraX, 0, width - 256), y = clamp(-cameraY, 0, height - 192).
• Characters: each [actor, x, y, expression, mirror] of cast is a portrait. portraits["<actor>_<expression>"] is [picture, dx, dy, width, height]: its top-left corner goes at (x + dx, 160 + y + dy), mirrored horizontally when mirror is 1. names[actor] is who it is.

Endings

When a mission turns on flag endings.gameOverFlag, the game ends: the ending scene is the one paired with the first flag that is on in endings.byFlag ([flag, scene]), or endings.default. Their titles are in the text files (endings).

Battles in the story

battles[id] is a battle of the story: map (its picture), size, and units as [uid, x, y, level, character] (character is not 0 for story characters). The same battles, with names, are in /data/maps.json.

Text files

/juego/textos/<language>.json has, for that language: names (speakers, by number), scenes (each scene's title and lines), missions, chapters, endings and units (unit names by uid). Its ui holds the labels the site's novel uses; you can ignore it.

Audio

/data/audio.json has music (code is the song's name in the game) and effects grouped by category. Songs that loop are recorded playing the loop twice and fading out. In the game, a song with loop_end_s jumps back to loop_start_s when it reaches loop_end_s and plays forever; one with end_s plays once. missions and scenes count the missions and scenes that use it (each mission's is in /data/maps.json), and screen is the fixed screen that uses it: world_map, mission_complete, victory and defeat (when a battle ends), game_over, title or ending.

sound_events says what plays the sound effects of the menus, the world map, the results screen, treasure chests and mana crystals. It is read from the game's code (evidence: static): each place that plays a sound and the number it loads; it was not observed in an emulator. The game plays sound number N as entry N − 1 of the selected sound archive. That is normally SEQ_SE, the "Game" category of effects.

• events: group (menu, world_map, results, chest, crystal), event, sounds (id, name, url) and calls, the places in the code that play it. In menus, cursor, confirm and cancel are identified; other gathers the remaining menu sounds, whose triggering action on each screen was not traced. On the map: move (one leg of a path), enter_event (arriving at a scene or a town) and enter_battle. Results: exp_count (each step of the experience count) and level_up. Chest: open and item (the item obtained). Crystal: captured and lost.
• download: while the duel mode's Download screen is open, the game uses another archive, SEQ_SE_CURSORS. In it, numbers 2, 3, 4 and 108 play their own versions (replaces is the normal sound of that number). url is null when the site has no clip of it.

Other pictures

/data/gallery.json groups the rest of the art by section: runes (the shape of each one, as a picture), spells and battle effects, backgrounds, world map and its markers, interface, and unused or test art. /juego/mundo.png is the world map.

Not in the data

Your version has to define these:

• Which orders produce the AI's states 6, 7 and 12 (unresolved_states in /data/ai.json) and how the AI looks in a battle: what is published comes from the code, not from an emulator.

The graphics, texts and music belong to Taito and Ubisoft.