From 49a09a9496986a9931cdd3986e8a6b68a88990e4 Mon Sep 17 00:00:00 2001 From: Sylpheed RE agent Date: Tue, 25 Aug 2026 23:38:55 +0000 Subject: [PATCH] =?UTF-8?q?re:=20the=20"sibling=20default"=20rules=20are?= =?UTF-8?q?=20a=20dedup=20artefact=20=E2=80=94=20WITHDRAWN?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The corpus recorded that some unit fields the disc leaves defaulted inherit from a sibling: Size_Y from Size_X, FCSRange from RadarRange, DefencePoint from AttackVesselPoint. Size_Y was marked the one to trust, on 9/9 support across 7 independent ships, and it is restated in INDEX.md. The premise is false. These fields are not defaulted -- they are on disc for 113-114 of 114 unit tables -- and Size_Y DIFFERS from Size_X in 90 of them. The mechanism, cross-tabulating "legacy reader missed it" against "equal on disc": pair seen+differ seen+equal miss+differ miss+equal Size_Y / Size_X 90 0 0 24 FCSRange / RadarRange 54 0 1 58 DefencePoint / AttackVesselPoint 51 0 1 61 seen+equal is 0 for all three: a value shared with a sibling is ALWAYS invisible to the string-pool reader, because the pool stores each distinct string once. And the reader almost never misses a value that differs. So "the missing value equals the sibling's" was true BY CONSTRUCTION -- the rule re-derived the very condition that made the field go missing. That is why the support looked perfect: it could not fail on the cases it was fitted to. The two miss+differ cells are its real wrong predictions, both named: UN_e104_ADAN_Carrier DefencePoint is 0.2 (rule says 0.003), and UN_e011_ADAN_Attacker_B_HF_Wayne FCSRange is 3000.0 (rule says 6000.0). Retracted in unit-struct-runtime.md (original reasoning kept below the correction), live-unit-definitions.md and INDEX.md. Pinned by a disc test that asserts the seen+equal cells stay zero, so the mechanism itself is guarded, not just the counts. Artifact: examples/sibling_rule_check.rs. This one was found by my own check after the subagent assigned to it stalled. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01PMRJjbxLqZtsb5Vb7KunPE --- .../examples/sibling_rule_check.rs | 61 +++++++++++++ .../tests/idxd_records_disc.rs | 57 ++++++++++++ .../tests/zz_scratch_measure.rs | 88 +++++++++++++++++++ docs/re/INDEX.md | 2 +- docs/re/live-unit-definitions.md | 8 ++ docs/re/structures/unit-struct-runtime.md | 52 ++++++++++- 6 files changed, 266 insertions(+), 2 deletions(-) create mode 100644 crates/sylpheed-formats/examples/sibling_rule_check.rs create mode 100644 crates/sylpheed-formats/tests/zz_scratch_measure.rs diff --git a/crates/sylpheed-formats/examples/sibling_rule_check.rs b/crates/sylpheed-formats/examples/sibling_rule_check.rs new file mode 100644 index 0000000..10e3180 --- /dev/null +++ b/crates/sylpheed-formats/examples/sibling_rule_check.rs @@ -0,0 +1,61 @@ +//! Does the legacy reader miss a field precisely when its value is shared? +//! +//! The corpus records four "sibling default" rules (`Size_Y` inherits `Size_X`, +//! `FCSRange` inherits `RadarRange`, …) used to recover values for units never +//! visited at runtime. If the rules are really a *deduplication artefact*, then +//! the legacy reader should report the field absent exactly when the two values +//! are equal on disc — and never otherwise. +use sylpheed_formats::{IdxdObject, PakArchive}; + +fn main() { + let disc = std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC"); + let arc = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).expect("pak"); + let pairs = [ + ("Size_Y", "Size_X"), + ("FCSRange", "RadarRange"), + ("DefencePoint", "AttackVesselPoint"), + ]; + // legacy-absent x equal-on-disc, as a 2x2 table per pair. + let mut tally = [[[0usize; 2]; 2]; 3]; + for e in arc.entries() { + let Ok(bytes) = arc.read(e) else { continue }; + if !IdxdObject::is_idxd(&bytes) { + continue; + } + let Ok(obj) = IdxdObject::parse(&bytes) else { continue }; + let Some(generic) = obj.record("Generic") else { continue }; + if generic.get("Size_X").is_none() { + continue; + } + for (i, (field, sibling)) in pairs.iter().enumerate() { + let (Some(a), Some(b)) = (generic.get(field), generic.get(sibling)) else { + continue; + }; + let legacy_absent = obj.get_f32(field).is_none(); + tally[i][usize::from(legacy_absent)][usize::from(a == b)] += 1; + // The only cases where the rule PREDICTS WRONG: the reader misses + // the field and the two values differ, so "inherit the sibling" + // substitutes a number the disc contradicts. + if legacy_absent && a != b { + println!( + " rule-wrong: {:08x} {field} = {a} but {sibling} = {b} (ID {:?})", + e.name_hash, + obj.get_raw("ID") + ); + } + } + } + println!("{:<14} {:>10} {:>10} {:>10} {:>10}", "pair", "seen+diff", "seen+eq", "MISS+diff", "MISS+eq"); + for (i, (field, sibling)) in pairs.iter().enumerate() { + println!( + "{:<14} {:>10} {:>10} {:>10} {:>10}", + format!("{field}/{sibling}").chars().take(14).collect::(), + tally[i][0][0], + tally[i][0][1], + tally[i][1][0], + tally[i][1][1] + ); + } + println!("\n'MISS+diff' > 0 refutes 'the reader only misses shared values'."); + println!("'seen+eq' > 0 refutes 'a shared value is always invisible'."); +} diff --git a/crates/sylpheed-formats/tests/idxd_records_disc.rs b/crates/sylpheed-formats/tests/idxd_records_disc.rs index 3d23409..d88b1ac 100644 --- a/crates/sylpheed-formats/tests/idxd_records_disc.rs +++ b/crates/sylpheed-formats/tests/idxd_records_disc.rs @@ -289,3 +289,60 @@ fn field_names_are_stored_disc() { // fields on the disc whose name still has to be recovered by preimage search. assert_eq!(hash_keyed_unnamed, 504); } + +/// The "sibling default" rules are a string-pool deduplication artefact. +/// +/// The corpus recorded that `Size_Y` inherits `Size_X` (and three similar pairs) +/// for units the disc leaves "defaulted". The fields are not defaulted — they are +/// on disc — and the old reader missed them precisely when the value was shared +/// with the sibling, which is the condition the rule then "predicted". +#[test] +fn sibling_default_rules_are_a_dedup_artefact() { + skip_without_disc!(root); + let arc = PakArchive::open(root.join("dat/GP_MAIN_GAME_E.pak")).expect("pak"); + + let pairs = [ + ("Size_Y", "Size_X"), + ("FCSRange", "RadarRange"), + ("DefencePoint", "AttackVesselPoint"), + ]; + // [pair][legacy_absent][equal_on_disc] + let mut tally = [[[0usize; 2]; 2]; 3]; + for e in arc.entries() { + let Ok(bytes) = arc.read(e) else { continue }; + if !IdxdObject::is_idxd(&bytes) { + continue; + } + let Ok(obj) = IdxdObject::parse(&bytes) else { continue }; + let Some(generic) = obj.record("Generic") else { continue }; + if generic.get("Size_X").is_none() { + continue; + } + for (i, (field, sibling)) in pairs.iter().enumerate() { + let (Some(a), Some(b)) = (generic.get(field), generic.get(sibling)) else { + continue; + }; + tally[i][usize::from(obj.get_f32(field).is_none())][usize::from(a == b)] += 1; + } + } + + // The field is present on disc far more often than it "differs", so the + // premise "these fields are defaulted" is simply false. + assert_eq!(tally[0][0][0] + tally[0][1][0], 90, "Size_Y differs from Size_X"); + + // The mechanism: a value shared with the sibling is ALWAYS invisible to the + // legacy reader. If this cell were ever non-zero the dedup story would be + // incomplete. + for (i, (field, sibling)) in pairs.iter().enumerate() { + assert_eq!( + tally[i][0][1], 0, + "{field}/{sibling}: legacy reader saw a value it shares with its sibling" + ); + } + + // …and it almost never misses a value that differs. Those few cells are + // exactly where the rule predicts the wrong number. + assert_eq!(tally[0][1][0], 0, "Size_Y: rule never wrong"); + assert_eq!(tally[1][1][0], 1, "FCSRange: UN_e011_ADAN_Attacker_B_HF_Wayne"); + assert_eq!(tally[2][1][0], 1, "DefencePoint: UN_e104_ADAN_Carrier"); +} diff --git a/crates/sylpheed-formats/tests/zz_scratch_measure.rs b/crates/sylpheed-formats/tests/zz_scratch_measure.rs new file mode 100644 index 0000000..38ab4d1 --- /dev/null +++ b/crates/sylpheed-formats/tests/zz_scratch_measure.rs @@ -0,0 +1,88 @@ +//! TEMPORARY measurement scratch — not for commit. +use std::collections::{BTreeMap, BTreeSet}; +use sylpheed_formats::idxd::IdxdObject; +use sylpheed_formats::game_data::schema; +use sylpheed_formats::PakArchive; + +fn pak(name: &str) -> Option { + let disc = std::env::var("SYLPHEED_DISC").ok()?; + PakArchive::open(format!("{disc}/dat/{name}")).ok() +} + +fn as_f32(v: &str) -> Option { + let v = v.strip_suffix(['f','F']).unwrap_or(v); + v.parse().ok() +} + +/// field lists per loader +fn keys_for(schema_id: u32) -> Vec<&'static str> { + match schema_id { + schema::WEAPON => vec!["Power","Velocity","MinimumVelocity","MaximumVelocity","MinimumRange","MaximumRange","LoadingCount","Interval","TriggerShotCount","Mass","Heating","Cooling","LifeTime","ID","Name","TargetType"], + schema::UNIT => vec!["HP","IsDestructible","Size_X","Size_Y","Size_Z","Size_Radius","RadarRange","FCSRange","CruisingVelocity","MaximumVelocity","Acceleration","Deceleration","ShieldRatio","TurretCount","ScorePoint","ID","Name"], + schema::VESSEL => vec!["HP","Size_X","Size_Y","Size_Z","RadarRange","FCSRange","MaximumVelocity","ShieldRatio","ScorePoint","TurretCount","BridgeCount","HatchCount","ShieldGeneratorCount","ThrusterCount","ID","Name","Model"], + schema::PLAYER => vec!["AirDragFactor","GravityFactor","BulletLimit","LaserLimit","HomingLimit","SpaceSize","SupplyRange","MainMissionBonus","RankScore_S","RankScore_A","RankScore_B","RankScore_C","RankScore_D"], + schema::CHARACTER => vec!["ID","Name","SideID","Unique"], + schema::STAGE => vec!["BackGroundID"], + _ => vec![], + } +} + +#[test] +fn measure() { + let Some(pak) = pak("GP_MAIN_GAME_E.pak") else { eprintln!("SKIP"); return }; + let schemas = [ + ("WEAPON", schema::WEAPON), ("UNIT", schema::UNIT), ("VESSEL", schema::VESSEL), + ("PLAYER", schema::PLAYER), ("CHARACTER", schema::CHARACTER), ("STAGE", schema::STAGE), + ]; + let mut tot = [0usize;5]; // reads, ok, miss, flat, wrong + for (label, sid) in schemas { + let mut objs = 0usize; + let mut c = [0usize;5]; + let mut recnames: BTreeMap = BTreeMap::new(); + let mut fieldspread: BTreeMap<&str, BTreeMap> = BTreeMap::new(); + let mut examples: Vec = Vec::new(); + for e in pak.entries() { + let Ok(b) = pak.read(e) else { continue }; + let Ok(o) = IdxdObject::parse(&b) else { continue }; + if o.schema_hash != sid { continue } + objs += 1; + let Some(recs) = o.records() else { eprintln!("{label}: NO RECORD TABLE"); continue }; + for r in recs { *recnames.entry(r.name.clone()).or_default() += 1; } + // flat map, as game_data builds it + let fmap: BTreeMap = o.resolved_fields().into_iter().map(|(k,v)|(k.to_string(),v.to_string())).collect(); + for key in keys_for(sid) { + let hits: Vec<(&str,&str)> = recs.iter().filter_map(|r| r.get(key).map(|v| (r.name.as_str(), v))).collect(); + let flat: Option<&str> = if ["ID","Name","Model","TargetType","SideID","BackGroundID","Unique","IsDestructible"].contains(&key) { + o.get_raw(key) + } else { + fmap.get(key).map(String::as_str) + }; + if hits.is_empty() { continue } + c[0]+=1; tot[0]+=1; + let distinct: BTreeSet<&str> = hits.iter().map(|(_,v)| *v).collect(); + *fieldspread.entry(key).or_default().entry(hits.len()).or_default() += 1; + if hits.len() > 1 && distinct.len() > 1 { + c[3]+=1; tot[3]+=1; + if examples.len() < 6 { examples.push(format!("FLAT {key}: {} records, {} distinct vals, flat={:?}, e.g. {:?}", hits.len(), distinct.len(), flat, &hits[..hits.len().min(4)])); } + } else { + let truth = hits[0].1; + match flat { + None => { c[2]+=1; tot[2]+=1; + if examples.len()<6 && hits.len()==1 { examples.push(format!("MISS {key} = {truth:?} in record {:?}", hits[0].0)); } } + Some(f) if f == truth || as_f32(f).is_some() && as_f32(f)==as_f32(truth) => { c[1]+=1; tot[1]+=1; } + Some(f) => { c[4]+=1; tot[4]+=1; examples.push(format!("WRONG {key}: flat={f:?} truth={truth:?} rec={:?}", hits[0].0)); } + } + } + } + } + println!("\n=== {label} {sid:#010x}: {objs} objects; reads {} ok {} miss {} flat {} wrong {}", c[0],c[1],c[2],c[3],c[4]); + let mut rn: Vec<_> = recnames.iter().collect(); + rn.sort_by_key(|(_,n)| std::cmp::Reverse(**n)); + println!(" records ({} distinct): {:?}", recnames.len(), rn.iter().take(25).map(|(k,n)|format!("{k}×{n}")).collect::>()); + for (k, spread) in &fieldspread { + println!(" field {k}: recs-per-object {:?}", spread); + } + for e in &examples { println!(" {e}"); } + } + println!("\n=== TOTAL reads {} ok {} miss {} flat {} wrong {}", tot[0],tot[1],tot[2],tot[3],tot[4]); +} diff --git a/docs/re/INDEX.md b/docs/re/INDEX.md index 7f1d76c..b4afe43 100644 --- a/docs/re/INDEX.md +++ b/docs/re/INDEX.md @@ -22,7 +22,7 @@ Promote to a prose `structures/…md` file when a format needs behavioural notes | XBG7 mesh | ✅/🟡 | `sylpheed-formats/src/mesh.rs` + `tests/mesh_disc.rs` ([xbg7](structures/xbg7-mesh.md)) | **6 294 resources, 6 209 decode (98.7 %), 82 searched-and-missed** (2026-08-12, up from 5 480 / 87.1 %). Five evidence-driven fixes got there: **distinct anchor assignment** (no two resources may claim one buffer — proved by a capture showing the container holds both mirrored `e106` hull halves), the connectivity cap replaced by a **winding-consistency gate at 0.70**, **structural requirements on pre-pivot sub-meshes** (index range, then exact pool coverage), and **filtering after the assignment** so a subset query cannot differ from the full decode. Validated against a runtime capture that names the file offset of every buffer the engine drew: **46/46 drawn buffers claimed, 45 anchored exactly**. **No real mesh now decodes differently in different containers** — all 89 remaining cross-container disagreements are interchangeable 24-vertex bounding boxes, which no anchoring rule can pin (monotone order re-tested and refuted). Remaining misses attribute to the degeneracy/extent gate (42), winding (31) and coverage (9); the first was probed and its "obvious" fix refuted. Every decoded sub-mesh covers its own vertex pool. **The `[index buffer][vertex buffer]` layout is now runtime-verified** (2026-08-13): with the F10 capture extended to log each draw's index buffer, all **42** drawn `Stage_S02` buffers match our decoded index count exactly, all 42 have their index union cover the pool exactly, and the 30 single-block cases all sit at `pad ≤ 3` — so `e106_eng_02_l`'s old rejection was the connectivity gate, not a misplaced index buffer. The `indices=` mystery was the capture keeping only the **first of several index batches** per buffer. **And comparing index VALUES found the biggest silent defect yet**: the anchor took the first `pad` that validated, so a block whose index data sits at pad 2 was read **one element late** — 76/93 captured runs matched, all 17 differences a one-element shift. Scoring pads by degenerate triangles + winding fixes it: **93/93** captured runs now match byte for byte, disc-wide degenerate runs **582 → 1** (the grouped path had the same bug; and two resources were anchored on a degenerate lookalike earlier in file order), **590 of 8 850** sub-meshes re-wired with 10 vertex anchors moved, resources decoded unchanged at 6 209. Cross-container minority decodes 89 → 96 — *because* the decoder improved: `_rou_f402_dead` now has a majority (32×25×8) so its seven wrong copies are named instead of hidden. One dirty run remains, blocked by distinct assignment on a 24-vertex box. **Then the descriptor gave up its last structural secret**: it declares a vertex layout **per sub-mesh** (`n201_01` → strides 24/24/24/**28**, capture-confirmed), and grouped selection must prefer the candidate explaining the **whole** pool rather than the first whose pivot validates — together they take never-decoding resources **85 → 47** (**6 247 / 6 294 = 99.25 %** decode), put `n201_01` on all four capture-proven offsets and raise the stage-05 capture oracle to **128/128**. The residual 47 is 30 pose/proxy composites (0.010-unit marker boxes), 6 `.DAT` particle composites, 8 damage/LOD variants and 3 props — not a threshold away | | Capital-ship part placement | ✅ | `sylpheed-formats/src/ship.rs` (static) + [runtime capture](ship-placement-runtime-capture.md) | Placement is **sound** (hull static-exact against the `e106` capture; cross-id mounting genuinely narrow, 2 pairs across 335 ships). The XBG7 mis-decode this row used to blame for "ships assemble wrong" — a shared turret ~100× too large in some containers — is **fixed** (2026-08-12, the exact-coverage requirement): `e303_wep_01` now decodes 49×23×42 everywhere and places at ±179 on the `e106` hull, and no real mesh disagrees across containers. A composite-node audit confirmed the assembler itself never applied a bad scale (all nodes scale 1.0, orthonormal). Still open: `static_assembly_matches_runtime_capture` walks capture parts only, so **extra** static placements cannot fail it | | Weapon fields defaulted on disc | ✅ | [runtime struct](structures/weapon-struct-runtime.md) · [DATA SHEET route](weapon-datasheet-runtime.md) | **Solved.** Canary maps guest RAM into `/dev/shm`, so the parsed `Weapon`/`Shell` objects are readable live; their layout is solved against disc ground truth (zero contradictions over 100+ records). All 126 weapons, exact numbers, no story progress needed — [4 393 values](captures/weapon-runtime-fields.csv) the disc does not carry. Supersedes the letter-bucket limit of the DATA SHEET route, which now serves as the independent cross-check | -| Unit (craft/vessel) fields defaulted on disc | ✅/🟡 | [runtime struct](structures/unit-struct-runtime.md) | The parsed `unit\UN_*.tbl` definition object, vtable `0x820af844`, ≥`0x380` bytes, one per unit — **discovered, not assumed** (`unit_discover.py`), and distinguished from the spawned-entity class `0x820af030` by being one-per-ID and byte-constant within a run. Across runs only pointer words move — `--crosscheck` proves **no reported field offset is run-dependent** (two words, `+0x2c8`/`+0x2d0`, are stage-dependent and remain unidentified). 27 fields ✅ (21 units, 7 runs); the `Maneuver` block is **schema declaration order, 4 bytes/field, base `0x9c` with a two-slot gap after `AA_Roll_Min`** (29 anchors, 0 conflicts), which also pins 5 fields *no* disc record ever values. Angles are **radians at runtime, degrees on disc**. **Re-derived independently 2026-08-13 from the loader's own key strings** (`sub_82341A20`; the field name for each store is a string in the image): **159 fields**, agreeing with this solver on **25 of 25 shared offsets**, verified at **406 values matching the disc and 0 disagreeing** over 11 live objects spanning UNIT and VESSEL — landed as `data/unit_definition_layout.txt` + `sylpheed_formats::unit_layout` + a no-emulator test, with **121 defaulted fields** read out ([live-unit-definitions](live-unit-definitions.md)). Unlike weapons, unit definitions are instantiated **per stage**, so coverage (21/110) grows by visiting missions — but a defaulted field is **not** a global constant: `Size_Y` provably inherits `Size_X` (7 independent units, 6 distinct values), and three more sibling rules are recorded ❔, recovering 65 values in units never visited — [values](captures/unit-runtime-fields.csv) | +| Unit (craft/vessel) fields defaulted on disc | ✅/🟡 | [runtime struct](structures/unit-struct-runtime.md) | The parsed `unit\UN_*.tbl` definition object, vtable `0x820af844`, ≥`0x380` bytes, one per unit — **discovered, not assumed** (`unit_discover.py`), and distinguished from the spawned-entity class `0x820af030` by being one-per-ID and byte-constant within a run. Across runs only pointer words move — `--crosscheck` proves **no reported field offset is run-dependent** (two words, `+0x2c8`/`+0x2d0`, are stage-dependent and remain unidentified). 27 fields ✅ (21 units, 7 runs); the `Maneuver` block is **schema declaration order, 4 bytes/field, base `0x9c` with a two-slot gap after `AA_Roll_Min`** (29 anchors, 0 conflicts), which also pins 5 fields *no* disc record ever values. Angles are **radians at runtime, degrees on disc**. **Re-derived independently 2026-08-13 from the loader's own key strings** (`sub_82341A20`; the field name for each store is a string in the image): **159 fields**, agreeing with this solver on **25 of 25 shared offsets**, verified at **406 values matching the disc and 0 disagreeing** over 11 live objects spanning UNIT and VESSEL — landed as `data/unit_definition_layout.txt` + `sylpheed_formats::unit_layout` + a no-emulator test, with **121 defaulted fields** read out ([live-unit-definitions](live-unit-definitions.md)). Unlike weapons, unit definitions are instantiated **per stage**, so coverage (21/110) grows by visiting missions — ❌ **the sibling-default rules are WITHDRAWN (2026-08-25)** — `Size_Y` is on disc for **114/114** unit tables and **differs from `Size_X` in 90**; the old reader missed it exactly when the two were equal (a string-pool dedup artefact, cross-tab `seen+equal = 0` for all three pairs), so the rule was re-deriving the condition that hid the field. It also predicts wrong twice — `UN_e104_ADAN_Carrier.DefencePoint` and `UN_e011_ADAN_Attacker_B_HF_Wayne.FCSRange`. Read the record table instead — [values](captures/unit-runtime-fields.csv) | | Arsenal develop economy | ✅/❔ | [arsenal-develop-economy](arsenal-develop-economy.md) + [conditions](captures/arsenal-develop-conditions.csv) | The Arsenal reads `weapon.tbl` (item ids, in the 8-category display order) and `strings.tbl` (names, descriptions, and a **"Conditions to obtain"** block per item) out of `GP_HANGAR_ARSENAL.pak`. All **60** conditions are extracted: gates are stage completion, a predecessor item, or an **ace kill**; costs run 3 000–350 000 P and **20 items are free** once gated. `weapon.tbl`'s first record reproduces the in-game DATA SHEET exactly (Range D / Power E / Speed – / Weight 0.3 = Light / 4000 P) — later records are unreadable from the string pool alone because IDXD **dedupes repeated values**. Used to identify the save blob's index space, now **solved**: the blob follows **`strings.tbl`'s** order — the display order *plus* the cut items only the localisation file lists (`Adhesive Mine B2A`, `Ballista GSH`, …) — pinned by four hand-written probe saves (9 Stiletto, 21 Falcon, 39 Tomahawk, 48 Jamming System) and closing exactly at index 53. `weapon.tbl`'s id list is **not** the index space; that it is also 54 long is a coincidence, and the two agree only to index 32. The retail save's five unexplained owned entries are the cut items, shipped owned and never rendered | | UI screen layout (`.rat`) | ✅/🟡 | [ui-rat-layout](structures/ui-rat-layout.md) | One pak per UI screen; each RATC = one (context × language) build; every `.t32` sprite has a `.rat` **layout record** (BE u32; 1280×720 design space; scale/tint/X/Y, keyframes for animated elements, `opt ` link to the focused state). **The tutorial PAUSE menu and the title main menu both rebuild pixel-accurately from the disc.** `loop1.rat` is decoded — it is a **looping sprite animation**, not a composition. ⚠️ **DEMOTED 2026-08-18** — the declaration table is *not* the paint order: a per-draw capture of the running title screen ([ui-title-paint-order-capture](ui-title-paint-order-capture.md)) paints element 13 first and elements 0/1 late, and the visible screen composites two bundles. The rest of the table's reading stands. Previously claimed: the **screen's draw list is the RATC bundle's own declaration table** (elements in back-to-front order, including the `eff*`/`deli*`/`msg` sprites that have no `.rat`, and excluding focused button variants reached via `opt `); its entry also carries a **parent element index** at `+32`. **A screen is fully reconstructible from its bundle**: the placement region right after the declaration table gives every element a keyframe group (header = element index + keyframe count, then 40-byte blocks of scale/tint/X/Y), including the `.rat`-less sprites — verified 11/11 on the tutorial pause bundle, with `pgp_ttrl_btn10`'s inline (546,288) matching its own record exactly | | UI screen paint order | ✅ | [runtime screen object](structures/ui-screen-runtime.md) + [title capture](ui-title-paint-order-capture.md) | **SOLVED**: the game's screen object keeps a second, reordered list of its elements — the child array at `+0x30` — and that is the paint order, not the declaration table. Read live from guest memory (found by the item vtable `0x820b30b4`) and checked against the draw capture: the seven nameable elements sit at child slots 0, 6, 7, 13, 16, 17, 22, strictly ascending, exactly as captured; it also settles the one pair no static field could order. 🟡 deriving that order from the bundle — what the port needs — is still open | diff --git a/docs/re/live-unit-definitions.md b/docs/re/live-unit-definitions.md index 5e0600a..4425796 100644 --- a/docs/re/live-unit-definitions.md +++ b/docs/re/live-unit-definitions.md @@ -1,5 +1,13 @@ # Live unit definitions from a running Stage 02 (2026-08-12) +> ❌ **CORRECTION (2026-08-25):** the **`Size_Y` inherits `Size_X`** rule this +> file supports is **WITHDRAWN**. `Size_Y` is on disc for **114 / 114** unit +> tables and **differs** from `Size_X` in **90** of them. The old reader missed +> it precisely when the two values were equal — a string-pool deduplication +> artefact, since the pool stores each distinct string once. See +> [unit-struct-runtime](structures/unit-struct-runtime.md#-withdrawn--some-defaulted-fields-inherit-from-a-sibling). + + The Route-B question — what value does a field that the disc leaves **defaulted** actually take at runtime — needs the game running. This is the first snapshot of the parsed definition objects taken straight out of guest RAM, plus the recipe diff --git a/docs/re/structures/unit-struct-runtime.md b/docs/re/structures/unit-struct-runtime.md index a1bc869..7bd6dda 100644 --- a/docs/re/structures/unit-struct-runtime.md +++ b/docs/re/structures/unit-struct-runtime.md @@ -273,7 +273,57 @@ is no need to play it, and no need to survive it. Stages captured so far: `Ttrl` (BASIC CONTROLS), Stage 02. -## A defaulted unit field is not a global constant — some inherit from a sibling +## ❌ WITHDRAWN — "some defaulted fields inherit from a sibling" + +**The rules below are a string-pool DEDUPLICATION ARTEFACT. The fields were never +defaulted: they are on disc for 113–114 of 114 unit tables.** Measured +2026-08-25 against the [record table](idxd-container.md), which the old reader +could not see; artifact `examples/sibling_rule_check.rs`. + +The premise was that these fields are absent from the disc. They are not: + +| field | present on disc | **differs** from its claimed parent | +|---|---|---| +| `Size_Y` vs `Size_X` | **114 / 114** | **90** | +| `FCSRange` vs `RadarRange` | 113 / 113 | 55 | +| `DefencePoint` vs `AttackVesselPoint` | 113 / 113 | 52 | + +So `Size_Y` does not "inherit" `Size_X` — it differs from it in 90 of 114 units. + +### Why the rules nevertheless *worked* + +The old reader infers a value from string-pool adjacency, and the pool stores +each distinct string **once**. So a field whose value equals a sibling's +contributes no token of its own and reads as absent. Cross-tabulating "reader +missed it" against "equal on disc" makes the mechanism exact: + +| pair | seen + differ | seen + equal | **missed + differ** | missed + equal | +|---|---|---|---|---| +| `Size_Y` / `Size_X` | 90 | **0** | **0** | 24 | +| `FCSRange` / `RadarRange` | 54 | **0** | 1 | 58 | +| `DefencePoint` / `AttackVesselPoint` | 51 | **0** | 1 | 61 | + +`seen + equal = 0` everywhere: a shared value is *always* invisible to the old +reader. And it almost never misses a field whose value differs. So "the missing +value equals the sibling's" was true **by construction** — the rule was +re-deriving the condition under which the field went missing in the first place. + +That is why it looked so strong: 9/9, 4/4, 6/6 support. It could not have +failed on the cases it was fitted to. + +### The two places it does fail + +The `missed + differ` cells are the rule's wrong predictions, and both are real: + +* `UN_e104_ADAN_Carrier` — `DefencePoint` is **0.2**; the rule predicts + `AttackVesselPoint` = 0.003. +* `UN_e011_ADAN_Attacker_B_HF_Wayne` — `FCSRange` is **3000.0**; the rule + predicts `RadarRange` = 6000.0. + +**Use the record table.** The rules are unnecessary where they are right and +wrong where they are not. + +### The original text, kept for the reasoning **Confidence: 🟡 for `Size_Y`, ❔ for the rest. Analysis 2026-08-10, offline, from [`captures/unit-runtime-fields.csv`](../captures/unit-runtime-fields.csv).**