# Apache analysis and reconstruction

## Reference and scope

The October 2000 European disc is the primary reference. Its DOS engine was built on 12 January 1998; the Windows software and 3dfx engines on 14 January. Earlier discs, the demo and patches remain comparison material. The June 1998 Voodoo2 update is a separate renderer compatibility variant.

The first reconstruction targets the original software game, with original assets selected from a local installation, C++26, Linux-first verification, square pixels and the window/scaling approach used in our other Lost Engines projects. Audio, controls, menus and campaign integration are part of the game, not optional follow-up work. Original unsafe memory access is not something to emulate.

## Current integration state

The C++ game runs Quickstart, training, single missions and campaigns with live flight, combat, instruments, audio and persistent pilot/campaign progress. The planner, waypoint editor, payload selector, 3D preview, preferences, joystick controls, manual and movies are connected. First-launch setup and multiplayer are verified, including two real windows exchanging chat and shared flight. Optimized packaging and all six CI configurations pass; release packages are published and the current local build is ready for playtesting. The entries below retain the analysis history. See [current status](analysis-review.md) for the present completion state.

## Work sequence

1. **Media characterisation: complete.** Seven distinct disc contents, four patches and one demo preserved with hashes and comparisons. No CD audio.
2. **Reference installation and executable map: complete for the selected engine.** The DOS reference runs in an isolated drive. Windows ELF/DWARF symbols are decoded and checked; earlier Windows revisions have partial address maps and original-routine comparisons.
3. **Resources and local workbench: complete.** Models, terrain/scenery, missions, images, palettes, fonts, cockpit/menu art, movies and audio have decoders and local viewers. MANEDIT's original figure plays all 104 supported poses. Six newer authoring files expose raw channels because the supplied editor cannot load them.
4. **Engine and gameplay: complete for the selected software reference.** Rendering, flight, avionics, weapons, AI, damage, campaign progression, saves, controls, timing, audio and multiplayer are traced and implemented.
5. **Analysis review: complete.** Resource and dispatch coverage, original-code evidence and defined-behaviour limits are recorded in the current status and implementation documents.
6. **C++ reconstruction: ready for beta testing.** The connected game is committed and pushed to `../apache-cpp`; game assets remain outside Git.
7. **Integration and acceptance: automated checks and CI complete.** Normal, sanitizer and optimized builds pass original-code comparisons and private-window game journeys. Hardware controls, sound devices and subjective playability remain human beta-test items.

## Working boundaries

Research and generated assets stay local. There is no deployment or publication task. Extracted media are immutable; working installs use copies. Input automation runs on a private X server and never controls the desktop. Only `apache-cpp` has commit/push authorisation at this stage. Other sibling projects are references, not editing targets.

## Current findings

- Both January 1998 Windows executables contain appended ELF/DWARF information, despite an empty PE debug directory. The symbols are decoded and independently checked. Model and image decoding now have original-execution comparisons. The local model, artwork, terrain and mission browsers are working. All terrain height interpolation, triangle texture dispatch, feature vertices and feature face submissions have original-execution checks. All 110 mission actor definitions are checked against original loading and formation expansion: 1,871 tasks, 8,944 actor records, 21,989 expanded units and 42,054 waypoints. The font, cockpit, movie and audio tools are in place. Checks cover 2,316 glyph draws, 60 cockpit composites, all 5,217 animation frames and palettes, and 207 sound-bank records. All 522 FLAC extracts round-trip exactly. The complete original software renderer, mission initialization and cockpit instruments now run in the isolated native harness. All 30,724 trigonometry table entries reproduce the supplied files. Gameplay behaviour and broader frame coverage remain in progress.

### Gameplay reference coverage

- Fifteen original flight scenarios each repeat identically from a fresh mission, covering realistic and arcade control, gentle manoeuvres, aggressive inputs, wind, fuel exhaustion, engine failures and overtorque. Full per-update state hashes and sampled raw double bytes are retained.
- Keyboard/joystick checks cover 14,000 ramp/routing comparisons and 6,400 curve/axis comparisons. The key table contains 105 original registrations.
- Independent subsystem checks cover fuel, engine/rotor response, temperatures and hover with exact double-byte comparisons. There are 4,284 landing boundary cases.
- Weapon checks cover 8,640 speed cases, 2,160 lifetime cases, 6,912 damage cases and 49 seeker scenarios. Five controlled launch-to-impact cases repeat exactly, including lost-target ground impact and class-3 scheduled shell damage. Player avionics sequences and full moving AI battles now have separate integration traces.
- Local pages now expose controls, physics traces, weapons and original rendered reference frames. No content has been deployed.

- Remaining effects and interface extraction now covers 145 images, with 60 original loader comparisons. All 110 text pose files parse to 816 frames and are available in a channel viewer; their editor-specific channel meanings remain to be traced.

- Angular-rate and aerodynamic equations have 2,000 independent cases; failure logic has 2,000 exact cases and normalized flight inputs another 1,000. Forty original game-loop traces cover update order, slow-frame subdivision and acceleration. The mission harness now uses original key events and timer dispatch.

- Campaign and log checks now cover 720 mission selections, 56 terminal states, 40 result transitions, 80 save/load round trips, 80 snapshots, 1,200 awards/count cases, 220 pilot recovery cases and twelve campaign journeys. Another 2,346 debrief decisions cover pilot survival, landing, territory and target requirements. Mobile kill collection now has 400 complete formation tallies and 14,400 attribution checks, plus 2,400 record insertions across block boundaries. Forty complete debrief and log/discard callbacks now repeat twice, with original save serialization captured in memory. Full frontend navigation remains an integration task.

- Avionics checks cover 1,800 target priorities, 120 ranked lists, 216 target selections, 800 MFD controls, 600 TADS choices/projections and 100 lock-retention cases. Two complete input/render sequences produce 66 repeatable frames. Terrain visibility has 1,400 sampling comparisons and 986 defined obstruction-position comparisons.

- AI checks now cover 7,200 distance/weapon-selection cases, 4,000 firing permissions, 4,320 fire intervals, 600 acquisition delays and 4,600 sector-search/retention cases. Three mission-1 tank models acquire, launch and impact identically in two original runs. The local AI page documents the separate battle-cell path and the negative Tank Gun range. Three ten-minute moving-battle runs now repeat exactly, covering 4,574 launches, 129 kills and eight battle endings.

- Saved preferences now have 317 conversion cases, source-file round trips, original control menu setters and ten visual-detail levels. The music reader passes 270 seconds of exact PCM checking across the theme loop, speech interruption/restoration and standalone speech completion.

The [reconstruction handoff](analysis-review.md) records the verified foundation and the targeted research that continues alongside implementation.

### C++ implementation progress

The reconstruction now loads the original images, models, terrain, features and palettes; draws the original menu widgets; and assembles terrain, scenery, clouds, stars, sun/moon, moving objects, shadows, smoke, explosions, craters and detached debris. These have independent original-versus-C++ state and framebuffer checks, including sanitizer runs. The model shadow comparisons cover all 848 true-coordinate models. Ship-deck shadow receiving and hidden-player rendering are included. Dynamic night/weather/glare palettes, thermal rendering and complete RGB frames also have original-execution comparisons. All cockpit panels, redraw modes and night lighting now match at both original resolutions, as do both instrument fonts and all five moving mechanical instruments. Warning lamps, radio text, electronic display pages and MFD control/failure state also match original execution. The additional FLIR, weapons, radar, tactical and flight-plan pages now have exact framebuffer comparisons, including automatic target cameras, target highlighting, route scaling and arrival estimates. Moving-map rendering now matches 744 complete maps and 640 MFD frames, including contours, super-features and initialized ground-object symbols. The central gunner display uses the same verified FLIR page. Helmet flight instruments, all weapon cues and complete sight layouts now match original frames, along with world-to-helmet projection and flight-to-instrument state conversion.

The combined avionics pass now matches 147 complete mission-derived frames, with 27 additional cases using bounded handling for original missing normals. Runtime model metadata matches all 1,314 objects. Fuel, engine, rotor, temperature, failure, control-normalization, hover and landing routines match 9,602 cases and their warning/audio call order.

Gameplay is not yet connected to the frontend. The continuous realistic-flight model now passes 32 original-code traces, including carrier takeoff, across all four warzones. Arcade flight also passes 28 continuous traces and 6,000 exact component cases. All 110 missions now load and initialize their actors, formations and carrier assignments with exact original-code comparisons. Weapon definitions, acceleration/drag/expiry, damage, selection and firing timing also pass the complete normal and sanitizer checks. Complete actor movement and collision-volume routines now pass original-code comparisons in normal and sanitizer builds. Seekers, missile guidance, gravity, proximity detonation and terrain-impact subdivision now also pass original-code comparisons in normal and sanitizer builds. Projectile launch, pool updates, collision removal and smoke now pass continuous comparisons across all four warzones. Live target descriptions and full visibility queries also pass normal and sanitizer comparisons. Live guidance, countermeasure response, direct/area damage and combat effect construction now also match original execution. Actor firing now also joins selection, aiming, ammunition, deadlines and target release with matching original-execution checks. Task acquisition, target retention, radar-directed patrols, ground battles, terrain-masked radar coverage, contact grids and static defence dispatch now also have original-execution comparisons. All mission sector ownership, front distances and dynamic scenery setup match. All 110 mission radar initializations and initial contact grids also match, including original startup coordinate quirks and separate animation/combat flags. Live spatial updates and target searches now match across the shipped missions. Eight continuous movement/combat traces also match, including retaliation, patrols, stationary defences, ground battles and casualties; firing calls remain observed boundaries in those traces. A second continuous suite now connects live firing, guidance, automatic countermeasures, collisions and smoke, with 3,882 matching launches and 7,843,193 matching fields in normal and sanitizer builds. A third continuous suite applies damage, casualties, destroyed scenery and combat effects, matching 7,629,707 fields, 3,438 launches and 74 combat casualties in normal and sanitizer builds. Remaining implementation includes connecting these verified components into complete combat, connecting collisions to player flight, live sensor behavior, complete frontend/campaign interaction and audio, followed by full journey acceptance. The detailed comparison counts are maintained in `../apache-cpp/docs/implementation.md`; local reports are under `work/checks/cpp/`.


### Player runtime integration

Live player flight, carrier starts, takeoff, collision dispatch, deck attachment and carrier reservation changes now match original execution. Normal and sanitizer comparisons cover eight continuous traces and 2,400 deliberate contacts, matching 8,188,635 fields. Keyboard ramps, external-view routing, device setup and calibrated joystick response also match 36,784 fields. The shared mission runtime now owns the connections between actors, flight, weapons and combat damage; its combined acceptance is in progress. The windowed frontend still opens menus. Player weapons, live sensors, frontend/campaign integration, audio and persistence remain active work.

### Shared player mission runtime verification

The combined player battle now passes normal and sanitizer comparisons: 9,399,339 fields over 9,600 updates across all four warzones and both flight models. This includes player flight, collisions, AI, live firing and guidance, damage, destruction and player subsystem failures. Another eight traces verify slow-frame flight subdivision (1,561,448 fields), and 600 contact fixtures include 50 carrier landings followed by another flight update (42,350 fields). Keyboard and joystick sampling match 36,784 fields. Reports are in `work/checks/cpp/mission-player-battle`, `mission-timing`, `carrier-followup` and `controls`, with matching `-sanitize` directories.

The window still shows the menus. Next are player firing and sensors, connecting the shared runtime and renderer to the frontend, and campaign, audio and persistence integration. These checks do not substitute for an end-to-end playable mission.

### Player weapons connected

Weapon selection, safing, gun/rocket aiming, physical rack launches, laser designation, ammunition use, gun flash/sound, incoming-missile warnings, firing solutions and impact estimates now have original-versus-C++ comparisons. Eight live mission traces match 3,047,894 fields, including 1,326 player-launched rounds, in both normal and sanitizer builds. Component comparisons cover another 1,613,243 fields. Local reports are in `work/checks/cpp/player-weapons`, `player-mounts`, `player-sight`, `player-warnings` and `player-launches`, with matching sanitizer reports.

Next are live radar and optical targeting, followed by the playable frontend connection, campaigns, audio and persistence. The window currently opens the menus.

### Live targeting and camera integration

All 110 missions now pass live sensor comparisons: 5,500 scans and 22,000 optical selections match 11,852,651 fields. Targeting controls and automatic/manual waypoint changes also match. Eight connected sensor/combat traces match another 3,282,731 fields, 2,079 launches and 69 kills. Normal and sanitizer results agree.

All ten camera geometry paths and all twenty view choices match original execution, including optical devices, fault fallback and remembered magnification. Continuous view-state verification and binding the renderer to the live mission are now the active integration work. The remaining frontend, campaign, audio, persistence and complete game journeys still follow; the menu window is not yet a playable release.

### Live scene and instrument verification

Continuous camera, lighting and sight calculations now pass original-code comparisons. The renderer reads the shared mission objects directly. Four battle traces produce 60 scene frames; five frames avoid original invalid model reads and match all indexed pixels and RGB output. The remaining 55 use bounded handling for missing normals. A separate cockpit integration check matches 467,620 instrument fields and 1,170,510 simulation fields over 1,200 updates. Normal and sanitizer runs agree. The next connection is the playable window, followed by campaign, audio, persistence and full journeys.

### Playable session, campaign entry and debrief

The live session joins the verified simulation and renderer to the window. Original timer/key input and both video modes are supported, as are explicit pause, camera changes while paused, focus-loss key release and return to the frontend. Training, single missions and all three campaigns have menu entry, mission preparation, takeoff, debrief, retry and in-memory result logging. Campaign entry retains the separate opening overview and stage situation. Text wrapping/selection/scrolling matches 32 original frames, with another 20 exact vertical-scrollbar frames and the ten original static menu frames still matching.

The communications implementation passes 6,000 original-code operations (600,000 fields); pilot/campaign serialization and progression pass 2,476 cases; debrief decisions and record insertion pass 5,565 cases. Twenty complete mission-derived debrief fixtures match their explanation text and 1,880 serialized pilot bytes. Normal and sanitizer results agree. Each fixture states its supplied landing, destruction or crash condition; these are analytical comparisons, not claims to have flown entire campaigns.

Continuous live-session comparisons exposed two ordering requirements: aiming the chain gun uses the preceding barrel attachment transform, and selecting an explosion sample consumes the same Watcom random sequence used for wind gusts. The latter still matters with audio disabled. The gun correction retains all 3,047,894 matching player-launch trace fields, including 1,326 player-fired rounds. Wider integrated flight/frame checks are continuing under `work/checks/cpp/session-*`.

Next are persistent pilot profiles, full briefing/map controls, preferences, Quickstart and audio playback, followed by complete game journeys and CI. No publication or asset redistribution is part of this work.


### Persistent profiles and campaign presentation

Completed original-format user/pilot storage, logbook editing, campaign transfer after pilot loss, campaign ending screens, promotions and medals. Original menu comparison covers eight populated pilot screens (2,457,600 exact pixels). Restart, capacity, deletion, protected pilots, rejected saves, campaign endings and award journeys pass in normal and sanitizer builds. Saves remain outside source game data.

The complete four-warzone session matrix now passes: 1,896 frames, 142,200 state fields, 1,456,128 palette bytes, 106,255,220 defined cockpit pixels and 62,592,000 full-frame pixels across 326 frames without original invalid reads.

Next: preferences and original control selectors, full briefing/map tools, Quickstart and audio playback. No CI yet.

### Preferences integration

Original selectors, toggles, sliders, terrain preview and joystick calibration indicators are connected. Thirteen preference/popup frames match 3,993,600 original pixels. Three hundred axis/hat cases match 12,000 fields. Saved choices survive restart and reach live flight. Normal and sanitizer checks pass, as do the existing menu text/scrollbar and complete frontend journey checks. Sixteen previews cover four zones and four detail settings; Yemen at minimum detail is exact. The other views encounter missing model normals already covered by bounded renderer handling. The Korea discrepancy was traced to shaded lines in `copsed` (model 142) requesting normal 0 from an empty normal table. No emulation of that invalid read is added.

Next: Quickstart and its score table, remaining briefing/map controls, and audio playback.

### Quickstart and score table

All three Quickstart missions now run through the menu, with unlimited ammunition/fuel, Invincible mode, first-launch Preferences flow and saved high scores. The original score calculation matches 280 cases; six score-table frames match 1,843,200 pixels. Six live traces match 288 frames, 21,600 state fields, 221,184 palette bytes and 8,110,080 cockpit pixels. Normal and sanitizer menu journeys cover ties, insertion into a full table, editing, restart and training assistance. Complete ordinary frontend journeys remain passing.

Next: audio playback and the remaining briefing/map controls. No CI yet.

### Audio playback

Connected the original PCM effects, menu theme, spoken briefings and flight/combat sound events. Reference comparisons cover 189 effect payloads, 128 gain values, 430 speech filenames, 2,050 channel/priority results and a 270-second looping stream (11,880,000 matching PCM bytes). Speech interruption, completion and mission return retain original resume positions. Independent resampling and callback-size checks pass in normal and sanitizer builds. Host audio hardware has not been exercised by automation.

The longer Quickstart comparison exposed a static-scenery construction error: scenery must not instantiate the attached turret used by the equivalent mobile model. The corrected construction matches all 1,000 scenery frames. The extended session now passes 828 frames, including the radio-chatter interval, with 62,100 matching state fields, 635,904 palette bytes, 26,144,180 defined cockpit pixels and 14,361,600 pixels across 187 complete safe frames. Normal and sanitizer builds agree.

Briefing map navigation matches 5,082 original operations and 23,652 fields. The route overlay matches 400 frames and 122,880,000 pixels, including rotation, symbols, labels and route visibility. UI integration is continuing. Remaining integration: briefing/map interaction, remaining frontend screens and full game journeys. No CI yet.


### Briefing map integration

Connected drag zoom/undo/fit, rotation, right-click centering, route drawing, territory and threat layers, weather and payload selection. Tool windows can be raised, moved and closed. Original-code comparisons cover 5,082 navigation operations, 400 route frames, 32 overlay frames and 30 real mouse gestures. Twelve complete map/weather/payload frames across all four warzones match both indexed pixels and RGB output. Normal and sanitizer builds pass. The colour comparison identified the original grassy-terrain palette override also affecting payload art in Fort Hood and Korea; the reconstruction applies it at the same final palette stage.

Next are the 3D preview camera, waypoint editing and scripted briefing presentation, then remaining frontend screens and whole-game journeys. No CI yet.

### Live map preview and waypoint planning

The C++ map preview now has the original satellite, orbit and fly-to-point modes and a resizable window. Camera comparisons match 9,956 operations and 199,120 fields. Twenty window gestures match 320 bounds fields. Fourteen preview frames match 840,966 pixels; eighteen cases containing the previously identified invalid source normals stay outside exact frame comparisons. All fifty payload combinations match 3,465,500 RGB pixels and their final launched inventory.

The waypoint editor matches 3,050 original operations and 2,618,694 fields, including hit selection, dragging, fixed endpoints, append/insert caps, deletion, types, grid coordinates and leg timing. Thirty tool/information frames match 2,498,460 indexed and RGB pixels. Thirty route snapshots and the launched navigation route also agree. Numeric controls include the original expanded arrows, held repeat and digit menus. These comparisons pass in normal and sanitizer builds. Existing map and campaign journeys remain green. Reports are under `work/checks/cpp/map-{camera,preview,window,editor}`, `work/checks/cpp/waypoint-ui*` and `work/checks/cpp/payload*`.

An audit of all 149 mission text and bundle files found no `:Briefing` sections or brace commands. The retained camera-tour parser is unused by this CD's English, French and German data. Shipped briefings use descriptions and recorded narration. See `work/checks/briefing-script-audit/report.json`; reproduce with `tools/audit_briefing_scripts.py`.

Remaining frontend integration: joystick buttons/hat, in-flight help/preferences/quit confirmation, movie playback, first-launch asset acquisition and full game journeys. CI remains disabled while implementation continues.

Joystick buttons and hats are integrated and verified: 24,576 original decoder cases, 6,000 device-source cases and ten live flight traces. Help covers all 108 authored pages and 227 navigation checks; 18 full 800x600 frames match 8,640,000 pixels. Quit confirmation matches both original resolutions and freezes simulation until Y/N. Normal and sanitizer checks pass, with private-Xvfb checks for help entry/exit and both quit responses. These changes are pushed as 8f5a802 and 42f92c8.

The root filesystem filled during capture output. Generated C++ comparison PPM/pixel files were losslessly compressed, recovering 595 MB; the conversion inventory is `work/checks/cpp/compressed-captures.json`. Source media and analysis references were retained. Further large captures use `work/checks/` or `/tmp`; only selected evidence is kept here. No in-flight Preferences key exists among the registered gameplay keys; the original exposes those choices before takeoff. Remaining work continues with movie integration and full game journeys.

### Movies and first-launch setup

Original ANIM playback now covers all 26 movies and 5,217 frames, with 306,913,280 matching pixels and 4,006,656 palette bytes. The delta path matches all 256 byte masks. Campaign movie selection, audio suspension and intro/briefing transitions pass normal and sanitizer checks, with a private-window journey through campaign takeoff. Committed as b322940.

The exact selected CD is available as a standalone BIN in Archive.org item `redump-id-91728`. A fresh temporary download matches the intake SHA-256. The C++ installer extracts the 1,504 selected game files, validates source and destination contents, and leaves different existing files unchanged. Bash and Windows helpers verify the BIN with SHA-256 and remove it after extraction. Data-directory choices are remembered separately from original assets. Validation continues in `work/checks/cpp/installation*` and `work/checks/cpp/setup-window*`.

Installer verification now passes in normal and sanitizer builds: all 1,504 extracted files match independent SHA-256 records (305,373,380 bytes). Both BIN and ISO inputs, repeated installs, missing-file repair, existing-file preservation, corrupt-source rejection, path containment and fetch-helper cleanup pass. Private-window setup checks pass for explicit, remembered and default data locations and source-data protection.

### Multiplayer protocol

Implemented bounded APNET packet encoding/decoding. Original-code comparisons pass 2,240 packets across 35 message types, 176,892 defined bytes, 64 compressed-state decodes (14,336 fields), and 1,620 malformed-input cases in normal and sanitizer builds. See `network.md` and `work/checks/cpp/network-packets*`. Transport is intercepted during checks; no network sockets are opened. Shared pilot/gunner state and live session integration are next.

Shared cockpit contents and flight exchange now pass original-code checks in normal and sanitizer builds: 1,000 crew sends/receives, 1,000 key-queue sequences, 147 malformed crew records and 900 replication/extrapolation cases. Network transport, lobby controls and remote scene integration remain in progress.

Remote firing and aircraft placement now pass continuous original-code comparisons in both normal and sanitizer builds: 4,519,568 firing-trace fields and 4,538,391 moving-aircraft fields. The original remote Cannon Pod takes the guided-constructor flight flag despite its unguided definition; this behavior is retained. Network target resolution matches 5,567 queries, including scenery coordinate/sector boundaries. All six multiplayer mode rules match 1,536 cases and 18,432 fields. See `network.md` and `work/checks/cpp/{remote-weapons,remote-battle,remote-scene,network-targets,network-rules}*`. The next connection is player allocation, followed by lobby/transport and shared-cockpit sessions. CI remains disabled.

Aircraft allocation and restart now pass normal and sanitizer comparisons across all four warzones and the dedicated multiplayer/flag missions: 675 attempts, 108 revivals and 785 scene/contact-registry states, matching 24,857 reported fields. All four CTest targets and both application builds pass. Continue with casualty synchronization, shared-cockpit integration, transport and lobby controls.

### Network lifecycle and casualty integration

The event state machine passes 1,800 original-code cases (108,955 fields), and bounded casualty queues pass 400 batches (9,963 records, including 196 overflow rejections). Normal and sanitizer runs agree. Scene integration passes 360 sequences in six missions, including 108 restarts, with 439,192 compared fields. Both full applications and all four CTest targets pass. Scene sanitizer validation also passes with the same trace digest. Continue with shared pilot/gunner runtime integration, transport and lobby controls; CI remains off.

### Shared cockpit session integration

Connected seat-specific controls, radio, countermeasures, mission ending, frame exchange and live rendering. Both flight models pass paired 100-frame traces in normal and sanitizer builds: 400 seat frames, 30,000 fields, 41,600 crew bytes and 326 complete matching frames. Manual chaff/flare sessions, signed flight-plan speeds and mission-ending combinations also pass. The four-warzone/resolution matrix is running. Continue with complete APNET event exchange, transport and lobby controls, then final journeys and release verification. CI remains off.


### Complete shared-flight event exchange

Both original APNET seats now match the C++ sessions in arcade and realistic flight: 400 seat frames, 30,000 fields, 416 messages and 310 complete rendered frames. Normal and sanitizer builds agree. The receive barrier includes firing, chaff, flares and crash/collision events. Carrier attachment maintenance and post-receive navigation instruments preserve the original timing. Casualty-source generation, real transport and lobby controls remain next; the wider shared-session matrix and single-player carrier regression are running. CI remains off.


### LAN transport and lobby receiver

APNET now has a nonblocking UDP transport, with original packet contents inside a small versioned node-identity envelope. The connection table sorts peers while in the lobby, fixes connection slots during flight, and expires absent lobby peers after 20 seconds. Sockets are created only when requested. Loopback tests cover discovery, names, preferences, readiness, menu messages, flight delivery, return to lobby and disconnect, along with malformed datagrams and a full 16-player roster. Both normal and sanitizer CTest runs pass all five targets.

The menu branches of the original receiver match 1,200 cases and 82,414 state/event fields in both builds, including all twelve lobby message types. Trace SHA-256: `142cbd368bcbe9c6cc7bd80cd3951ca692ddfd668823ed038f0a5e44a541cc54`. The full shared-seat matrix also passes the sanitizer run with the same 3,200 frames and trace digest as the normal build. Connecting the actual network screens and all multiplayer mission modes remains in progress. CI remains disabled.

### Connected multiplayer screens and sessions

The original network and two-player screens now drive discovery, names, roles, preferences, readiness, shared mission selection and takeoff. Live sessions use the original peer or client/server exchange according to the selected mode. The obsolete serial/modem controls are replaced by LAN discovery and a direct host address. UDP carries the original APNET payloads in the reconstruction's transport envelope; it does not connect to the DOS game's IPX or modem drivers.

Five loopback journeys use actual menu clicks, two sockets and 80 seat frames per mode: two-player combat, single missions, pilot/gunner, multiplayer combat and capture the flag. They also cover departure, returning to the lobby and a two-player server handover. Broadcast is disabled in these tests. Normal and sanitizer builds pass all five journeys and all five CTest targets. The dedicated server/client departure comparison matches 800 original cases and 49,668 state/event fields.

The combat MFD now draws the original kill scoreboard. Mission initialization applies connection difficulty before constructing actors, and combat-only modes skip the ordinary AI war simulation. The six-mode original-session matrix is still running. Remaining multiplayer integration includes respawn, landing rewards, flag completion, following a surviving partner and chat input. CI remains disabled.


### Multiplayer acceptance and pose editor

The complete mode matrix passes in normal and sanitizer builds: 48 cases, 3,840 frames, 288,000 state/camera fields, 2,949,120 palette bytes, 172,815,553 defined cockpit pixels and 200,524,800 complete-frame pixels. A Mission 141 actor check matches all 154 actors in both flight models. Combat recovery, landing rewards, flag completion, chat and server handover are connected. Real-window journeys pass combat, shared pilot/gunner and network combat, with localhost-only transport. Reports are under `work/checks/cpp/network-session-final*`, `session-actors*` and `network-window-*`.

MANEDIT 1.05's model constructor, limb hierarchy, rotation order and interpolation are recovered. The pose viewer animates the actual editor figure, uses the authored duration and names the channels. See `poses/loader-trace.md` and `poses/native-check.json`. The six newer II/IC files remain raw-channel views because this editor does not support them.

Validation housekeeping removed 44 obsolete test executables from `/tmp`, recovering 4,121,121,168 bytes. Current binaries and build trees remain, as do compact reports, analysis views and tooling. The cleanup inventory is `work/checks/cpp/validation-cleanup-2026-11-05.json`. Working outputs now belong in ignored `work/` or `/tmp`; the analysis tree retains only selected evidence and viewer assets.

### Final release handoff

All six CI builds pass after replacing the transport test's fixed poll count with a bounded wait for actual delivery. Linux, Windows and macOS release packages are published. Each downloaded archive contains the same explicit nine-file runtime set, with platform-specific executable and setup helper names. Their checksums pass, and the released Linux executable matches the original main menu exactly. The local `../apache-cpp/build/apache` is also rebuilt and tested.

The earlier Windows comparison now maps 317, 325 and 330 routines in the three 1996 engines. Direct execution confirms identical sampled matrix, approximate-range, actor/waypoint positioning and common crater-update results. The notes distinguish these from the 24-to-36-byte crater layout change and the compiler's shared function tails.

Validation cleanup reclaimed 4,496,124,048 bytes from obsolete executable copies and the completed installer-test download. The manifest is `work/checks/cpp/validation-cleanup-2026-11-05.json`. Extracted media, analysis viewers, tools, reports and useful captures remain intact.