From e110b10ac88b6f8b8729299d24d36e330af78f20 Mon Sep 17 00:00:00 2001 From: Joe DiPrima Date: Wed, 29 Jul 2026 11:19:52 -0500 Subject: [PATCH] the #73 pick dig, part 2: there was never a software pick -- the division card cast the ray The hunt for the un-decompiled pick writer ends with the reason no scan could find it: it does not exist. In 1995 the pick was a DPL SCENE INTERSECTION run by the video board. The evidence converges from five directions: - The WinTesla renderer still carries the result slots: dplHitInstance / dplHitDCS / dplHitGeoGroup / dplHitGeometry + vehicleReticle, NULL-inited in the ctor and never fed by the port. - The stubbed 1995-era renderable constructors each took dpl_isect_mode_obj ("type of intersections to do on this object") plus an intersection MASK -- every scene object was configured for ray queries. - Auric, quoted in the KB long before this dig: "the pod's division card cast from the view." - VGL Lynx's night-6 LOD warning ("the hit test may run against a different LOD") reads as firsthand knowledge: the ray tested the DRAWN geometry. - Exhaustive byte- and pseudocode-level scans: nothing in the binary writes rayIntersection/targetEntity/targetDamageZone. Game code only reads them, constructs them (the Mech ctor @0x4a1674 -- identified this dig, along with vtable +0x18/+0x1c = Mech::Read/WriteUpdateRecord, nine replication groups, reticle not among them), gates them (FUN_004afd10, the look-state machine: per-view crosshair positions, the pi rear case, the per-weapon rear-fire mask walk), and ships them to the board for drawing (FUN_00460a7c packages rayIntersection + elementMask into dpl). What this means for #73: aimed fire in 1995 had PER-PART precision -- scene ray, struck triangle on the active LOD, the DCS is the segment, the segment's dzone is the credited zone. The cylinder lottery was only ever the UNAIMED path. The port's whole-mech box pick funnels aimed fire through the unaimed lottery, which is exactly what three testers documented on night 6: aim at the arm, get the spray. Fix design recorded in the KB: a per-SEGMENT ray test on the shooter side (inverse(segmentWorld) * ray vs each segment BGF's local extent box, nearest wins, its dzone dispatched as the aimed zone), falling back to box+lottery when no segment resolves. Co-Authored-By: Claude Fable 5 --- context/combat-damage.md | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/context/combat-damage.md b/context/combat-damage.md index eb2b2a3..a73b404 100644 --- a/context/combat-damage.md +++ b/context/combat-damage.md @@ -85,7 +85,28 @@ unlocated** [T4 candidates]: the un-exported stretch `0x4a1674-0x4a2d48` (touche together near entry `0x4a2971`, which is called from `0x494483`), the two unidentified Mech vtable overrides `+0x18=0x4a122c` / `+0x1c=0x4a0c2c` (both big switch functions), and lone sites `0x4877a4` (byte read via the mission entity table `0x5015c8`), `0x4b0097`, `0x45fb14-24`. -Recovering it settles #73's residual box-vs-cylinder question with binary truth. +**RESOLVED (same dig, deeper): there IS no software pick writer — the 1995 pick was a DPL SCENE +INTERSECTION** [T0 + T1 converging]. Evidence: (a) the WinTesla renderer still carries the result +members `dplHitInstance/dplHitDCS/dplHitGeoGroup/dplHitGeometry` + `vehicleReticle` (L4VIDEO.cpp +ctor, all NULL-init); (b) the stubbed 1995-era renderable constructors each took +**`dpl_isect_mode_obj` ("type of intersections to do on this object") + an intersection MASK** — +per-renderable intersection configuration against the scene; (c) Auric's account ("the pod's +division card cast from the view"); (d) VGL Lynx's LOD warning reads as firsthand knowledge — the +ray tested the DRAWN geometry, i.e. the active LOD's meshes; (e) exhaustive scans: nothing in the +binary or the pseudocode ever writes `rayIntersection/targetEntity/targetDamageZone` — game code +only reads, initializes (the Mech ctor @0x4a1674 constructs the embedded Reticle), gates +(`FUN_004afd10`, the look-state machine, toggles `pickPointingOn` per view with the π rear case), +and SUBMITS the reticle to the board for drawing (`FUN_00460a7c` packages +0x37c/+0x390 into dpl). +⇒ **Aimed fire in 1995 had PER-PART precision**: scene ray → struck triangle on the current LOD → +the DCS = the struck SEGMENT → its `dzone` (the SKL segment→zone map, `GetSegmentIndex@49db20`) = +`targetDamageZone`. The cylinder lottery (STEP 6) was only ever the UNAIMED path. The port's +whole-mech box pick + "STEP-6 zone under the boresight" funnels AIMED fire through the unaimed +lottery — which is exactly the night-6 report (#73): aim at the arm, get the spray. +**Fix design**: per-SEGMENT ray test on the shooter side — for each visible segment of the +candidate mech, `inverse(segmentWorld) · ray` vs the segment BGF's local extent box (the draw +traversal already owns the per-segment world matrices); nearest struck segment → its `dzone` → +dispatch with that zone (aimed), beam converges to the segment hit point. Falls back to the +existing box+lottery when no segment resolves. `mech+0x37c` = target world Point3D; `mech+0x388` = target `Entity*` (the `HasActiveTarget()` gate); `mech+0x38c` = targeted sub-zone (−1=whole). Weapons cache hasTarget/targetPoint/muzzlePoint, refreshed each frame. [T1]