OpenBF1942-Plus
Refractor 1, rebuilt from scratch
Loading...
Searching...
No Matches
PROJECT_MEMORY

Append-only. Newest first. At most 3 bullets per stage.

2026-11-15 — Documentation site

  • GitHub Pages site built with Doxygen and doxygen-awesome-css (as OpenMOHAA-Plus), themed with the banner's colours and fonts: all docs/ pages plus the engine/ and tools/ reference. Theme fetched at build time, not vendored.

2026-11-15 — New banner and visual identity

  • docs/banner.svg replaced by the desert-dusk design; its fonts (Stardos Stencil, Oswald) embedded as woff2 subsets so GitHub renders them. Palette and fonts recorded in PROJECT_CONTEXT as the project identity.

2026-11-14 — B3: vehicle ammunition

  • Seats keep their gun's rounds (magSize / numOfMag, read from the retail FireArms); depots that workOnVehicles refill them by ammoType, single-magazine guns round by round. The vehicle HUD shows the count and fills the bar. Checked with a probe (an empty Sherman gets 10 rounds a second at a repair pad) and a forced-seat screenshot; tested; Berlin 300 s identical.

2026-11-14 — C2: HUD placed as the original

  • Vehicle HUD from each seat's setVehicleIcon / setVehicleIconPos / ammo icons and bar kinds, placed as measured (checked on a forced-seat screenshot of a Sherman).
  • The radio menu drawn as the original's button row (menu/texture/radio/ icons, slots measured on captures of each category; F8 toggles it); the captures confirm the decompiled key layout.
  • Maintainer captures of the original client (1920 × 1080, kept out of the repository) show an 800 × 600 layout stretched per axis; health, ammunition panel and magazine (setAmomBarPosX/Y confirmed), tickets with flags above a top-right minimap with its grid, feed top left, measured and drawn so. Tests updated.

2026-11-14 — C2: health bar and magazine textures

  • The kit's healthbar_* texture filled from the bottom and the weapon's setAmmoBar magazine filled by rounds over setAmmoBarSize rows (the art's height, checked on the pistol: 41 rows). Placement ours (menu/InGame is a MemeFile). Checked on screenshots (assault BAR, engineer No4); tested.

2026-11-14 — C3: mesh particles, first-person muzzle flash

  • Particle templates draw their geometry (blending from its .rs: the flashes add). Emitters carry their view flags; the renderer spawns the held weapon's first-person emitters at its muzzle (the weapon's setPosition for the effect) and draws them with the arms. Checked on a screenshot (Thompson, first person); tested; Berlin 300 s identical.

2026-11-14 — C3: dust, exhaust and wakes

  • Effects on vehicle parts (track and wheel dust, exhaust, bow waves, plane water touch) run while driven, over the materials their bundle lists (addWorkOnMaterial, 1 = water) and scaled by IntensityAtSpeed. Checked on a driven Sherman (the material-10 dust variant emits; the other stays off); Berlin 300 s identical.

2026-11-14 — C2: minimap

  • The level's colour tiles shrunk into one texture (water tinted) drawn top left, north up, 250 m around the player, with setMinimapIcon markers: flags by owner, vehicles turned to their heading, teammates, the player. HUD quads now carry a texture and an angle. Checked on a screenshot (El Alamein base); layout tested.
  • Open: the original HUD textures (menu/texture/ingame/), .dif fonts, capture progress icons.

2026-11-14 — C3: sprite effects

  • engine/effects.*: EffectBundle / Emitter / SpriteParticle templates parsed and simulated on the CPU (CRD_* values, over-time curves, colours, frame grids), drawn as sorted camera-facing sprites. Shown: muzzle flashes, shot end effects (explosions), MaterialManager impacts, addArmorEffect damage smoke / fire and destruction effects.
  • Checked on screenshots (a Sherman's shell exploding ahead; a damaged Sherman smoking and burning); synthetic test; Berlin 300 s identical (effects use their own random generator).
  • Open: mesh particles, first-person muzzle flash, dust and wakes.

2026-11-14 — B2: bots use pistols, mines and packs

  • A bot whose primary has no round and no magazine fires its kit's pistol (drawn and animated as it); engineers lay mines near flags their team holds and drop packs by enemy-crewed vehicles, set off once out of the blast. Placed charges now record their owner, so the player's detonator sets off only the player's packs. Rules guessed.
  • Berlin 300 s: 15 mines laid, no wrecks, no packs (no enemy vehicle came within 6 m); tickets and deaths within one of the previous run. El Alamein: no mines (its engineers rode vehicles). Pistol fallback not seen in a 300 s run (bots rarely run dry).

2026-11-14 — copyState weapons; out-of-ammo slide lock

  • copyState (not only copyState2) creates the per-weapon states of the K98, both snipers, the Panzershreck and the Walther P38: they had no arm, fire or reload animations. Weapon states take the weapon's own animation first. Checked by dumping the loaded states.
  • With no rounds and no spare magazine, WeaponOutOfAmmo<w> holds the slide / bolt back.

2026-11-14 — Held weapon parts placed on their bones

  • The maintainer's screenshot showed the Colt's slide always back: the 180° turn on held weapons was applied before each part's bone offset, mirroring it. Turning the meshes after the offsets puts the slide over the barrel and the MP40's magazine in its well (checked against mesh bounds).

2026-11-14 — B2: movement animations; legs at their own speed

  • Swim, ladder (up, down backwards, idle), free fall, parachute and jump states replace walking, hiding the weapon where the state does; pose() plays negative speeds backwards (tested), and legs now run at their own state's speed (Lb_RunBackward had been playing forwards).
  • Single-shot (fireOnce) fire states now play once from the shot instead of looping at the clock's phase.
  • The maintainer saw a pistol slide stay back after a reload: not reproduced (states clear, data has the slide forward at rest and at the reload's end); asked for details. Berlin 300 s identical.

2026-11-14 — B2: ladders

  • c_CGLadders objects become climbable boxes in physics: walk into one to climb (2.5 m/s, guessed), back off to climb down, stand still to hold on; SoldierClimbLadder while climbing. Tested on a synthetic ladder.
  • 78-level sweep: all exit cleanly; only Aberdeen changed (one more stuck sidestep). The sweep script lives in the scratchpad again (sweep.sh: 16 at a time, 45 s).
  • Open in B2: swimming / jump / ladder animations, bot pistols, bots with mines and packs.

2026-11-14 — C1: soldier sound triggers read from the animation states

  • animations/AnimationStates*.con name each state's sound (setSoundTrigger, 72). No state uses Charge, so bf1942 never plays SoldierCharge; SoldierSwimStand is floating, not leaving the water. Added SoldierStop and floating; landing sounds have the original's 1 s cooldown.
  • Our soldiers still start these from physics events, not state machines. Berlin 300 s identical. C1 is complete for bf1942 except ladders, which need ladders (B2).

2026-11-14 — C1: radio, gear, medic checked against the Mac client

  • The decompiled Mac client gave the radio key layout (local confirm sits on F3–F6, vehicle swaps by kind, conquest page by control point with attack / defend by owner), TicketLow at 20 %, gear defaults 30 / 20 m and 0.65 / 0.85 with patch 0 going up, and the medic healing the first hurt teammate in range. All applied; Berlin 300 s identical.
  • Found: bots never send radio; soldier sounds in the original start from animation-state triggers (our physics events are a stand-in), which is also where SoldierCharge lives.
  • Open in C1: SoldierCharge (animation-state triggers), CTF radio page.

2026-11-14 — B2 / C1: medic pack heals

  • MedPack (magType 1) is now a kit weapon: rounds heal the teammate aimed at within healDistance, else the medic (healFactor / selfHealFactor as hit points per round, unverified), with SoldierHealedByMedic. Headless: 10 → 24 of 30 hit points in 10 s, 10 heal sounds.
  • Bots keep their first weapon with a projectile (primary skips packs); Berlin 300 s identical.
  • Open in C1: SoldierCharge, bots on the radio. Bots do not heal yet.

2026-11-14 — C1: radio and announcements

  • Radio menu from menu/RadioMenu's strings: F1–F7 categories, F1–F8 messages, drawn in the HUD with lexiconAll.dat texts (parser tested); team messages crackle and play MenuRadioSound, local ones SoldierVoice. Key order per message unverified. All 45 messages play existing files (headless run).
  • Seats moved from F1–F8 to number keys, as the original binds them. GamePlay.ssc announcements: flag gained / lost, ticket bleed starting, tickets below a quarter.
  • Open: bots on the radio, SoldierCharge, medic healing; the maintainer to compare menu keys with the original.

2026-11-14 — C1: landing gear, swimming, falls

  • Aircraft gear goes up and down by its setGear* values (rule guessed) and plays its LandingGear patch while moving; the mixer gained trigger Release (tested). A headless flight: gear up at 25 m on full throttle, 2 s of gear sound.
  • Swimming state in physics (tested: floats 1.4 m deep), with splash in / out and strokes; free falls past 10 m/s loop SoldierFallingHigh until ground, parachute or water (bail-out at 87 m: wind from 1 s, ended on landing). Soldier patches play whole only when they mix triggered and untriggered layers.
  • Berlin 300 s identical. Open in C1: radio and callouts, charge, medic healing.

2026-11-14 — C1: voices, parachute, depot refills

  • Hurt soldiers say SoldierHitDamage (once a second at most), dying ones SoldierKilled, in the template's setRadioLanguage (@Language folder; Canadian falls back to English). The earlier note that these scripts are empty at HIGH was wrong: their voices sit under sound/<rate>/<language>/.
  • SoldierOpenParachute when a parachute opens; SoldierRefillAmmo when a depot adds a magazine (Ammo::supply now says so, tested). Every voice path resolves for the 7 soldier templates; Berlin 300 s identical.
  • Open in C1: radio and callouts, charge, swimming, falling wind / scream, medic healing, landing gear; the maintainer has not heard these yet.

2026-11-14 — C1: jumps, landings, posture changes

  • Soldiers play SoldierJump when the physics takes a jump, SoldierJumpLand on touch-downs above 3 m/s (ground patch), and the four posture scripts; physics counts jumps and landings per character (tested). Game results unchanged (Berlin 300 s identical).
  • Rejected: jumps inferred from leaving the ground while rising, 1,091 jumps against 62 landings on Berlin (bots climbing rubble).
  • Open in C1: radio, voices, swimming, parachute, landing gear, refills; the maintainer has not heard the new sounds yet.

2026-11-14 — native Windows build

  • The engine builds with MSVC 14.29 and vcpkg (SDL2, libepoxy, pkgconf); engine tests pass on Windows. Command in SYSTEM_SUMMARY.
  • Fixes: the matrix header renamed from math.h to engine/mat.h (MSVC's <cmath> picked ours up through -I engine); Jolt on the /MD runtime like SDL2; SDL_MAIN_HANDLED so no SDL2main.
  • The maintainer played it natively: runs fine, but the mouse was inverted on both axes. The earlier flips compensated WSLg, so they now apply only under WSL (WSL_DISTRO_NAME). Open: audio stalls check on the native build.

2026-11-14 — audio stalls traced to WSLg's device

  • The maintainer heard stutter again after minutes. A per-5-s timing log showed our callback under 2 ms while the gap between callbacks grew from 23 ms to 3.7 s; not changed by 512 / 1,024 frames or 44.1 / 48 kHz. Confirmed outside the engine: a bare SDL device with no window feeding silence stalls the same way (0.9 s at 75 s, 4.9 s at 3 minutes).
  • An offline bench (driving and a full Berlin battle, no device) mixed in at most 1.1 ms per frame, with voices rising and falling.
  • The mixer now caps voices at 256 (oldest one-shots dropped); blocks back to 1,024 frames. Next check: a native Windows build.

2026-11-14 — C1: vehicle parts, shells in flight, footsteps, ambient; player starts at a spawn

  • Vehicle parts with their own scripts loop (engine, tracks by speed, turrets by measured turning rate, wings); the mixer reads Speed and Acceleration curves. Shells and rockets loop their whine in flight; soldiers step by speed, posture and ground material; map objects loop their ambient scripts. Game results of the 78-level sweep unchanged by the sounds.
  • The maintainer saw no map in the listening tests: --play without --cam started the player in the map's corner (under water on Berlin). It now starts on a spawn point its team owns (5 one-sided levels keep the corner).
  • Open in C1: radio, voices, jumps / landings / swimming, landing gear, refills.

2026-11-14 — audio heard by the maintainer: stutter, knife, reload fixed

  • Stutter and delay: one lock covered file loading and the voice list, so the audio thread waited on archive reads. The mixer now locks only its voices.
  • Knife and reload were silent: trigger Volume layers (151 scripts) start when their volume rises; we played them from time 0, so short clips ended unheard. Implemented with a mixer test; device blocks 1,024 → 512 frames.
  • Maintainer: shots, grenades, knife and reloads now play; a fixed delay remains, suspected to be WSLg's audio path.

2026-11-14 — C1: impacts, explosions and every driven engine

  • A shot's end plays its effect's sound: the projectile's endEffectTemplate, else the MaterialManager setEffectTemplate for its material against the target (body part, armour, terrain material map). Physics hits now carry the shot id; Game::fire wraps every shot.
  • Every vehicle with a driver, bot or player, loops its engine (Sounds::engines); the 78-level sweep's game results are identical to before.
  • Open: projectiles in flight, aircraft wings and gear, soldiers, ambient; nobody has listened to the new sounds yet.

2026-11-14 — B1: opening nav cells from collision rejected

  • Opening blocked infantry cells where vertical rays at 0.4–1.6 m find no collision made Stalingrad (63 → 227) and Battleaxe (1,065 → 1,695 stuck) worse and did not help Berlin: the rays miss low rubble and thin fences that physics blocks. Reverted; recorded in pathfinding.md.
  • Also rejected: walking a bot stuck in a blocked cell back to its last free spot (captures 52 → 51, stuck events doubled by loops into the same trap). B1 left with the visible-exit route and the vehicle-target rule.

2026-11-14 — B1: bots stop duelling vehicles they cannot hurt

  • Berlin's Soviet bots stood for minutes firing rifles at a bot in a Hanomag (5 damage of 100 per hit). Infantry now skips vehicles its weapon would need more than 10 hits to destroy (threshold guessed, in debt.md); Berlin's attackers end 11–19 m from their flags instead of 45–68 m.
  • 78-level sweep neutral (captures 54 → 52, bot deaths 154 → 141, fewer pointless fights); no errors.
  • Open: Berlin still captures nothing in 5 minutes; bots stand on 1 m ruin walls the infantry map marks blocked.

2026-11-14 — B1: bots leave blocked cells through a visible exit

  • Berlin's stuck events were 83 % in cells the infantry map marks blocked (spawns inside building footprints); the planner snapped to the nearest free cell behind a wall. Game::route now heads first for the nearest free cell in sight (physics ray, 15 m).
  • 5-minute games: Berlin stuck 134 → 72, Stalingrad 204 → 91; 78 levels: 7,010 → 6,427, captures 51 → 54. Rejected: a 1 m grid (worse in both cities).
  • Open: Berlin and Stalingrad still capture no flag in 5 minutes.

2026-11-14 — back to the roadmap; collision choice re-measured

  • The 2026-11-10 rejection of the last collision block (El Alamein stuck 33 → 474) does not reproduce with today's engine: 5-minute games 39 → 29 there, and lower on Gazala, Battleaxe and Stalingrad; Tobruk, Wake and Berlin up 9–21 %. The last block stays; pathfinding.md and debt.md updated.
  • Roadmap E0 row updated to the decoded state; next in order is B1 (cities).

2026-11-13 — object descriptors understood, 97 % of ghost updates

  • Descriptor rules found (_analyseObject, compareProperties) and checked bit-exactly: tree order, child PlayerControlObjects are separate ghosts (next id), every networked instance is a property except rotational bundles with identical controls; widths from template ammo and gear counts.
  • Berlin's T34-85, Hanomag, stationary MG and vehicle MG seat decode completely (turrets, weapons, gears); 7,130 of 7,342 ghost updates.
  • Open: layouts from templates (server template numbering differs from our script order), springs' high compression table, a hand weapon and small spawn objects.

2026-11-13 — player, score and spawn managers; 92 % of ghost updates

  • Player (deaths, teamkills, score, kit, respawn countdown), score manager (two team blocks with tickets, score, deaths) and spawn manager (24 groups on Berlin, positions / 8) decoded, each checked against the events and the server log.
  • Unnamed created objects are classified by fit: vehicle when body + engine decode within 5 m of the creation spot. 6,737 of 7,342 ghost updates of the recording now decode.
  • Open: static guns, hand weapons, small objects; the vehicle components after the engine.

2026-11-13 — grenades, flags and kits in ghost updates

  • Projectile (12-bit quaternion), control point and kit readers added; ghost decoding now takes an id → class map that track_classes builds from the events. 881 grenade updates read exactly their length.
  • Ground truth: both grenades that killed the player land 2 and 4.6 m from the death positions in the server's XML log.
  • Open: hand weapons, the managers (ids 1, 513, 514), the class of objects no event names.

2026-11-13 — vehicle body and engine in ghost updates

  • A vehicle's update is its body (SimpleObjectNetworkable) and engine, then the other networked components; components sharing a networkable info read the same bits once. bfnet.py decodes body and engine: 1,474 updates, first positions within 1.2 m of the creation spot; the engine ends with a per-update sequence number.
  • Compressed-vector mode 1 is 20 bits per component, fitted from the update lengths.
  • Open: the order of turrets, springs and weapons after the engine (all zero in this recording: one bit unexplained); needs a session with another player in a tank.

2026-11-13 — soldier ghost updates decoded

  • Ghost updates are per-descriptor lists of net properties read by networkable components. The soldier's reader (mask-driven position, rotation, velocity, animation states, state bits) is in bfnet.py: 180 updates read exactly their declared length, positions match the control position and the log's death spot.
  • Widths the decompilation hides were fitted from update lengths: compressed-vector modes 2 / 3 = 16 / 12 bits, quaternion 16, animation states 11.
  • Open: vehicle, weapon, projectile, control point and manager readers; the soldier's ammunition field width.

2026-11-13 — game events decoded

  • The 51 game events (ids from the Mac client's GameEvent::initEvents, layouts from each deSerialize) are in bfnet.py; every data packet of the recording now decodes to its last byte. readUnsigned(min, max) is range-coded, which the first attempt missed.
  • Matched against the server's XML log: spawn requests carry team and kit, CreateObject carries template, networkable id and exact position, vehicle enter / exit, score kinds 1 / 4 / 7, round status.
  • Open: action values, per-object ghost updates, the download section.

2026-11-13 — second recording, payload walk verified

  • 14-minute session (three 5-minute Berlin rounds, tanks entered, deaths) with the server's XML event log, kept outside the repository with the player's data. Every action and ghost section decodes to its last byte (24,223 client, 15,924 server payloads).
  • Transport type 5 is the disconnect; the server tick runs at 30 Hz and restarts each round.
  • Next: the game events (196 packets) against the event log's ground truth.

2026-11-13 — master server protocol documented

  • network.md now has the GameSpy 2002 master-server exchange from keowu's research: TCP 28900, \basic\secure\ challenge, validate + enctype 2, the server list as 6-byte query-port entries ending in \final\, then \status\ to each server. All unverified.
  • Open for E2: the validate algorithm and secret key, enctype 2, server heartbeats to the master.

2026-11-13 — static collision uses the detailed block

  • Meshes with two collision blocks now collide on the last (detailed) one; the first is often a stub (2 faces on the suburb houses). 78-level sweep: no errors, stuck sidesteps 9,810 → 7,010, bot deaths 98 → 146, captures 54 → 51.
  • Checked and left alone: textures named only by file name resolve through each level's alternativePath, already handled; the 41 non-power-of-two retail textures are all loading screens and fonts.
  • Material map orientation verified (row = z): no spawn or flag of the 21 base maps lies on material 7, the original's outside-the-world material. Outside damage not implemented: its default values are unknown (debt, step D).

2026-11-13 — payload structure from the Mac client

  • The payload is a 6-bit mask of stream managers (actions, events, ghosts, downloads) and their sections in id order; it explains every prefix seen in the recording, and the bit-94 floats are the player's control object position. bfnet.py payload walks actions and ghost entries.
  • The 2026-11-10 recording was lost with its session scratchpad, so the walk is checked only on synthetic packets; recordings must live outside the scratchpad (still outside the repository).
  • Open: game event readers, action values, per-object ghost updates, compressed-vector bit widths.

2026-11-13 — external sources reviewed

  • Ten third-party BF1942 repositories reviewed; seven kept in docs/references.md with licence and allowed use (port GPLv3 code with attribution; facts only from unlicensed or decompiled sources, never committed).
  • Key find: decompilations of the Linux dedicated server and Mac client keep DICE's symbol names (BitStream, ghost manager, networkables), the next lever for E0.
  • Rejected: librfa, RefractorForgeLivery, RefractorForgeArchive (nothing beyond what we have or RefractorForge).

2026-11-10 — game transport decoded

  • tools/bfnet.py: header (6-bit sequence and ack, 4-bit type, 32-bit received mask), data length, ping / pong clocks; holds on every packet of the recording. The relay that recorded it is its record command.
  • Payload is an LSB-first bit stream with length-prefixed strings; client frame and server tick counters found. Message layout still open.

2026-11-10 — README and license

  • README rebuilt on the OpenCoD2-Plus model (banner, screenshots rendered by our engine, transparency, notice) in six languages; gameplay called an early prototype, not playable.
  • License chosen: AGPL-3.0, so modified servers also share their source; same as OpenCoD2-Plus Server.

2026-11-10 — repository moved

  • The repository moved to the account OpenGamePlus (private, history kept); commits are now signed with that account's noreply address. Its gh token has no workflow scope: changing .github/workflows/ needs gh auth refresh -s workflow.

2026-11-10 — Berlin ground still open

  • The original's Berlin street is about 2.4 times our colour tile there, while El Alamein's sand matches tile ×1. Ruled out: a ×2 on the terrain, denser fog, a shifted colour map, patched tiles. Lead: Terrain.ShadowAmbient (per level).
  • Sand tint fixed: the detail texture is now normalised by brightness, not per channel.

2026-11-10 — vehicle colour and barbed wire

  • Vehicles looked less yellow than in the original because the sun was mirrored. sunLightDirectionVec with x and z negated brings El Alamein's tanks from 54/40/29 to 78/59/40 (original 88/67/44), with the sun opposite the baked terrain shadows.
  • Cut-out textures are tested at full resolution, so barbed wire no longer vanishes beyond 10 m.

2026-11-10 — first-person arms matched to the original

  • Against the El Alamein screenshot (Thompson): set1pFov read as the field of view drew the arms nearly twice as large, and the legs' 3p animation lifted the gun. Now the 1p animation plays alone, with a 0.75 rad field of view and no center1pHands x, all fitted by eye.

2026-11-10 — same-spot comparison with the original

  • Our camera was matched to the maintainer's Berlin screenshot, using the parked tanks and the tank stoppers (rh_tsp_M1) as landmarks. The field of view is the same; buildings and haze match within 10 %.
  • Only the terrain is darker: ×1.85 at that spot, ×2.2 at the first spot. An El Alamein capture at the same spot (the Allied flag facing the factory) shows the sand already matches, so the ×2 is rejected and the Berlin gap is something else. The sky rule became "fogged as geometry 250 m away", which gives a blue sky over El Alamein and a sepia one over Berlin, as in the original.

2026-11-10 — compared with the original client

  • Berlin, with the maintainer spawning in the original and screenshots taken; we rendered from the same base's spawn points. Gaps by size: no terrain detail texture, colour and lighting too cold and dark, haze too far, faceted lighting on soldiers.
  • The vertical mouse axis is flipped, at the maintainer's request. Soldiers get smooth normals, recomputed each frame from the posed triangles with welded seams, instead of face normals. Terrain detail texture and anisotropic filtering added. Rejected: a ×2 on the terrain tiles, which matched one Berlin street but whitened the desert maps. Fog now uses each level's renderer.fogStart / fogEnd (Berlin 0–100 m, a sepia haze from the camera on), and the sky is washed towards the fog colour.

2026-11-10 — first live test by the maintainer

  • They saw the map and heard the shots; the reload animation was almost complete. Two bugs fixed: a shot left a sound looping, because the patches were merged; mouse look needed the right button.
  • Patches are now used by role (0 shot, 1 reload, 2 distant, 5 automatic loop with stop FinishSample). Playing captures the mouse (F10 frees it). Second test: loops gone, third person fine; the mouse feels inverted (axis unknown; the code turns right with the mouse and looks down with it), the player model flickers, textures look incomplete. Reload animations were cut halfway and are now fitted to reloadTime.

2026-11-10 — first network recording (E0)

  • Elevated pktmon sees only LAN broadcasts: the client sends a GameSpy \status\ to port 22000, and same-machine traffic is loopback. A UDP relay in WSL (a separate host) recorded a full 5-minute session: 14,707 packets. The query protocol on port 23000 is documented.
  • Kept out of the repository: the recording (player name, CD-key hash). Next: decode the bit-packed game packets.

2026-11-10 — landing craft and ship spawns (roadmap B3)

  • Spawn points inside ships (teamOnVehicle 1 spawners) belong to the spawner's team and move with the ship: 1,936 bots over 78 levels (was 1,689), 5 levels still one-sided (Battle of Britain ×3, Santo Croce, Essen).
  • Bots carry passengers in troop boats and land them at the beach (40 m from the flag or aground).

2026-11-10 — vehicle seats (roadmap B3)

  • Nested PlayerControlObjects read as seats: each has its own weapon, mouse-look parts, SeatObject position and exit. The player enters the first free seat and changes with F1–F8.
  • Bots board land vehicles and drive them to flags on the tank path-finding map. Armed seats aim with the seat's mouse-look and fire. Stuck drivers back out, then give up. Over 78 levels: 718 boardings, captures 57 → 78, bot deaths 368 → 173 (crews resist rifles).
  • Seated soldiers drawn per seatFlags with the seat animations, pelvis on the SeatObject (checked on a Willys). Open: pilots and boats, entry points.

2026-11-10 — fire and reload animations (roadmap B2)

  • Fire (looping) and reload (play once) upper-body states and the weapon's own WeaponFire / WeaponReload skeleton animations play for the player (both views) and bots. The upper body has its own speed and start time.
  • Open: the state machine's transitions, weapon switch / deploy, recoil and sway.

2026-11-10 — first person (roadmap B2)

  • Live play starts in first person (V toggles). It uses the original 1p arms and the states' second (1p) animation, hung from the camera by center1pHands, and drawn in a last pass with set1pFov.
  • Open: fire, reload and switch animations; the 0.47 field-of-view reading.

2026-11-10 — animation fix and held weapons (roadmap B2)

  • .baf quaternions are now read conjugated, and biped roots get a quarter turn from Max space instead of being dropped. Soldiers no longer lean back about 28°; legs, height and knees check out. Rejected: our own two-hand barrel rule, which hid the real error.
  • Soldiers hold their weapon on its skeleton (useSkeletonPartAsMain, bindToSkeletonPart, copyState2 per-weapon arm states); a 180° turn on the main bone was fitted from the left-hand position. Open: first person, reload / fire arm animations.

2026-11-10 — parachutes and fall damage (roadmap B2)

  • setParachuteDrag read as quadratic drag (24 / 100 kg: 6.4 m/s descent). Space while falling opens it, and the model is drawn above the soldier. Landings above 10 m/s hurt; guessed.
  • Open: bots take no fall damage; the original's opening rules are unread.

2026-11-10 — crouch and prone (roadmap B2)

  • The player crouches (ctrl) and lies down (Z). The capsule shrinks, so shots pass over a prone soldier. Speeds are guessed, standing up needs room, and the crouch / lie animation states play.
  • Bots crouch (scouts lie down) while fighting and throw grenades at 12–35 m. Over 78 levels in 5 minutes: 302 grenades, bot deaths 258 → 368, flag captures 68 → 57.
  • Open: prone capsule upright, posture transitions.

2026-11-10 — explosions and kit weapons (roadmap B2)

  • Projectile radius read: material2 damage hits everything within it, falling off linearly (unverified); fuses that run out explode. Over 78 levels bot deaths 236 → 258.
  • The player carries the whole kit (keys 1–9), each weapon with its own magazines. dieAfterColl 0 projectiles bounce and rest: grenades on their fuse, mines near vehicles, explosive packs on G. Open: bots using secondary weapons.

2026-11-10 — magazines and reload (roadmap B2, first part)

  • magSize, numOfMag, reloadTime and fireOnce read. Player and bots count rounds, reload on empty or with R; the HUD shows rounds / spare magazines.
  • Supply depots read (1,567 over 78 levels): ammunition and health within their radius; bots out of spare magazines walk to one.
  • Bot deaths over 78 levels in 5 minutes fell from 494 to 236. Measured: reload pauses cut bot shots by about a third (El Alamein 663 → 445); running dry was not the cause. Kept, as it is the original rule.

2026-11-10 — HUD (roadmap C2, first part)

  • .font decoded (glyph x0 y x1, gray TGA type 3 added to the decoder). An on-screen overlay replaces the window-title HUD: crosshair, tickets and flags, health, weapon, vehicle hit points, a feed of kills / captures / wrecks, round result.
  • Open: original HUD textures and layout, .dif fonts, ammo (needs magazines, roadmap B2), minimap.

2026-11-10 — audio (roadmap C1, first part)

  • SDL2 device plus our own mixer (ADR 0006); .ssc layers with distance / time / control curves; every shot and the driven vehicle's engine play. Templates now record their script folder (relative loadSoundScript paths), in both CON interpreters.
  • Sweep: every template's script in the three mods parses, every referenced .wav decodes; HIGH level chosen because some scripts ship only High/.
  • Open: soldiers, impacts, explosions, ambient, radio; real engine rpm; not heard by a person yet (built remotely).

2026-11-10 — AI navigation (roadmap B1)

  • Level-0 path-finding maps decoded (tile markers 0 / 1 / bit tiles, 1 = blocked; all 207 parse, aligned with level objects). Bots route with A* on a 2 m grid: over 78 levels stuck sidesteps −32 %, bot deaths +36 %.
  • Goal hysteresis added (bots swapped between equidistant flags every step). Tried the detailed (last) collision block for static meshes: worse on open maps, rejected.
  • Open: cities (Berlin, Stalingrad: spawns inside buildings, doorways), levels 1+ of the maps, 13 levels without level-0 maps.

2026-11-10 — second network capture attempt (E0)

  • Relays on the query port (with game-port rewriting) and the game port saw no packet: the client reaches the server another way. The server's query port follows game.gameSpyPort; ASE is game port + 123.
  • Config changed for seconds and restored byte-identical again; no process or file left behind.
  • Next: one elevated pktmon capture with the maintainer present.

2026-11-10 — consolidate (roadmap A)

  • mapview.cpp (~1,400 lines) split into engine/game.* (headless game layer), engine/render.* (GL) and thin mapview.cpp; new obf_sim runs the demos without a window; CI on GitHub.
  • Proven equivalent: old and new builds give identical --shot logs and images on five scenarios — after finding that moving code changed results by 1 ulp: Jolt's -mfma reaches our sources, so the compiler fused multiply-adds differently per file. Our code now builds with -ffp-contract=off (needed for replays and network sync).
  • Open: obf_render still includes game.h for its view types.

2026-11-10 — first network session attempt (E0)

  • Ran the original server and client on the maintainer's machine (allowed, maintainer remote): Berlin loads, but no packets captured — the client discovers LAN servers and connects to the reported address, bypassing a relay on +joinServer's address.
  • The server reads only Mods/<mod>/Settings/ServerSettings.con; its port was changed for seconds and restored byte-identical (sha1 checked). No other install file touched.
  • Next: relay that also answers the LAN query and rewrites the port, or one elevated capture with the maintainer present.

2026-11-10 — roadmap

  • Maintainer goal: play with original BF1942 clients and servers (ADR 0005); all phases in scope, order delegated to the agent.
  • Order: consolidate the code, start protocol research early (riskiest, shapes the game layer), then AI navigation, audio, HUD, gameplay completeness, fidelity measurements, modes, menus, networking, rendering, distribution.
  • Open: maintainer runs the original game for captures (E0) and measurements (D).

2026-11-10 — conquest

  • engine/conquest.*: flags neutralise and capture by who stands in their radius, tickets bleed and drop per death, a team at 0 loses; spawn points follow their flag. Bots on both teams target the nearest visible opponent; window title is the HUD.
  • Straight-line bots got stuck behind buildings (11 of 11 still "running" after 5 min); a 2 s stuck check with a 1.5 s sidestep fixed most. A simulated El Alamein game ends after ~32 min.
  • Open: path finding, real conquest rules, vehicles for bots, other game modes.

2026-11-10 — first AI, control points

  • Enemies see (line of sight), turn, fire with aim error, and otherwise run to the nearest flag their team does not hold; the player takes damage, dies and respawns at home.
  • Control point instances were missing in both interpreters: ControlPoints.con is run bare and re-checks v_arg1 == host. A bare run now keeps the caller's arguments; C++/Python parity re-checked (78 levels, 0 mismatches).
  • Open: path finding, capturing and tickets, AI in vehicles.

2026-11-10 — teams, kits, enemy soldiers

  • --play 1|2 takes the team's soldier (game.setTeamSkin) and kit primary (game.setKit, --kit); enemies stand on the other team's spawn points (SpawnPoint group → ControlPoint team) and can be shot dead.
  • Soldiers are hittable through a Jolt inner body on their character; killed ones are parked under the world so shots pass.
  • Open: AI, spawning on carriers, secondary weapons.

2026-11-10 — weapons and damage

  • Damage = materialDamage × damageMod(attGroup, defGroup) from the MaterialManager files the engine runs; the target is the armour material of the collision face hit. Sherman shells need 3 front / 2 side / 1 rear hits on a Sherman and 13 on a Tiger's front: the retail armour design shows through.
  • roundOfFire is rounds per second (first read as seconds: a Garand fired every 3.2 s). Destroyed vehicles switch to their wreck detail level.
  • Open: explosion radius, effects, magazines, kits, soldiers as targets.

2026-11-10 — parked vehicles are drivable

  • Spawner placements that can move become physics vehicles; E gets into the nearest. build_scene returns spawn points; build_object no longer follows nested spawners.
  • Sweep of 1,546 parked vehicles found real defects: spawns under our terrain fell through it (now lifted), a carrier's single convex hull threw its aircraft off (now per-part hulls, big parts as 8 m columns), hard brakes nosed planes over.
  • Open: LCVPs on davits, two Salerno Willys, entry points.

2026-11-10 — soldier on foot (step 7 starts)

  • --play USSoldier: Jolt CharacterVirtual capsule walking on terrain, buildings and vehicles; lower-body animation follows the movement; E gets into the --drive vehicle and out at its setSoldierExitLocation.
  • Templates hold no soldier speeds; all movement numbers are guesses to calibrate.
  • Open: entry points, crouch/prone, weapons, several vehicles to choose from.

2026-11-10 — moving parts

  • build_object takes a joint function (template name + visit index); physics animates rotational bundles from their own input, limits and speeds, wheels from the ground, wing deflections and propellers. Turrets follow the mouse.
  • Engine rotation deliberately not applied: car wheels hang under the Engine and would orbit its axis.
  • Open: tracks (AnimatedBundle), gear retraction, propeller rpm.

2026-11-10 — boats

  • FloatingBundle = buoyant column (lift × submerged fraction); with it LCVP, Hatsuzuki, Prince of Wales, Fletcher, Shokaku, Sub 7C and Elco rest within ~0.3 m of where the retail levels place them — the strongest check so far.
  • Water drag at each float pinned long hulls (Fletcher 0.08 °/s): sideways damping now acts at the centre only. Ship thrust read like aircraft (Σ torque) — torque × differential made the PT boat as slow as an LCVP. The viewer stops drawing createInvisible parts.
  • Open: big ships turn slowly; submarine diving; unused float settings; all 78 maps load with physics (27,630 static bodies).

2026-11-10 — aircraft

  • Wings push along their normals (angle-of-attack lift + control flap); regulated main wings hold 1 g; thrust = summed engine torque. Parked fighters' retail pitch (−11° to −14°) matches the Mustang's spring rest (14.4°): independent check of the spring reading.
  • Rejected readings: regulate 4.91 per wing (Il-2 half lift, SBD 1.5 g); thrust from torque × differential (twins and B-17 never take off). Found: a Spitfire driven from its spawn point started inside the parked static copy and was pushed under the terrain — spawner vehicles are no longer static bodies.
  • Open: C-47 (no regulator), XPack2 jets and rockets, gear retraction, calibration.

2026-11-10 — tracked vehicles

  • Maintainer confirmed the fidelity target: approximate first, calibrate later. Tanks drive: zero-strength rollers carry nothing, the engine's yaw input turns the hull on the spot, running gear is left out of the hull.
  • A whole-fleet sweep found the real causes: springs along the tilted body axis cost half the acceleration (now along the ground normal); centre of mass at hull height rolled jeeps in ordinary turns (lowered to wheel height).
  • Open: M3A1 and Sexton hulls still touch the ground; turret, track and wheel animation; aircraft and boats.

2026-11-10 — physics: Jolt + Refractor wheels

  • Maintainer chose the hybrid: Jolt (ADR 0004) for bodies and collision, our ray-cast Spring wheels, engine and grip as forces; --drive Willy drives a jeep on any map.
  • Reading strength/damping per wheel mass makes a Willys rest exactly at its model wheel positions; first run rolled over (grip at ground level, 2 m spawn drop) and crept on slopes — fixed with grip near COM height and an idle hold.
  • Open: units of torque/drag (placeholders), tanks/aircraft/boats, wheel animation, calibration against the original.

2026-11-10 — object lightmaps

  • Per-instance lightmaps decoded: name = mesh file + truncated instance position (67/67 on Wake), 8-bit colour-mapped TGA, second UV of .sm.
  • First tried ×1 from one bright Wake bunker; measured mean lightmap brightness (0.13–0.21) showed ×2 is needed. Added a format coverage table.
  • Open: palette.pal, .lsb shadow bits, exact blend.

2026-11-10 — vehicle structure survey

  • LodObject children are alternative detail levels; the viewer drew all of them (hull + low-detail + wreck overlapping) — now only the first.
  • Documented vehicle trees (Engine, RotationalBundle wheels, Spring suspension, Wing) as research for step 6; parameter units unknown.
  • Open: physics approach (own code vs. library) and fidelity target — decision for the maintainer.

2026-11-10 — C++ review fixes

  • Independent review found three confirmed crashes on malformed mods: std::regex stack overflow in .rs, self-recursive run, NaN frame index; plus template fan-out and unchecked allocation sizes.
  • All fixed with regression tests; rules added to boundaries (no regex on file data, budgets on data-driven recursion).
  • Open: Unicode whitespace and lone-if handling differ slightly from Python on unusual files.

2026-11-10 — level look and collision meshes

  • Viewer draws the sky box, fog to the map's view distance and sun lighting from Init.con; terrain stays unlit (baked).
  • Collision blocks decoded to triangles + MaterialManager ids (all 1,815 blocks); wireframes overlay the visible geometry exactly.
  • Open: the collision tree, the role of a second block, fog start and light scale.

2026-11-10 — animated meshes in the C++ viewer

  • engine/anim.* ports the readers, pose and skinning; the viewer skins control-point flags and a --soldier demo with lower + upper body states.
  • Biped root kept only as pelvis height; skinned meshes lit with face normals since no bind pose exists.
  • Open: frame rate (25 fps guessed), state machine transitions, held weapons, the 20° stance lean.

2026-11-10 — skeletons, skins, animations (Python)

  • Decoded .ske, .skn (with bone name table) and .baf (per-channel RLE of i16); all 1,799 files parse to their end; skin links to .sm vertices by position.
  • Conventions fixed visually with a throwaway rasterizer: standard quaternions, T·R locals; the conjugate gives impossible knees.
  • Open: the Biped root (Bip01) is in 3ds Max space — replaced by identity for soldiers; residual 20° stance lean unverified.

2026-11-10 — map objects in the viewer

  • C++ ports of the CON interpreter (parity with Python on all 78 levels) and .sm; new .tm format; scene places instances, children and spawner vehicles.
  • Rotation convention (D3D yaw/pitch/roll) checked against baked building shadows in Berlin; tree sprites are group 3 of .tm.
  • Rejected: decoding the collision tree to skip it in .tm — the geometry is found from the end of the file instead.

2026-11-09 — C++ engine start: terrain viewer

  • obf_mapview (SDL2, OpenGL 3.3, epoxy) renders heightmap, colour tiles and water; all 78 levels open; RFA/LZO/VFS ported with bounds checks.
  • Height formula (value × yScale / 256, rows along z) fitted on all base maps; tile order picked as the only seamless variant.
  • Open: map objects in the viewer need a C++ CON interpreter; texOffset, material map and water rules unknown.

2026-11-09 — static meshes

  • tools/sm.py parses all 2,527 .sm (v9/v10, triangle lists and strips) and exports OBJ + MTL + textures; geometry checked visually.
  • Rejected: writing a renderer for the model viewer — Blender already opens OBJ/DDS; rendering waits for the map viewer.
  • Open: collision blocks, mesh footer, the alpha field.

2026-11-09 — CON interpreter

  • tools/con.py: VFS over the mod stack + interpreter with an active-object model; all 78 levels load and every placed object resolves to a template.
  • Path rule settled from data: script folder, then level folder, then mod root; a test caught -> targets being substituted.
  • Open: the level load sequence and object file order are assumed; no game logic, the props are only recorded.

2026-11-09 — documentation system

  • Added AI memory layer, ADRs, format specs and tools/check_docs.py; English docs, README also in Spanish.
  • Rejected: the full template structure (boundaries, glossary, development/) — no content yet.
  • Open: boundaries doc when the C++ engine starts.

2026-11-09 — CON language survey

  • Inventoried all .con/.inc in retail data: subsystem.method commands with an active-object model, run/include/if/beginrem.
  • Retail scripts contain junk lines, so the interpreter must ignore unknown lines.
  • Open: run path resolution; interpreter not started.

2026-11-09 — RFA reader

  • Decoded RFA layout and implemented LZO1X in pure Python; verified on all 31,254 retail files.
  • Rejected: third-party LZO packages (stdlib-only tools).
  • Open: meaning of the per-archive unk field; patch override order.