Latebrake engineering status¶

Updated: 2026-11-07 Latest published milestone: v0.5.95 experimental SOURCE-ONLY pre-release, immutable source commit 45e62e2f9009741bf947019105708abe64f89c3f, zero executable attachments. It snapshots unmerged draft PR #313 (physical-asphalt edge paint, braking rubber, author-only PBR material script and pinned authored-asset build gates). It does not include a cooked Unreal material or Windows executable. Exact-source publication passed 171 C++20 tests per Windows/Ubuntu/macOS and 621 Python source tests. Physical Unreal 5.8 Editor/UHT compilation, gameplay visuals, cooking and installed QA remain unverified; source publication does not merge PR #313. Next engineering priority: genuinely compile licensed UE5.8 Editor/UHT and Game targets, cook the original circuit and run installed Win64 driving at 30/60/120 FPS. Verify reverse contact/braking, front/rear axle suspension, steering, AI and packaging manifest evidence before merging physics. Playable status: Not verified. GitHub's source archive is not a game or a Windows installer, and Android hardware QA is independently outstanding.

v0.5.95 original Unreal circuit surface source (published tag, NOT merged)¶

Exact source 45e62e2f9009741bf947019105708abe64f89c3f was published as v0.5.95 through the independent publisher workflow on November 7, 2026: 171/171 CTests each on Windows, Ubuntu and macOS, 621 Python source-binding tests, PowerShell material/manifest fixture tests and documentation verification.
The draft PR #313 contains 8 road-edge paint segments and 48 braking rubber markers fully bounded to the physical existing asphalt slabs. An Unreal Editor-only PBR material authoring script and hashed source-provenance checks were added. The real .uasset, shader cook, dynamic material appearance, 3D cars/track quality and Windows executable have NOT been generated or verified.
The published source-only GitHub release has zero executable assets. PR #313 remains draft and unmerged pending a licensed Unreal Editor/UHT build and installed Win64 visual/driving QA. See source notes and gameplay gate #148.

v0.5.94 experimental physical reverse overspeed (tagged source, NOT merged)¶

Immutable 7919a3e553de94e12f1dcfa961e305d9aff71bcd captures the true shared Chaos pawn's finite reverse overspeed planar braking, 48.6/36 km/h soft signed reverse targets and a rear load-limited correction in the existing lateral friction budget. Normal race authority and sideways/vertical motion remain unchanged by the new controller.
Exact-source publication succeeded only after correcting seven source-binding assertions that initially blocked release. Publisher run passed 185/185 CTests on Windows, Ubuntu and macOS each, 673/673 Python source fixtures, packaging policy and site/docs verification. These are not Unreal builds or installed physical driving tests.
The GitHub release has zero attached executable assets. The independent playable-game issue #148, genuine engine compilation and installed QA remain unresolved. Earlier v0.5.93 remains immutable.

v0.5.93 immutable experimental source (NOT a playable game)¶

The tagged draft source commit 9dd2b3236f25b242387233c988255881dd7aab59 corrects sideways-slide opposite-pedal classification, prevents engine heat caused by blocked motor thrust, reports the post-limit physically submitted slipstream bonus and records non-shipping requested drive/brake/steer forces.
The offline Win64 reviewer can require a human-driver record and bind those forces to the original SHA256-matched runtime receipt, exact log, source commit, engine Build.version, authored map and complete cooked archive. Editable files and matching hashes are not independent proof of Unreal compilation or gameplay.
The exact-source release publisher passed 184 portable C++20 CTests each on Windows, Ubuntu and macOS plus 674 directly tagged Python checks, PowerShell source-policy tests and documentation. Separate PR merge-preview CI passed 679 Python tests because it also included five historical publisher-policy tests in protected main. Exact verification clarification is separate from the immutable release notes.
The release is a source-only pre-release with zero assets. PR #295 stays draft/unmerged, and issue #148 remains open until a real playable Win64 qualification is achieved.

v0.5.92 experimental tagged handling source¶

Immutable 13f5588b64462a6dcdcb7d7406c584c63837e87b captures the tested unmerged PR #295 source, including spring continuity, airborne rolling-load isolation, planar launch measurement, bounded opposing-throttle braking, shared motor/cornering grip and static-road ray-length damping.
The pinned-source publisher qualified all 184 CTests on Windows/Ubuntu/macOS, 659 Python source checks, PowerShell policies and strict documentation before creating the pre-release.
The release has zero attached assets and does not establish UE compilation, cooking, installed driving or a production game. The physics PR remains draft pending those independent gates.

v0.5.91 experimental tagged draft source (NOT merged playable game)¶

Immutable 8edba49c0a6294ece2797c708d80b6dd52288d40 freezes source from PR #295: four corner springs sampled from blocking WorldStatic road, actual Chaos point velocities, bounded vertical forces at four wheel anchors, axle anti-roll load transfer and spring-qualified rear motor/front steering authority.
Rate-limited loss/recontact QA logging and physical-momentum-preserving guard paths have passed cross-platform source-only CI; no licensed Unreal Editor/UHT, Windows cook, genuine driving test or independent wheel/tire solver has been qualified.
v0.5.91 intentionally has no executable release assets and is not merged into protected main. This historical entry records the first tagged suspension snapshot, not installed playability.

v0.5.90 published source-only milestone (not installed gameplay)¶

ProgressiveRoadLoad: bounded road load and coast-down for shared real player/rival Chaos rigid-body chassis (not physical wheel contact).
SpeedAwareYawTorque: speed-sensitive yaw force rather than instantaneous rotation; AutomaticTransmission: four forward gears, reverse, brief shift torque drops and estimated engine RPM.
GripLimitedBraking and LateralGripBudget: limited service deceleration with approximate shared forward/lateral traction and handbrake effects, not suspension or measured real-world tire data.
RivalCornerBrakeEnvelope: earlier braking decisions from current speed and qualified road/tire/damage/brake-heat observations.
RivalStraightPassAssist / RivalPassTrafficResolution: one rival may request limited passing steering on only the longer original paved straights, aborting and restoring normal route steering whenever the independent same-lane traffic safety brake takes priority.
Release at a85e564a4856a2d0915df5287b3fdc8079e7b72d passed all seven qualified publication jobs, including full portable C++ tests on Windows, Ubuntu and macOS and each of eight independently required new production-source CTests.
No new Windows EXE, Windows installer, Android APK/AAB, licensed UE 5.8/UHT compilation, cooked original map or hardware playtest. The source preview has zero binary assets.
Exact publicly published release notes.

v0.5.89 published source-only milestone (not installed gameplay)¶

New optional desktop accepted-gate race progress instrument. No continuous car separation, official position or race authority.
The existing six-car garage shows signed read-only comparison ratios and authentic next-tier engine/grip purchase prices; spending/save guards remain unchanged.
Same-directional-gate, same-lap local rival split timing is an observational HUD statistic, explicitly not race classification.
Quick Race ROOKIE / STANDARD / EXPERT modifies only next-race local prototype rival throttle. Career always runs STANDARD; neither checkpoint authority nor rewards can be changed by the menu selection.
All portable Windows, Ubuntu and macOS C++20, editor-source and packaging/provenance release checks passed for immutable e3a059f4ebc0cd7525586d6aef683361d7189452; no licensed Unreal Engine 5.8 UHT/Game build or installed GPU driving test has occurred.
Exact published source notes.

v0.5.88 published source-only milestone (not installed gameplay)¶

Read-only north-up desktop PIT radar marker projects the actual physical RacePitBay position; it changes no checkpoint or reward.
Android PIT HOLD uses an original-finger-press ownership policy to avoid accidental repair commands from steering or throttle fingers, with focus/rotation/release cancellation and genuine service progress.
Six existing fictional garage cars now have source-defined SKY BLUE, EMBER ORANGE, ELECTRIC VIOLET, RACING SCARLET, SEA GLASS, SOLAR YELLOW body, aero-trim and canopy palettes. Actual rendering remains unverified because the engine-provided primitive material's Color parameter has not been tested in a UE 5.8 Editor session.
The exact ee4c0a95a92535918f974d47887ddfcd87a9c221 release tag has zero compiled binaries. Windows/Linux/macOS portable C++ tests passed; they cannot substitute for licensed Unreal UHT compilation and installed gameplay QA.
After the release: PR #257 added more actionable blocked-pit service guidance to main. This is unreleased source development, not included in the immutable v0.5.88 tag. The cosmetic pit bay outline is under separate review in PR #258.
Published v0.5.88 source notes retain the source-only and not-playable warnings.

v0.5.87 published source-only milestone (not installed gameplay)¶

The real Unreal local-driver chassis now supports a race-local, stationary 2.5-second PIT SERVICE hold using actual position, measured speed, neutral throttle and pit authorization. Accepted stops restore bounded synthetic collision damage, tire condition and nitro charge; the desktop HUD shows eligibility guidance.
The default Unreal input mapping correctly separates Enter and left mouse activation; a closed menu does not consume controller-Y pit holds.
Six existing fictional garage cars acquire distinct STREET, SPRINT, GT, TRACK, TOURING, APEX collision-free 3D body-kit proportions using built-in engine primitives. No physical car model or realistic asset pack was added.
Public release notes confirm the exact asset-free source snapshot. This is not evidence of working Unreal 5.8 compilation, cooked circuit or installed Windows/Android driving.
After the release: PR #252 merged a small read-only PIT marker in the expanded desktop race radar. The radar change is unreleased source development, not part of the tagged v0.5.87 snapshot.

v0.5.86 published source-only milestone (not installed gameplay)¶

The shared player/rival physical chassis includes bounded synthetic engine heat and proportional power fade across regular thrust, human nitro and qualified drafting. Coasting cools the state without modifying official race timing, credit awards or save data.
The autonomous rival separately moderates high-speed throttle demand from its last valid heat sample while leaving low-speed recovery, traffic braking and verified directional gate progression authoritative.
The spacious HUD can show discrete verified checkpoint count gap, explicitly not a race placement, physical separation or lap-time margin. Physical rival directional gate run-through and completion behavior still requires installed Unreal driving evidence.
Three-platform source-only C++20 qualification, Python source bindings, synthetic packaging policies and docs checks were required by the immutable release workflow. No Win64 EXE or Android package exists in the source-only pre-release. See v0.5.86 notes, engine-heat QA and rival heat-pace QA.

v0.5.86 included source — rival verified-gate run-through driving (source-only)¶

After directional rival gates replaced mere proximity scoring, the pilot still stopped its motor on the old 440cm waypoint-arrival radius. The real physical rival now aims 550cm through each gate on the original paved circuit and explicitly disables generic radial arrival. Only a verified forward 3D crossing can advance the rival route.
Legacy generic waypoint planners retain their old default arrival behavior. Invalid event gate indexes now fail closed and stop the rival instead of steering toward the origin. Existing corner braking, surface pace, player traffic, recovery and scoring remain.
New strict C++20 tests cover 200,000 physical approach samples, all four runway targets, old-radius regressions, actual gate trace, malformed inputs and full source bindings; no licensed UE compile, cooked map, Windows/Android install or real driving qualification. Rival run-through QA.

v0.5.86 included source — physical rival directional gate crossings (source-only)¶

The autonomous rival now advances its approximate route only after an actual forward 3D checkpoint plane crossing from the same CheckpointMotionTrace and EvaluateCircuitGatePlane geometry as the player. The previous 440cm radius alone is insufficient: reversing through a gate, hovering nearby, off-lane/airborne movement, bad physics and teleport-sized jumps cannot credit the rival lap.
A verified crossing ending outside the old radius can still count, avoiding high-speed missed waypoints. Explicit trace resets cover race interruptions, route advancement, teleport recoveries and completed routes. The original distance/speed-based stall recovery still works, and the player race clock/rewards remain unchanged.
A 200,000-pair portable C++20 regression and actual Unreal source-binding tests check geometry and ordered route progression; no licensed UE 5.8 compile or installed racing QA has occurred. Directional rival gate QA.

v0.5.86 included source — real rival yaw-rate steering moderation (source-only)¶

The physical rival now reads actual Chaos world-Z angular velocity after its corner, tire, dirt/damage and player-traffic decisions. A bounded engine-neutral policy reduces requested steering by up to 65% when high measured yaw and high vehicle speed share its turn direction. Opposite- direction correction, neutral/low-speed steering, braking and throttle remain unchanged; invalid measurements fail closed.
New C++20 tests exercise 200,000 deterministic chassis motion samples, boundary conditions, malformed physics and monotonic steering authority. Python binding checks verify the real chassis sensor is in the final AI control path before SetAutonomousControls.
No UE 5.8 UHT compile, cooked circuit, installed Windows/Android race or verified vehicle-feel testing has occurred. Yaw steering QA.

v0.5.86 included source — moving-rival no-approach recovery (source-only)¶

The actual physical rival route tracker now recognizes eight continuous seconds of speed without meaningful waypoint progress: 450–10,000 cm/s physical movement, frame times <=0.10s, and no 260cm decrease in distance to the actual next waypoint. A wall-slide or small orbit can now request the same verified, finite-budget recovery that previously required near-stationary speed under 80cm/s.
Real 260cm approach, new waypoints, invalid data, frame hitches, race reset/reconfiguration and a reported recovery all clear or rearm the observation. Synchronous TryRecoverTo verification and separated success/failure counts are unchanged, as are racing results and saves.
New standalone C++ tests cover 400,000 source-level progress/stall observations with cross-platform CI and Unreal source bindings. This is not installed Unreal gameplay; see moving-stall QA.

v0.5.86 included source — rival road and impact-aware corner pace (source-only)¶

The physical autonomous rival now reads the prior qualified chassis sample's confirmed paved/off-pavement state and bounded accepted-impact grip multiplier. Its new risk policy can only reduce throttle or request service braking for confirmed dirt or strongly damaged corners; steering, waypoints, player traffic and authoritative timing are unchanged.
Low-speed off-road recovery retains full requested launch throttle; a 0.12-second brake hold avoids chatter. Session resets, pausing and verified/failed recovery clear temporary state; invalid physics fails closed. Portable C++20/Unreal-source bindings plus 200,000 sample combinations cover the policy, not real installed gameplay.
Real licensed UE 5.8 build, circuit cook and physical rival test evidence remain mandatory. Rival low-grip QA.

v0.5.86 included source — live forward/reverse motor envelope (source-only)¶

The physical player and rival car now fade all three baseline/nitro/draft motor-force paths toward zero near their real, gear-specific speed limits. Forward fade starts at 82% of the live garage/nitro forward cap; reverse starts at 74% of the handling-specific reverse gear cap. Smoothstep reduces repeated hard-clamp thrust while preserving low-speed launches and existing engine braking when the driver switches direction.
200,000 portable C++20 samples and Unreal-source bindings protect monotone, finite reductions across the actual shared chassis. Lateral/vertical physics, checkpoints, saves, credits and the existing final speed caps are unchanged.
Source tests do not certify motor feel, UE 5.8 compilation or Windows/Android installed QA. Gear-aware motor QA.

v0.5.86 included source — reverse-gear physics control (source-only)¶

Both player and real rigid-body rival now use a source-level reverse-speed limiter after the existing Chaos total-speed clamp. Backwards velocity measured along the actual planar chassis heading is bounded at 1,350 cm/s (Arcade) or 1,000 cm/s (Simulation Inspired), independent of garage top-speed upgrades. Lateral slide velocity and vertical motion are preserved; forward cruising, nitro, drafting, timing, scoring and saves are unchanged.
Strict C++20 tests cover 200,000 direction/speed combinations, invalid geometry and bounded outputs; Unreal-source bindings protect placement after the usual gate checks and existing forward speed cap.
Gameplay, AI driving behavior and real installed hardware performance are not validated by source tests. Reverse speed QA.

v0.5.86 included source — source integration regression (source-only)¶

The real production chassis effect policies are exercised together by a new C++20 ArcadeDriveComposition regression across 200,000 deterministic frames: road/dirt transitions, tire and impact grip, finite corner throttle, additive nitro/drafting, and bounded service-brake heat.
Source binding checks ensure shared motor-force scaling on all three player/rival motor paths and guard the race/physics/interrupt lifecycle. No gameplay physics, saved state or published version is changed.
This test is not a licensed UE 5.8/UHT build, a cooked map, a Windows game or installed Android test. Composition QA.

v0.5.85 brake heat and collision damage — source-only milestone¶

Shared player/rival chassis code observes finite signed speed and service braking for a conservative arcade brake-heat response. Sustained high-speed heat can reduce service brake resistance to at least 74% of normal; heat gradually cools and parking brake behavior retains its own floor.
Root chassis hit callbacks validate impact impulse, body mass, real driving speed and contact normal. Strong predominantly horizontal impacts may add 3–13% damage, capped at 60% per race and one accepted contact per 0.40 seconds; damaged power remains >=79% and lateral grip >=85.6%.
These policies share the bounded existing motor/nitro/drafting and tire/traction force paths. Restart clears damage; invalid physics, pauses, recoveries and focus loss cannot create false collisions. No authoritative lap/credits/save changes are intended.
Exact source qualification on Windows, Ubuntu and macOS and Unreal-source binding tests do not prove licensed UE 5.8/UHT compilation, live Chaos collisions, a cooked circuit, installed binaries or Android touch QA. Brake QA · Collision QA.

v0.5.84 paved/off-pavement arcade traction — source-only release¶

The actual player and physical rival chassis reuse the authored four-strip pavement footprint and observed real XY actor position after all race/Chaos gates; on-road acceleration and lateral grip are unchanged.
Continuous 0.15-second off-pavement confirmation reduces existing baseline/nitro/slipstream motor force to 78% and existing lateral damping to 72%; continuous 0.20-second pavement re-entry restores the baseline. These bounded prototype effects reuse the frame-stable damping rule without a new tire or collision solver.
A bad frame, nonfinite/implausible position, menu, pause, lost focus, restart or teleport is unable to preserve a stale surface state or authorize new force. Expanded desktop HUD reports the confirmed traction effect; narrow touch gameplay and official timing, scoring, rewards, records and saves remain unchanged.
Strict source-level tests cover 250,000 deterministic samples and C++20/Python source bindings. Actual UE 5.8/UHT compilation, physical off-road/chassis validation, corner recoverability and installed Win64/Android QA are not verified. Road traction QA.

v0.5.82 human nitro — source-only release (not installed gameplay)¶

Local human B/gamepad stick-click input requests a bounded burst using real positive chassis speed and validated forward throttle. A finite run-local energy/heat policy includes regeneration, heat cutoff, fresh-press rearming and cooldown. The existing single rigid-body acceleration and target speed cap are adjusted; race authority, credits, records, rival AI and saved progress are unchanged.
Release, menu, focus interruption, pause, invalid physics, braking and recovery deny active boost. Compact mobile HUD adds no new control region; real UE 5.8 gameplay, pad feel, speed-cap transitions and native packaging remain unverified. Nitro QA.

v0.5.81 observed braking distance — published source-only¶

Real Chaos planar/forward speed pairs estimate only the current in-game stopping distance while the player is demonstrably braking; do not infer it from command inputs, fixed friction or rewards. The optional desktop HUD follows current speed-unit settings.
Reject single samples, insufficient deceleration duration, nonfinite speeds, reverse/slide, collisions and frame hitches. Reset on brake release, pause, focus loss, recovery or restart. This is a nonauthoritative visual advisory, not a driving safety guarantee.
Strict C++20 policy tests, Python source bindings and braking distance QA qualify source behavior only; licensed UE compilation and installed hardware tests remain outstanding.

v0.5.81 human handbrake — published source-only¶

Separate held Left Shift/right-stick-click prototype handbrake, local human only: suppresses motor request, lowers lateral rigid-body damping to encourage slides, applies bounded forward resistance, and preserves stronger service BRAKE when both are held.
Safe pressed/released input ownership and synchronous clearing on pause, restart, recovery, menu and focus loss. Desktop HUD shows transient handbrake state without adding mobile touch buttons.
Portable C++20 policy regression and Unreal-source binding checks are not licensed UE 5.8 compile or installed Win64/Android driving evidence. Handbrake QA.

v0.5.83 AI grip-aware corner pace — source-only release¶

The physical autonomous rival reads its previous valid measured tire grip and real planar/lateral Chaos chassis motion. A bounded corner policy reduces throttle or requests braking under measured turn/slip risk, with a 0.12s hold to avoid brake chatter. It cannot raise throttle, steer, modify route progression or bypass player-aware traffic braking.
Race reset, paused/invalid physics, route completion and recovery clear transient pace state; standalone C++20 and Python source-binding tests check the race pipeline. This remains source-only pending real UE 5.8/UHT and installed AI gameplay tests. Grip pace QA.

v0.5.82 combined arcade acceleration budget — source-only¶

Concurrent local nitro and verified rival slipstream share a strictly bounded 40% maximum additive motor-force budget. Full nitro priority leaves no more than 2% simultaneous draft acceleration; without nitro, earned drafting can supply up to 6%. Malformed/inconsistent allocations fail closed.
A portable C++20 production allocator, stress regressions and Unreal-source binding tests verify the code. The expanded desktop HUD shows only the actually allocated draft share. This does not qualify UE compilation or real installed gameplay; see drafting QA.

v0.5.82 real-rival slipstream drafting — source-only¶

Human-only sustained geometry and validated signed moving-chassis speeds can provide a bounded 0–6% additional force to existing motor acceleration while trailing a physically ready AI rival. Countdown, reverse, Time Attack, pause, finish, missing/stale targets and invalid Chaos inputs cannot qualify. The original motor, maximum speed clamp, lap/time awards, saves and AI authority stay unchanged.
Portable C++20 geometry tests, Python UE source bindings and slipstream QA are not Unreal compilation, genuine map cooking or installed gameplay evidence.

v0.5.82 arcade tire wear and temperature — source-only¶

Both physical human and rival pawns use the same finite, frame-bounded chassis-derived condition policy. Lateral slip and effective braking slowly add simulated heat and wear; the existing lateral damping rate is scaled to at least 68% of its configured value, never made nonfinite or negative.
A new race resets both drivers; a recovery/pause cannot repair worn tires. Expanded desktop HUD displays grip and wear, but compact Android UI remains unchanged. This is not actual rubber physics, a pit-stop feature or a proved UE gameplay mechanic. Tire condition QA.

v0.5.80 published source-only pre-release — rival, stability and cameras¶

Portable, frame-time-bounded resistance handles braking and grip on long frames without oversized impulses. Rival following uses signed forward closing speed with guarded time-to-contact and bounded brake hold.
Android steering neutralizes center-touch jitter and residual torque; run-local best-lap ghost display/separation adds advisory visual race feedback.
The real player pawn observes signed chassis slip relative to its nose, with live/peak desktop telemetry. Holding V or left gamepad shoulder shows a temporary rear view that clears on pause, focus loss, restart and recovery.
Cross-platform source qualification passes are not licensed Unreal Engine 5.8/UHT compilation, a cooked owned map, real EXE/APK or a hardware driving test. See chassis slip QA, rear view QA and playable gate #148.

v0.5.79 published source-only pre-release — best-lap ghost beacon and signal lights¶

The actual player chassis generates a bounded run-local best-lap pose trace, with replay as a small non-colliding floating beacon after a legitimate driven lap. It never records a persistent best ghost or qualifies official score; ghost QA.
Two red brake/tail lamps and one white reverse lamp use real effective braking and negative chassis velocity. The lights do not affect collision, handling or scoring; signal QA.
This is source-only: Windows, Ubuntu and macOS portable C++20 qualification, Python binding tests and docs are not real UE 5.8 compilation, cooked map or installed driving QA.

v0.5.78 published source-only pre-release — procedural vehicle visuals and player-aware rival¶

The actual Chaos rigid-body car now has decorative wheel roll/reverse, front steering and rotating spokes; actual tire/suspension physics is unchanged. Wheel visual QA.
The rival reads the real player position and velocity, reducing throttle or braking on approach in-lane without steering or race authority changes. Traffic AI QA.
The full source publishing matrix (Windows, Ubuntu, macOS, Python/PowerShell and MkDocs) remains not a real Unreal build, cooked level or installed game test.

v0.5.77 published source-only pre-release — measured chassis telemetry and Windows QA¶

Interpolate the physical 0–5 km/h threshold only between consecutive eligible post-green chassis samples separated by 0.25s or less. Interrupted, malformed and stalled samples use the observed endpoint, never an invented crossing. Equal-clock speed spikes fail closed.
Pure C++20 tests cover exact mid-frame interpolation, successive slow baselines, NaN, suspended sessions, frame gaps, reverse launch and impossible duplicate-clock speeds. No official scoring or saves change. Actual UE 5.8, Chaos frame ordering and installed device QA remain open. See launch QA.
A new optional real-world-velocity VehicleGForceMeter estimates longitudinal/lateral chassis acceleration, peak braking and cornering G in HUD/Results without affecting race rules, credits or saves. It fails closed on malformed samples and teleports; see G-force QA.
Local Win64 build/playtest scripts and private hash-linked manual review tooling help collect actual engine/hardware observations. This is NOT a verified packaged game; see Windows QA.

v0.5.76 published source-only pre-release — 0–5 km/h forward launch estimate¶

A portable LaunchSpeedMeter records only a first observed signed forward crossing of 5 km/h after a stationary/slow post-GO sample, inside 30 seconds of authorized driving. Active clock excludes charged recovery fees; restart clears the estimate. Invalid time, a clock rollback, a failed-readiness frame or a valid paid recovery cannot invent a launch from teleported motion.
Real player chassis physics feeds GameMode; the expanded HUD and Results label the result as a session estimate, not reaction time or a racing record. No save, credit, medal, handling or sector code is modified.
Added portable C++20 boundary tests, real RaceProgress-linked timing checks and Python Unreal-source binding tests. Merged in PR #157, and subsequently published in asset-free v0.5.76 after independent three-OS source qualification; not Unreal-qualified. See launch-speed QA.

v0.5.75 published source-only pre-release — genuine green-light race start¶

New engine-neutral RaceStartLights enforces a measured 3→2→1→GO countdown. The real GameMode authorizes its advance only with complete circuit, verified grid, local driver and unpaused/focused running. The official clock receives only post-green frame time.
Player physics input, autonomous rival drive, checkpoint scoring and recovery are all gated by this single real GameMode state. Restart zeroes the sequence; pause, menu, focus loss and invalid frames do not advance it. The live HUD renders the correct light state without an independent fake timer.
New strict C++20 RaceStartLights tests link production RaceProgress.cpp; Python source contracts cover the actual pawn/rival/GameMode/HUD decisions. See start lights QA.
Published independently qualified SOURCE-ONLY pre-release: all strict portable three-OS C++20 tests, Python Unreal source contracts, synthetic PowerShell provenance policies and documentation checks passed for the exact merged commit. No genuine UE 5.8 compilation, actual cooked map, installed Win64/Android package or hardware QA was performed; zero executable assets.

v0.5.74 published source-only pre-release — signed player controller deadzones¶

Human steering has a 12% symmetric center deadzone; signed throttle/reverse inputs have a 5.5% center deadzone. Remaining travel is rescaled continuously to full range and keyboard extremes remain ±1. Invalid inputs and thresholds fail closed.
Real native UE ThrottleInput and SteerInput callbacks use this policy. Autonomous rivals and Android touch inputs are unchanged. No physics, awards, racing record or saved user settings change.
A new strict C++20 DriveAxisDeadzone regression and Unreal source-binding tests independently verify source behavior and mappings. See controller acceptance QA.
Published source-only at a separately qualified immutable main SHA; the source archive is not an installed build and contains zero executable attachments. UE/device gameplay QA is still required.

v0.5.73 published source-only pre-release — grounded arcade drift combos¶

Source-only addition: fixed-state DriftComboMeter observes the actual car's bounded planar and lateral velocity samples, requiring sustained sideways movement before starting an arcade combo. Validated frames increase finite points; brief gaps preserve a combo but recovered grip ends/banks it once. Physics-invalid, paused/focus-suspended and recovered driving break the sequence; race restart resets all current-session arcade points.
The non-compact active HUD shows combo timing/points. The paged finished Results menu shows total style points, best combo and genuine qualified sample time only after a recordable finish, with the prominent text NO CREDITS. Scores are purely ornamental: no additional rewards, career points, saved records, achievements, tire forces or race timing changes are allowed.
Real pawn Tick/teleport and Results HUD are covered by strict C++20 and Unreal-source integration regressions. The Drift QA plan lists additional mandatory UE 5.8 compilation, original track, physics, Windows/Android rendering and hardware tests.
Published SOURCE-ONLY pre-release: the exact main commit passed three-OS portable C++20, Python source-binding, synthetic PowerShell policies and documentation integrity checks. The tag has zero runnable assets; a playable game and real engine/device qualifications are still outstanding.

v0.5.72 published source-only pre-release — four race views and touch camera¶

Source-only feature: C cycles four deterministic Chase, Close Chase, Hood and High Chase presets instead of a two-distance toggle. Each applies a real UE spring-arm length, pitch, forward/vertical offset, collision probe and camera lag. The shared camera policy is allocation-free and refuses unsafe/nonfinite values.
Android CAM: During an active race, the previously unused visible MenuBrowse rectangle becomes the CAM touch action; in menus it remains BROWSE. A portable fail-closed admission policy requires a fresh distinct press, valid mode/circuit/driver and no pause/focus loss or finished race, without acquiring steering/pedal ownership. HUD draws CAM using precisely the same hit-test rectangle and shows the selected view name below lap/time on larger viewports.
Qualification: strict C++20 preset and touch geometry/admission regression tests plus actual Unreal pawn/HUD source-binding tests. Camera QA defines essential UE 5.8 compilation, actual framing and Android multitouch acceptance. The source-only pre-release has been published with zero executable assets; the engine and mobile behavior remain unqualified.

v0.5.71 published source-only pre-release — race Results insights¶

Source-only implementation: Three additional real Results reviews: last eight retained completed timed laps' average, median, population deviation and consecutive faster-lap streak; real best per-gate sectors and explicitly mixed-lap theoretical sum; independently sampled chassis distance, peak speed, brake usage and high lateral slip time. No official timing, rewards, handling, SaveGame or career state is modified.
The existing touch-safe Results pager makes the additional rows reachable; compact displays hide secondary lines. Data policies refuse unawardable timing, insufficient/invalid windows and malformed chassis samples. Portable C++20 and Unreal HUD source contracts are included; engine and device QA remain outstanding. See Results insights QA.
Published SOURCE-ONLY pre-release: the exact merged main commit was independently qualified on three OS source CI, Python contracts, synthetic PowerShell policies and site integrity before publication. No actual playable game assets were produced. UE 5.8/UHT, genuine authored cooked map and installed device QA remain outstanding.

v0.5.70 published source-only pre-release — timed lap review in Results¶

Published in source preview: The Results menu shows a bounded eight-lap review from actual finished-run RaceProgress records with physical lap numbers, run-best comparisons and signed deltas against the preceding retained timed lap (desktop). Mobile displays compact single rows through the existing safe detail pager; no race authority, reward or save format is changed.
Invalid, incomplete, penalty-only and zero-time finishes fail closed. Strict production-linked C++20 tests cover three-lap, one-lap, twelve-lap, reset, and invalid-run cases; Python source contracts check HUD binding. See recent lap review QA.
Not engine qualified: Licensed Unreal Engine 5.8/UHT build, actual Canvas rendering, real packages and Windows/Android device tests remain outstanding; v0.5.70 is the latest published GitHub pre-release.

Unreleased source feature: Results/Career/Garage menu rows hidden by the v0.5.68 safety cap can now be visited page by page rather than permanently lost. The HUD pins the menu title/instructions, collects all eligible text rows, renders one bounded MenuDetailWindow, and shows a real page number in its reserved notice strip.
Up/Down keyboard actions and menu-specific Android UP/DOWN pad labels navigate detail pages without altering PageUp/PageDown category navigation, Enter/SELECT actions, normal RESTART/RECOVER racing, menu pause or race logic.
The portable MenuDetailPager resets on menu-category switch and close, clamps after resized viewport/changed result counts, and refuses invalid capacity; independent SAVE FAILED remains visible. Strict C++20 and Unreal-source binding tests cover policy and real input routing. See menu paging QA.
This is not licensed UE 5.8/UHT compilation or physical device validation; v0.5.65 remains the most recently published source-only GitHub pre-release.

v0.5.68 source development — bounded career/results menus¶

Unreleased: The menu-side MenuLine used a separate unbounded Y cursor despite v0.5.66/v0.5.67 improvements to the race HUD. New portable HudMenuVerticalPlan limits visible menu details above physical Android steering controls, reserves a MORE MENU DETAILS HIDDEN notice and keeps a SAVE FAILED banner visible independently of the regular menu list.
Strict portable C++20 tests cover portrait/mobile, full desktop and malformed viewport geometry; Python Unreal-source tests guard the actual Results/Career/Garage callbacks. See menu vertical QA.
Omitted text still needs genuinely accessible scrolling/pagination and visual UE5.8/mobile validation. This does not change gameplay scoring, navigation, saves or physics. v0.5.65 remains the latest published source-only pre-release.

v0.5.67 source development — measured, phone-safe HUD text widths¶

Unreleased source improvement: Race telemetry, menus, save/pause/finish banners and desktop footer now use actual Unreal GetTextSize font width measurements to elide long lines before they cross the physical Android action-pad column or desktop viewport edge.
Portable HudTextBounds derives a protected text lane from the original authoritative TouchControlLayout, rather than guessing glyph counts. Measured binary-search ellipsis and defensive width validation allow deterministic truncation; compact lap/gate and mobile warning/status strings use shorter wording.
Strict portable C++20 geometry tests and real HUD source binding tests cover multiple viewports, font width anomalies, button non-overlap and regression against hiding essential status. See horizontal HUD QA.
Not a playable release: runtime Canvas glyph and high-DPI behavior, actual Android safe areas, Unreal Engine 5.8/UHT, cooked assets and installed Win64/Android QA remain outstanding; v0.5.65 is still the latest public GitHub pre-release.

v0.5.66 source development — viewport-bounded HUD and critical race messages¶

Unreleased: Existing racing HUD telemetry could grow past its viewport and push keyboard hints below the bottom. Source-only HudVerticalPlan now bounds ordinary text rows using the real HudLayout, reserves separate visible save-warning and race-status rows, and fixes the footer baseline.
The authoritative LAP/GATE and TIME readouts now precede optional rival, wayfinding, driving/garage and split stats on small screens; surplus optional rows are suppressed without changing the game clock, scoring or UI input owner.
Portable strict C++20 tests evaluate small/fullscreen, wide/portrait, Windows and Android geometry, genuine touch pad Y limits and nonfinite viewport values. Python Unreal source contract checks actual DrawHUD integration; see HUD vertical QA.
Not playable-verified: cross-platform portable CI is not UE 5.8 UHT/Editor compilation or a cooked, installed Win64/Android game. v0.5.65 remains the latest published source-only GitHub pre-release.

v0.5.65 published source-only pre-release — signed measured rival approach¶

Unreleased source feature: A real production radar-linked RivalRelativeMotionTracker watches successive grounded player/rival direct separations and only displays CLOSING or SEPARATING after 0.4s sustained change of at least 2m/s. The tracked signal is signed direct separation rate, not opponent physical velocity, collision prediction or race order.
The HUD now displays verified sustained CLOSING on compact and desktop views and SEPARATING on expanded desktop views. Invalid actors/positions, disallowed race states, noisy radial changes, large (>90m/s) inferred discontinuities and invalid time deltas clear the trend; teleport, checkpoint epoch, menu, verified rival recovery and focus state all reset historical samples.
Strict portable C++20 tests link the real production RaceMiniMap.cpp and cover first-frame safety, sign reversal, 0.4s debounce, jump rejection, bad frames, missing rivals, Time Attack and bounded state. Unreal HUD binding contracts guard a single real radar snapshot. See direct-motion QA.
Published SOURCE-ONLY pre-release, not a playable game: the independent v0.5.65 publisher qualified the exact merged source commit on Windows/macOS/Linux with source-policy and documentation checks, then created an asset-free immutable tag. Licensed UE 5.8 UHT/editor compilation, a real cooked map, and Win64/Android installed hardware QA remain outstanding.

v0.5.63 source development — sustained rival proximity awareness and UE HUD scope fix¶

Unreleased HUD improvement: Real rival radar samples now also drive a compact/desktop close-opponent warning. It enters only after 0.6s continuously at or within 15m DIRECT planar separation and remains visible until the rival is farther than 20m. Invalid, unsupported, nonfinite, paused or interrupted race samples clear it; this is not a collision prediction or race ranking.
The HUD resets proximity on player replacement, checkpoint session changes, player teleports and verified rival recoveries. The all-viewport warning reuses the single production mini-map snapshot instead of sampling actors twice, and never modifies scoring, physics, recovery costs or persistent progression.
Compile fix: Moved const RaceProgress& Race before the early results-menu branch which previously used Race before its local C++ declaration. Dedicated Unreal-source binding tests guard the scope while portable three-OS C++20 tests exercise the new alert policy.
See rival proximity and installation QA. This source milestone is not a licensed UE 5.8 compile, installed Android/Windows game test or new GitHub release; v0.5.60 remains the latest published pre-release.

v0.5.62 source development — live player and opponent racing radar¶

Unreleased feature: Expanded desktop circuit minimap now shows actual player yaw with a north-up heading tick, a physically verified opponent marker when present, the true next scored checkpoint, and finite direct rival separation (never an invented race ranking or time gap).
New production RaceMiniMap.h/.cpp builds a bounded snapshot from real engine positions, official gate geometry and mode/race eligibility. Invalid positions, unhealthy/absent rivals, Time Attack events and off-display car coordinates hide vehicle markers instead of pinning a phantom marker at map center or boundary.
ALatebrakeRaceGameMode::TryGetRivalRadarPosition verifies a live rival actor and physics body before returning a finite real location. The Unreal HUD renders validated markers without modifying race timing, checkpoints, AI, collision, career rewards or save data.
A new strictly compiled Windows/macOS/Ubuntu production C++20 target and Unreal-source binding checks cover the grounded radar path; race radar QA specifies remaining real UE 5.8 and installed-device HUD/physics tests.
No new playable release: v0.5.60 remains the latest published GitHub source-only pre-release; genuine UE/UHT build and Win64/Android device QA are still outstanding.

v0.5.61 source development — road-return guidance and inbound-only rival corner braking¶

Unreleased improvement: New OffTrackAdvisor.h derives the nearest paved road return direction/distance from the same four rectangles as the existing circuit geometry. A debounced OffTrackIndicator raises an advisory only after 0.8s sustained off-pavement driving; it resets on pause/menu, malformed sample, checkpoint session or teleport, and pawn replacement.
The actual expanded and compact Unreal HUD displays the approximate direct return-to-pavement distance and cardinal direction. It does not change authoritative checkpoint, save, medal, race clock or paid recovery rules.
Rival correction: RivalCornerAnticipation.cpp now gates anticipation by an inbound previous-gate→current-gate projection (440–2200cm), cross-track corridor of 620cm, and pavement membership, instead of radial corner proximity alone. Beyond-gate, off-shoulder and nonfinite observations cannot trigger speculative corner braking.
Added strict C++20 geometry/debounce tests, expanded all-four-corner AI regressions, new Unreal-source HUD/AI binding contracts and QA procedures. These improvements require real UE 5.8 and installed Windows/Android gameplay qualification and are not tagged or published.

New real production code, not placeholder version bumps: DrivingSessionStats.h/.cpp accumulates bounded, run-local approximate distance, peak speed, distinct braking actions and high-side-slip/braking time from actual Chaos physics tick samples. ALatebrakeCarPawn owns the tracker, resets it at race RESTART and suspends continuity at any physics/OS interruption or teleport. The expanded HUD displays the measured information without altering saves, rewards or scoring.
Player wayfinding: CircuitRouteAdvisor.h/.cpp computes direct-line meters and a steering bearing toward the actual next RaceProgress checkpoint from the engine position and yaw. Guidance fails closed for invalid gates, off-track/malformed samples and ineligible sessions; compact HUD only shows near-gate guidance. It has no authority to award a checkpoint.
Opponent update: RivalCornerAnticipation.h/.cpp wraps existing PlanRivalTurn output to request earlier bounded speed reduction before the original four 90-degree bends. It preserves the primary pilot's steering and stop decisions, finite rival recovery budget, and player-authoritative race results.
Tests: three standalone strict C++20 production-linked suites, two Python Unreal source-binding suites and documentation hardware acceptance plans, all under a dedicated source-only release publisher with exact-SHA GitHub tag policy and zero executable-asset contract.
GitHub publication: v0.5.60 is intended to be published as a GitHub source-only pre-release only after Windows/macOS/Linux C++20, editor-source Python, synthetic PowerShell policy and MkDocs checks all succeed. The existing published v0.5.46 snapshot remains the prior release. There is no valid installed EXE/APK evidence.
Outstanding blocking gate: licensed UE 5.8 Editor/UHT compile, authentic binary cookable circuit, real Win64/Android packaging, input/physics/HUD playtests, artifact hashing and reproducible device evidence (issue #13).

v0.5.53 source development — corner traction and wrong-way guidance¶

Unreleased gameplay source: A new CornerTractionAssist.h tempers positive motor demand under sustained high-speed lateral sliding, with stronger intervention in Simulation Inspired than Arcade. It preserves full launch/straight authority, does not rewrite driver BRAKE or reverse input, and applies after Chaos velocity validation in the shared player/gamepad/touch/rival pawn physics tick.
New HUD wayfinding feature: WrongWayIndicator.h compares actual XY motion against the intended direction on all four unambiguous straight sections of the original circuit. It waits for 0.8s sustained opposite motion, suppresses corners/slow/sideways samples, and resets on pause/menu, race ineligibility, pawn changes, checkpoint-session changes and teleports/restarts. It is advisory only and never affects checkpoint awards or race time.
Two strict C++20 test suites cover speed/slip and finite-input behavior, all four route directions, warning debounce and resets; Python source contracts verify actual Unreal pawn/HUD callsite ordering and CMake registration. See handling and wayfinding QA.
Real engine and device validation still missing: no licensed UE 5.8 UHT/Editor/game compilation, original cooked map, installed Windows/Android packages, driving comparison or mobile HUD/finger QA is claimed.

v0.5.52 source development — verified restart cannot transfer to another pawn¶

Unreleased: A successful RESTART previously left RestartPlacement globally VerifiedPlacement. If the possessed player pawn was later destroyed/replaced with a physically valid car, that new actor could inherit the old pawn's grid authorization without ever passing the original start-position verification.
The portable RestartPlacementGuard::CanRace(bool isSameVerifiedPawn) now keeps ordinary initial APlayerStart behavior, but requires verified actor identity after an explicit restart. Unreal GameMode records TWeakObjectPtr<ALatebrakeCarPawn> VerifiedRestartPawn only after TryRecoverTo succeeds; destroyed, recycled or replaced actors fail the weak identity check. Another explicit restart clears the previous binding before attempting to verify the newly possessed pawn.
The central IsRestartPlacementReady() check now covers time, gates, paid RECOVER, rival eligibility and pawn motor forces. C++20 regressions emulate successful restart, replacement/possession loss, frozen race clock, no new checkpoints or recovery fees, re-possession and a fresh verified restart; Unreal source integration tests require the actual weak binding. See restart-grid QA.
No playable release: actual UE 5.8 compilation/cooked original circuit and installed Windows/Android pawn-destruction, re-possession and driving QA are still outstanding.

v0.5.51 source development — close paid RECOVER restart-grid bypass¶

Unreleased corrective work: Source audit caught an inconsistency in v0.5.50. HasLocalPlayerDriver() already blocked clock, scoring and rival eligibility after failed restart-grid placement, but RecoverPlayer() passed only Car->IsRacePhysicsReady() to its staged fee/teleport policy. A physically valid car in the wrong location could therefore still authorize a paid RECOVER.
Fixed actual Unreal caller: The staged paid recovery transaction now receives HasLocalPlayerDriver() so its eligibility includes the verified restart placement guard and the existing live chassis state. A failed grid restart cannot trigger a new player teleport or five-second fee; an explicit verified retry re-enables legitimate paid recovery.
Fail-closed driving default: PlayerDriveConditions::RestartPlacementReady now defaults to false, so six-field/omitted callsites cannot accidentally enable full player/rival yaw torque. All legitimate C++ callers and test fixtures explicitly supply the verified seventh bit.
Verification: Extended production RaceProgress.cpp-linked portable tests cover healthy chassis + rejected grid, untouched counters and callback, successful restart + paid recovery, and all 128 drive-state combinations; Python source bindings require the authoritative recovery check. See restart-grid QA. Real UE 5.8 compilation, cooked content and installed hardware gameplay remain separate blockers.

v0.5.50 source development — fail-closed player restart-grid placement¶

Unreleased: A race RESTART previously reset the authoritative clock then used a void RecoverTo that ignored engine teleport failure. A perfectly finite old-position chassis could still earn racing time and ordered gates after a rejected grid placement.
New portable RestartPlacementGuard invalidates the previous start authorization before reset and restores it only after live Unreal TryRecoverTo verifies the start pose, post-move body and motion. Missing or rejected grid placement leaves race time, checkpoint awards, paid RECOVER, player/rival driving and HUD eligibility blocked; an explicit successful retry restores play.
Initial APlayerStart spawning remains eligible subject to ordinary physics readiness. New C++20 RaceProgress-linked state-machine tests, extended seven-bit input matrix and Python Unreal/HUD source integration checks accompany restart grid QA.
Not a playable build: authorized UE 5.8 UHT/Editor compilation, cooked circuit, real Windows/Android executables and installed failure/retry QA are still pending.

v0.5.49 source development — rival recovery outcome integrity¶

Unreleased: The AI had been using the legacy void RecoverTo for stuck recovery. Unreal could reject/misplace a teleport, while the existing finite recovery counter still looked like a successful move. Now the route tracks bounded attempts with a pending state and explicit verified/rejected outcomes.
Actual ALatebrakeRivalCar::Tick calls TryRecoverTo and reports its success only after engine pose, body health and motion validation. Unresolved requests cannot advance rival route telemetry; rejected placements request braking and may retry only after a fresh stall interval.
GameMode and non-compact HUD display ATTEMPTS plus separate VERIFIED/REJECTED counts; route reset and event changes clear outcome state. New production-linked C++20 regressions, existing route budget tests and Python source integration contract cover both outcomes; see rival recovery QA.
No licensed Unreal 5.8 C++/UHT compilation, installed game, actual Chaos teleport failure injection or device steering QA has been completed. This is a source-level improvement, not proof of playable opponent behavior.

v0.5.48 source development — speed-sensitive steering and finite orientation¶

Unreleased: A new header-only portable C++20 SpeedSensitiveSteering.h tapers physical yaw torque as real planar speed rises, preserving full steering up to 900 cm/s and reducing it above 5400 cm/s to 55% Arcade / 40% Simulation Inspired. Both presets retain the existing smoothing, low-speed speed authority and reverse turn correction. Actual Unreal base-pawn torque applies this to player keyboard/controller/touch and autonomous rival commands.
Nonfinite derived physics guard: Reject invalid calculated planar, longitudinal or lateral speed before any motor/steering force, rather than relying only on finite raw chassis velocity components.
Complete orientation gate: Shared RaceVehiclePhysicsReadiness now demands finite actor pitch/yaw/roll before race time, ordered checkpoint awards, player recovery or rival movement. This prevents an invalid forward/right transform from affecting race physics.
New strict C++20 numerical regressions and Python Unreal-source integration contracts with required hardware QA matrix. This is not evidence of a licensed UE 5.8 compilation, playable Windows/Android game or stable release.

v0.5.47 source development — full orientation and post-move recovery verification¶

Unreleased development work: Paid RECOVER now requires all three observed Euler axes within 2° of requested orientation, not only yaw. A successful Unreal transform is also insufficient unless the post-move Chaos body still passes the existing physical chassis readiness policy and its instantaneous 3D linear/angular motion is finite and bounded (1 cm/s, 1°/s).
The production RecoveryTeleportVerification.cpp classifies tilted placement, disabled/nonfinite post-move physics and unintended residual motion. The actual Unreal pawn collects the post-teleport snapshots before allowing GameMode's staged penalty transaction to commit; rejected attempts keep the race clock, penalty audit and recovery counter unchanged.
Extended three-OS C++20 regression coverage and Python Unreal-source binding checks, plus engine and device QA matrix. Unreal 5.8 compilation and installed Windows/Android testing remain unverified; this work is not a playable build or stable release.
An unexpectedly moved body on a rejected recovery can still require manual on-device remediation; this change prevents a charge, not all possible consequences of a failed engine transform.

v0.5.46 published source-only pre-release — paid RECOVER requires verified engine placement¶

The player RECOVER path previously charged its five-second time penalty and recovery count before calling a void Unreal RecoverTo; SetActorLocationAndRotation could fail without the caller knowing.
New C++ production verification policy checks Unreal acceptance, finite 3D destination, placement within 5 cm, and yaw within 2°. New pawn TryRecoverTo reports success/failure while retaining the old Blueprint API, invalidates pre-move checkpoint traces and neutralizes driver controls.
GameMode uses a staged RaceProgress/counter transaction and commits its full fee only after verified movement. Failure preserves elapsed clock, total penalty, penalty count and recovery count.
New portable C++20 and Unreal source-binding regressions; independent publisher workflow #40178570042 passed all three-OS source checks, PowerShell packaging policies and immutable tag verification. Published asset-free SOURCE-ONLY pre-release on 2026-10-25. Genuine UE 5.8 compile, cooked-map gameplay and Android/Windows installed recovery validation remain unverified.

v0.5.45 published source-only pre-release — real physics mass and angular velocity validity¶

New production VehicleDynamicsReadiness.h/.cpp rejects nonpositive/nonfinite chassis mass and any nonfinite X/Y/Z Chaos angular velocity. Prior race physics readiness covered linear velocity but not these equally material body values.
ALatebrakeCarPawn::IsRacePhysicsReady() now combines the two checks, blocking authoritative clock and checkpoints on unhealthy dynamics. Pawn force/torque and AI route updates stop before acting on broken bodies; HUD speed guards against nonfinite display.
Three-OS C++20 and Python integration contracts cover source behavior and real RaceProgress.cpp policy, not licensed UE compilation. New docs/VEHICLE_DYNAMICS_QA.md provides genuine engine/device acceptance.
Published asset-free SOURCE-ONLY pre-release on 2026-10-25. Independent workflow #40176772622 passed all three-OS C++20 tests, Python Unreal-source binding tests, Windows PowerShell packaging and manifest policies, and immutable source/tag checks. UE 5.8 game/UHT compilation, cooked map, Chaos and installed Windows/Android driving QA remain open.

v0.5.44 published source-only pre-release — exact installed Unreal engine build identity¶

Discovered that candidate manifest schema 1 and Win64/Android pairing required only an unreal_engine_version string such as 5.8. Different installed 5.8 builds can share that string but have different changelists/metadata.
The candidate pipeline now hashes the exact installed Engine/Build/Build.version bytes before compiling and rechecks this identity after Editor authoring, before/after cooking and when creating a schema-2 manifest. Manifest and pair verifiers require unreal_engine_build_sha256; otherwise mixed-engine build review fails.
Windows CI synthetic metadata and manifest tests exercise changed same-size changelist JSON, missing fingerprints, unsupported schema and different Win64/Android engine metadata. Build.version SHA is metadata continuity, not authentication of UE binaries or running a game.
Published asset-free SOURCE-ONLY pre-release on 2026-10-25. Independent publisher run #40175014921 passed three-OS strict C++20, Python source contracts, Windows PowerShell engine/manifest/packaging negatives and immutable tag checks. Unreal Editor/UHT/game compilation, authentic cooked map, Win64/Android executables and installed-device QA remain unverified.

v0.5.43 published source-only pre-release — standalone PAUSE survives rejected world pause¶

Detected a distinct gap not covered by v0.5.42's player-driving readiness: a keyboard/gamepad/touch standalone PAUSE pressed while the engine was running had no independent fallback state if Unreal's SetGamePaused(true) did not actually pause. As a result, the race clock and ordered gates could continue while the player believed PAUSE was requested.
ManualRacePauseGuard now latches first-press intent before the world-pause request and clears only on explicit second press, menu return or accepted restart. All authoritative clock, checkpoint, recovery, rival and pawn-driving consumers respect this latch. PAUSE touch dispatch and HUD remain usable when world pausing fails.
Source regression tests cover failed PAUSE/UNPAUSE, real race-progress clock behavior, checkpoint session revision, recovery/rival denial and player input readiness. No UE Editor/UHT compiled artifact, Chaos runtime or real Win64/Android installed pause QA is claimed. See issues #31 and #13.
Published asset-free SOURCE-ONLY pre-release on 2026-10-25. The pinned independent workflow passed Windows/macOS/Ubuntu strict C++20 tests, isolated ManualRacePauseGuard regressions, Python Unreal source integration and Windows PowerShell policy. Licensed UE/UHT, real pause failure, cooked circuit, playable executables and installed device physics remain unverified.

Identified a gap after the v0.5.39 focus-loss safeguard: when an ordinary menu or manual world pause request fails (or the race is finished while the engine still ticks), player input still flowed through the pawn's force/torque integrator even as GameMode clock and checkpoint scoring were stopped.
Added portable typed PlayerDriveReadiness gating of authoritative GameMode, circuit readiness, menu, engine pause, focus interruption and finished-race state. The pawn now neutralizes driving input and existing linear/angular momentum before applying any thrust or torque if those states are blocked. Explicit close/resume/restart makes active racing eligible again.
Portable C++20 tests cover all 64 combinations; Unreal source-binding tests check real callsite ordering, not engine behavior. Real UE 5.8 Editor/UHT, actual pause-failure/Chaos behavior, cooked map and installed Windows/Android QA remain outstanding.
Published asset-free SOURCE-ONLY pre-release on 2026-10-25. Independent publisher run passed strict Windows/macOS/Ubuntu C++20 tests, isolated PlayerDriveReadiness checks, Python source contracts and PowerShell package-policy tests. Real UE 5.8/Chaos pause delivery, authentic cooked map, installed Win64/Android builds and driving QA are still outstanding.

v0.5.41 published source-only pre-release — real map receipt integrity safeguards¶

The prior Editor-generated starter-map-result.json established package name and byte length, but not byte equality; a modified map of identical length could satisfy the local receipt. A direct New-StarterMap.ps1 invocation also did not independently validate engine/project version 5.8.
Require UE Build.version, project EngineAssociation, actual Editor-reported version, versioned SHA256 receipt and exact saved-file hash match before accepting the map. Existing serialized-header, post-authoring source provenance and pre-/post-UAT map snapshot checks remain in place.
New synthetic PowerShell negative tests and Unreal Python mocks explicitly do not stand in for actual Editor execution; see MAP_AUTHORING_QA.md.
Published SOURCE-ONLY pre-release on 2026-10-25, with zero compiled game assets. The independent pinned publisher passed Windows/macOS/Ubuntu portable C++20 checks, Windows synthetic map-authoring tamper cases and Python Editor stub tests. Actual licensed UE 5.8 Editor/UHT, authentic cooked .umap, packages and installed device QA remain open.

v0.5.40 published source-only pre-release — per-lap active clock eligibility¶

Found a source-level completion/award consistency gap: a positive overall race time could coexist with a completed zero-duration lap, or a penalty-only lap could look timed despite no successful active clock update. The previous award boundary validated elapsed/best times but not independent timing evidence for every completed lap.
Track ActiveTimedLapCount separately from the pre-existing penalty-inclusive TimedLapCount. The count increases once per completed lap only after a successful RaceProgress::Advance has advanced the actual clock in that lap; reset and rejected deltas clear/retain evidence correctly.
FinishTimingEligibility requires a finished ordered event, a representable elapsed/last/best/slowest clock, and both lap counts equaling required laps. GameMode rejects ineligible finishes before transaction construction, awards, credits, record updates or SaveGame I/O; the source HUD and finished insights do not claim a verified result.
Regression cases include valid multi-lap penalties, zero-time first laps, penalty-only first/final laps, invalid deltas, overlong clocks, restart, and one-gate races. Real Unreal 5.8/UHT, editor map cooking, runtime checkpoint timing, Windows and Android installed QA remain unverified.
Published SOURCE-ONLY pre-release on 2026-10-25, with zero compiled game assets. The independent publisher passed the complete Windows/macOS/Ubuntu portable C++20 suite, focused FinishTimingEligibility test, Python source-contract tests and packaging-policy fixtures. Genuine Unreal Engine and installed device gameplay remain unverified.

v0.5.39 published source-only pre-release — neutralize player motion if OS pause fails¶

Address a remaining fair-play and input safety hole: v0.5.38 stopped the race clock, checkpoints, recoveries and rivals on application deactivation, but a failed Unreal world pause could leave the player chassis simulating momentum and accepting newly delivered inputs while competitive time was stopped.
Stop held/filtered drive input and zero finite physical linear/angular velocity on the new focus-loss event and during each surviving pawn tick while the guard is latched. This policy intentionally sacrifices momentum continuity on interruption for fair timing; actual Chaos motion still requires testing.
Fail closed on suspended mobile touch: only a fresh PAUSE tap can intentionally resume; throttle, steering, dragging, recover, restart and career pads cannot dispatch. Physical press identity tracking remains in place.
The independently gated GitHub release workflow passed full portable C++20 on Windows, macOS and Ubuntu, Python source-contract tests and PowerShell fixture tests, then published the unchanged commit as an asset-free prerelease. The release includes new portable touch-policy C++20 tests, CMake matrix registration and Python source-binding assertions. Published SOURCE-ONLY prerelease on 2026-10-25, not qualified as a runnable game. Licensed Unreal 5.8/UHT, real-world physics/OS pause failure and Android tests are still open in #31 and #13.

v0.5.38 published source-only pre-release — already-paused app focus-loss checkpoint integrity¶

Found that OnFocusLost returned false on a new focus loss if Unreal was already world-paused by its OS. GameMode consequently returned before invalidating the checkpoint motion epoch, despite the race suspension latch activating.
The guard now returns one of three typed FocusLossTransition results. GameMode advances the checkpoint session epoch on any new active suspension, while requesting SetGamePaused only if needed and ignoring repeated notifications. Foreground still never automatically resumes competitive timing.
Portable regressions exercise real motion samples through an already-paused interruption, duplicate OS notifications and deliberate recovery; Python source contracts require the actual engine callsite ordering.
The code remains unqualified in genuine UE 5.8/UHT, the cooked map, Android/Windows OS delivery and installed-device driving. See issues #31 and #13.

v0.5.37 published source-only pre-release — per-lap fee attribution¶

The portable race state records a run-local snapshot of charged fees at an accepted lap-completing gate. It exposes already-paid current-lap and last-completed-lap fees without modifying event totals, lap timing, awards or saves.
The expanded source HUD surfaces THIS LAP PENALTIES only when applicable; the results menu can show already-included final-lap penalties. A penalty-free lap following a charged lap is correctly displayed as having zero new fees.
Added strict C++20 multi-lap and one-gate attribution regression coverage plus Unreal HUD source binding tests. No UE Editor/UHT, map cooking, device render or installed executable was validated by source CI.

v0.5.36 published source-only pre-release — committed time-penalty telemetry¶

Added allocation-free count and total for successfully charged race time penalties in the genuine engine-independent RaceProgress. The audited increment matches the representable amount actually added to the race clock; invalid/undercharged/saturated fees cannot mutate any accounting.
Expanded HUD and results menu show the penalty total already included in the race clock, split and lap times. No extra scoring charges or profile/save fields were introduced.
New strict C++20 TimePenaltyAccounting test and Python Unreal-HUD callsite checks cover recovery, finish, reset, malformed charges, numerical edge cases and on-screen source integration.
Source CI does not prove UE 5.8/UHT editor compilation, authentic cooked maps, installed Windows/Android driving or actual HUD appearance. Those remain the release gates.

v0.5.35 published source-only pre-release — app focus-loss race integrity¶

OS deactivation/background previously cleared pawn input but did not itself guarantee the authoritative game race clock was paused. A platform could continue ticking while the player could not drive.
Introduced AppFocusRaceGuard: once gameplay loses focus, timing, ordered checkpoint scoring, paid recovery, and autonomous rival driving all reject updates even if Unreal's SetGamePaused fails or the OS resumes an already-paused world. Foreground notifications never lift the latch; only a deliberate player resume, menu return or accepted restart does so.
Runtime Pawn lifecycle bindings delegate deactivation/background to the GameMode. All real consumers (GameMode tick, gate actor, recovery, rival) observe the latch. Session revision invalidates pre-loss gate motion on an active deactivation.
Added strict portable C++20 real-RaceProgress.cpp tests and Python source-binding contracts. No real Android/Windows OS delivery, UHT/UE 5.8 compilation, device pause/render or installed gameplay is claimed.
Follow-up hardware scenarios are documented in Touch controls and remain covered by issue #13.

v0.5.34 published source-only pre-release — release workflow integrity¶

Source-only pre-release v0.5.32 initially hit a malformed YAML CTest filter before any tag was created. The workflow was repaired and retested.
New standard-library SourceReleaseWorkflowPolicyTests.py checks modern source-only release workflow structure: exactly one of each required job, three-platform C++ matrix, valid isolated CTest filter, immutable three-job checkout SHA and matching publisher SHA, proper notes/version identity, predecessor gate and explicit asset-free pre-release policy.
Mutation fixtures ensure that malformed regex quoting, duplicated release jobs, inconsistent source SHAs, wrong tag/notes path, and missing source-only warnings fail closed before a new source release.
It is a structural source check, not a full YAML parser or proof of Unreal Editor builds. Existing GitHub Actions remain the real workflow semantic/execution check.

v0.5.33 published source-only pre-release — live sector target¶

A new portable LiveSectorTarget.h compares the current unfinished sector only with a previously measured positive split of the SAME gate. The UI shows time until the previous best or positive overtime once the current split takes longer. It never claims an achieved improvement before the gate is crossed.
Expanded Unreal HUD source binds to this shared engine-neutral policy. Cross-platform real-RaceProgress.cpp C++20 tests and editor-source binding regressions cover start, improving sector, missing reference, exact best, slow sector, restart, finish and invalid clocks.
Genuine UE 5.8 Editor/UHT compilation, rendered HUD checks and installed Win64/Android driving QA are not established by source CI.

v0.5.32 published source-only pre-release — current-lap sector potential¶

PR #85 added portable CurrentLapPotential.h, using only the actual RaceProgress current-lap duration and the best positive measured splits from the same race. Completed sectors are already included in elapsed lap time; the current sector can only add its unspent best remainder. No speculative negative-duration time is subtracted.
The non-compact Unreal HUD shows LAP POTENTIAL (BEST SPLITS) and its signed difference to the achieved within-run best. It hides the line before a timed lap, after finishing/restarting, for missing or zero reference splits, and for invalid or out-of-bound clocks.
Added a strict standalone CurrentLapPotentialTests.cpp target linked to real game RaceProgress.cpp. Ubuntu, Windows and macOS CI, release script policy, editor-script checks and documentation build passed on PR #85 before merge. See sector timing.
This is not a playable release, Unreal compile, engine-rendered HUD verification or device test. v0.5.32 is now the latest public source-only tag; genuine engine/Win64/Android qualification remains open.

v0.5.31 source development — local invalid-velocity QA visibility¶

The v0.5.30 checkpoint trace rejects nonfinite velocity, but non-shipping mode-2 local QA summaries did not display the InvalidVelocity rejection bucket. Real QA inspectors could not distinguish a corrupt physics measurement from unclassified diagnostic samples using aggregated logs alone.
The actual ALatebrakeCheckpoint 10-second summary appends invalid-velocity=<count> when diagnostics mode 2 is enabled. It reads the existing bounded GateDiagnosticCounters category; no position coordinates, per-frame buffers, network traffic or shipping logging are added.
AnalyzeCheckpointQA.py now accepts both the prior summary format without this trailing field (assigning zero for missing history) and the new format with a validated nonnegative UINT32 counter. It rejects malformed or repeated fields and counts above the sample budget.
Added standalone C++20 bucket regressions, Python legacy/new parser tests, and a source-level contract for Unreal's local log format. These are synthetic/source tests, not evidence of installed Unreal runtime logging or real Android diagnostics.
The full checklist is in bounded checkpoint QA summaries. No playable game packages or stable release are yet qualified.

v0.5.30 source development — checkpoint corrupt-velocity discontinuity¶

Detected a race-integrity gap in CheckpointMotionTrace::SampleDetailed: a NaN/infinite velocity sample could be rejected while its finite position was still retained as the baseline for the next gate crossing. A later finite reading could falsely bridge that corrupt physics interval.
Reject any nonfinite horizontal velocity before capturing a baseline; reset the trace and report GateRejected/InvalidVelocity without giving RaceProgress an ordered gate. The next entirely valid sample establishes a new baseline only; a subsequent real forward crossing can count. Position, session and teleport guards remain unchanged.
New C++20 CheckpointVelocityContinuityTests.cpp links original RaceProgress.cpp and checks all four gates, NaN/±infinity in velocity, first-frame invalidity, unchanged session epochs, per-gate diagnostic counts and no ghost lap completion.
Technical qualification steps are at checkpoint velocity QA; genuinely compiling/cooking UE 5.8 and testing installed Win64/Android packages remains outstanding. This is source-only development, not a new public release or binary.

v0.5.29 source development — remove residual motor and steering input¶

Identified a mismatch between touch ownership and physics output: TouchReleased and a nonfinite ApplyTouch canceled driving fingers but left already-smoothed throttle or steering values untouched. Dragging an owned GAS finger into the neutral gap similarly allowed an old motor command to decay over subsequent physics frames.
Added shared portable TouchResidualSafety.h: CancelTouchOwnerAndOutput drops the released/invalid finger's ownership and its respective filtered command, while MoveTouchWithResidualSafety cuts residual gas on a move into neutral/BRAKE, steering on exit from its active vertical band, and both commands on an unusable viewport.
Wired the actual Unreal Pawn's TouchReleased and ApplyTouch to these helpers. Independent held fingers and the physical TouchPressTracker action latch remain intact until genuine release.
Added strict three-OS portable C++20 regressions and Python source-binding checks; none compile Unreal or validate Android touch/physics on real hardware.
Unreleased source development; genuine UE 5.8 UHT/editor, cooked original map and device QA are still required under issues #13/#31.

v0.5.28 source development — paused multi-touch release admission¶

Android regression identified: IE_Pressed was bound with bExecuteWhenPaused = true, but IE_Released used the default. A finger lifted during a paused menu/session could remain marked as physically held by TouchPressTracker, suppressing subsequent legitimate presses with the same finger ID.
Bind the existing TouchReleased callback to execute while paused. The callback releases only touch drive ownership and its matching physically-held tracker slot; it never fires discrete menu/race actions. No additional reset on menu entry is allowed, which would incorrectly re-arm a physically still-held finger.
New strict portable C++20 lifecycle test exercises simultaneous gas, steering and PAUSE fingers across pause, release and new presses. A Python source-level binding contract verifies the actual Unreal callback wiring, and has negative source mutation fixtures.
Remains source-only: needs UE 5.8 UHT/input binding compilation and Android device pause/menu/touch event delivery checks under #13.

v0.5.27 source development — actual player chassis readiness¶

Investigation: HasLocalPlayerDriver() previously returned true for any possessed ALatebrakeCarPawn, even if the underlying physics chassis was missing its mesh, not simulating, not blocking WorldStatic or had nonfinite location/velocity. The race clock could accumulate ghost time despite an undrivable vehicle.
Added portable RaceVehiclePhysicsSnapshot and a predicate enforcing all required chassis conditions. The actual pawn now exposes IsRacePhysicsReady(), used by local player clock/gate readiness and by charged recoveries.
Engine checkpoint actors clear their motion baselines and local QA samples when a car loses physical readiness, so restored physics does not interpolate an invalid old trajectory into a gate award.
New strict C++20 tests use original RaceProgress.cpp for missing/invalid chassis, nonfinite 3D physics state, frozen clock while broken, resumed active time and finished-race behavior.
Still source-only. UE 5.8 compilation, real rigid body collision, editor map cook and installed Windows/Android QA have not occurred.

v0.5.26 source development — paid recovery session guard¶

Review identified a gameplay mismatch: RecoverPlayer used to allow a paid teleport during an incomplete circuit startup or while the game/menu was paused, even though checkpoint scoring and the race clock were explicitly suspended in those states.
TryChargePlayerRecoveryIfReady reuses the real player scoring readiness contract before the existing atomic five-second recovery fee. The engine-facing RecoverPlayer checks active driver identity, track readiness, both pause conditions and race completion before charging and teleporting.
New strict portable tests link original RaceProgress.cpp and check every circuit/menu/driver readiness combination, denied-state immutability, legitimate charges, restart, finish and counter/ floating-point boundary failure.
Unreal 5.8 compilation, actual installed game behavior, mobile pause/recovery input and collision QA remain unverified. No new release tag or executable is implied by this work.

v0.5.25 source development — original cooked map identity¶

Earlier pre-release packaging recorded the circuit map's SHA256 after UAT, but could not prove the same bytes were present before cooking. The one-command candidate builder now snapshots Editor-authored map bytes and verifies them before/after UAT and at manifest creation.
Test-CandidateMapSnapshot.ps1 fails on missing, implausibly small, reparse-point, corrupt or changed map bytes. Disposable policy fixtures test same-size mutation, invalid SHA256 and restoration.
The dual-platform manual release gate also compares the map's SHA256 between Win64 and Android candidate manifests. A matching Git SHA and engine version alone are insufficient when the map was generated separately. Synthetic paired-manifest tests exercise this policy.
These are source/build identity improvements only. No genuine UE compilation, packaged game, hardware driving QA or official v0.5.25 release has been verified.

v0.5.24 source development — source-to-binary provenance gate¶

A preexisting package manifest gate checked only tracked changes. Untracked new .cpp, .h or .ini source could affect a genuine Unreal build while the manifest still claimed an unchanged Git HEAD.
Added Test-SourceProvenance.ps1 to reject modified, staged and unexpected untracked source. Only the anticipated real Editor-authored Content/Maps/LatebrakeCircuit.umap path can be untracked, and its SHA256 is recorded separately by the candidate manifest writer.
A follow-up source revision pin fixes another handoff ambiguity: a clean but different HEAD after a long Editor/UAT task cannot pass as the exact same candidate. Build-PlayableCandidate passes its initial 40-character commit through all source checks; portable Git policy regressions cover matching, incorrect, malformed and blank pins.
Invoked before the expensive Editor build, after level authoring, when invoking UAT directly, and before writing the final candidate manifest.
Added temporary Git policy fixtures under Windows CI (not generated game content). Actual UE 5.8 Editor/UHT, cooked map, installed packages and hardware QA remain blocked on a licensed runner/device.

v0.5.23 source development — close malformed duplicate press dispatch gap¶

Investigation: the real pawn's TouchPressed previously returned as soon as TouchPressTracker::Press rejected an already-down finger. This bypassed v0.5.22's TouchDriveState::Press malformed duplicate handling: the portable state test passed, but the engine event path never reached it.
New engine-independent AdmitTouchPress classifies events before returning: the same held finger's NaN/Inf repeated press cancels its own driving ownership while staying physically down (no duplicate PAUSE/RESTART/RECOVER). Legitimate duplicates and unrelated captured fingers remain unaffected.
The Unreal pawn calls the shared policy and immediately zeroes its smoothed steering/throttle output if that specific held owner is canceled. First presses still reach viewport handling, including malformed first presses.
Expanded portable TouchPressTrackerTests.cpp checks the exact integrated admission policy and multi-touch isolation. These tests are not Unreal event binding, packaged Android input, or installed-game QA.
No v0.5.23 release tag, executable, APK or AAB is implied by this work. Real-device qualification remains open in issue #13.

v0.5.15 source development — one checkpoint epoch for all gameplay transitions¶

RaceSessionEpoch now tracks pause, accepted race restart, and menu-to-gameplay transitions independently of individual actor ticks.
CloseMenuForRace consolidates menu dismissal and input clearing for successful Quick Race, career, championships, challenges and results replay.
The Quick Race menu avoids restarting twice when event selection already restarts the authoritative race. A direct restart action also closes an open menu after success, not after failed career replay.
Strict C++20 portable regression exercises real directional checkpoint crossings and RaceProgress before/after every transition.
Pending actual UE 5.8/UHT/editor and hardware race qualification.

v0.5.14 merged source — reject malformed UAT package outputs¶

New Win64/Android candidate structure script checks payload sizes, Windows MZ headers, cooked asset presence, APK ZIP contents and AndroidManifest.xml/native or dex content.
The real UAT packaging stage calls this preflight BEFORE the archive manifest writer and temporary unverified artifact upload.
Negative fixtures check malformed files, not game output.
Genuine UE 5.8 editor/UHT/cook and on-device racing qualification still require an authorized Windows Unreal workstation. Build instructions.

v0.5.13 merged source — exact package/QA identity¶

The platform release gate now requires a 64-character SHA256 of Latebrake-candidate-manifest.json in each installed-device QA report. Matching only the source commit no longer qualifies a different package produced by a second Unreal cook.
Build-PlayableCandidate.ps1 prints the exact digest after the archive manifest passes its closed-world hash/file-list verifier.
Both Win64 and Android QA templates and negative policy tests cover the new identity requirement. Synthetic tests do not represent human playtesting or authentic Unreal binaries.
Real UE 5.8 compilation, cooked Win64/Android candidates and installed hardware testing remain outstanding. Build/QA instructions.

v0.5.12 merged source — reject linked candidate directories¶

Verified an archive-integrity gap: checking only each final file for reparse-point attributes was insufficient when the file's parent directory is a symlink or Windows junction outside the archive.
Manifest verification now rejects the manifest/root links and every linked parent component before hashing a listed payload; empty linked directories in the archive are rejected too.
The manifest writer refuses source with dirty tracked files, links and empty archive payloads before recording SHA256 digests.
Disposable local negative fixtures cover a junction outside the candidate root, with no synthetic game binary or gameplay claim.
Pending: licensed UE 5.8 editor, map, UAT packages, real installed Win64/Android QA. See build pipeline.

v0.5.11 merged source — never bridge checkpoint samples across pause¶

New allocation-free CheckpointSessionTrace resets the motion baseline on menu and Escape/gamepad pause/resume session-revision changes, independently of teleport revisions and pawn swaps. No gate can earn a score from two samples separated by a menu pause.
Unreal checkpoint actors reset their diagnostic windows on session changes and refuse sampling during blocked/paused/menu-open states.
GameMode scoring now requires a valid local player driver as well as a ready unpaused circuit; race clock similarly treats an open menu as paused even if the world pause call fails.
Four-gate real RaceProgress portable C++20 tests exercise interrupted and uninterrupted forward crossings, plus reset, corrupt coordinates and large/wrapped revisions.
UE 5.8 UHT/editor compile and installed Win64/Android resume/gate QA remain outstanding. Required acceptance.

v0.5.10 merged source — avoid ghost time without a player car¶

GameMode only advances actual RaceProgress while a valid local ALatebrakeCarPawn is available through the player controller.
An otherwise-complete course can now show a distinct HUD warning when the player pawn is missing. Time resumes on player return instead of inventing elapsed time while no driver could race.
Engine-neutral PlayerRaceClockReadiness tests cover loss, return, pause, invalid time, finish and reset with original race source.
Unreal UHT/editor compile, real possessed-pawn behavior and installed-game HUD/device verification remain pending.

v0.5.9 merged source — clock cannot run on an incomplete circuit¶

New portable AdvanceRaceClockIfReady uses real RaceProgress and refuses time accumulation when the circuit readiness audit failed, the world is paused, the race finished or the frame time is malformed.
GameMode Tick now uses this policy rather than unconditionally advancing the elapsed race clock. The public IsCircuitReadyForGameplay source accessor allows the HUD and menu to display an explicit track-not-ready warning.
A strict C++20 test links the actual original RaceProgress.cpp and checks positive advancement, rejected gates, pause/resume, invalid durations, finished race freeze and restart isolation.
No real UE 5.8 editor/game compilation, actual circuit cooking or installed Win64/Android QA exists for v0.5.9. Clock-startup QA design.

v0.5.8 published source-only — verify collision channel blocking¶

Original engine-neutral CollisionResponsePolicy now requires Pawn, PhysicsBody and WorldDynamic responses to be Block.
After setting BlockAll, the engine-facing SpawnBlock checks each actual Unreal mesh component channel and destroys Actors that would still Ignore or Overlap important vehicle/dynamic channels.
This integrates with the previous nine-piece startup audit: a misconfigured road/barrier cannot contribute to successful course construction or enable race checkpoint rewards.
Portable C++20 CollisionResponsePolicyTests.cpp covers each rejected channel and positive paths. C++/CTest cannot verify actual real-game rigid body contacts.
v0.5.8 is published as a source-only pre-release, without actual game executables. Collision response QA.

v0.5.7 published source-only — actual mesh-configuration and spawn preflight¶

New CollisionBlockSetup policy disallows startup credit when an Unreal actor exists but its mesh component is absent, the expected Cube is not bound, blocking collision is disabled or scaling failed.
The engine-facing SpawnBlock code destroys rejected actors and reports LATEBRAKE_COLLISION_SETUP_FAILED; the existing source startup audit still requires all nine full block configurations.
New engine-independent CircuitSpawnSafety ensures the player and rival starts plus all recovery targets are finite, on planned paved road and outside conservative perimeter barrier clearances. LATEBRAKE_SPAWN_LAYOUT_BLOCKED prevents the course from entering ready state if future geometry edits invalidate a spawn.
New strict portable tests and synthetic smoke-parser negatives guard these policies, but neither compiles Unreal Editor/UHT nor confirms that a real vehicle collides with the road on hardware.
v0.5.7 is published as source only; no verified playable build exists. Source and real-game QA design.

v0.5.6 source-only preview — fail-closed circuit geometry startup¶

The engine-independent CircuitCollisionPlan defines nine original ground/road/barrier transforms from shared world coordinates, preserving the earlier prototype's actual positions and scales.
A new CircuitStartupAudit requires all nine collision block creations, four unique checkpoint indices and exact seven ISM groups / 93 instances before marking the course ready.
Unreal GameMode tracks attempted/created block Actors, logs LATEBRAKE_GEOMETRY_READY collision=9/9 or LATEBRAKE_GEOMETRY_INCOMPLETE, and does not allow race checkpoint progression on incomplete startup.
The runtime log parser requires complete, single-instance scenery, geometry and four-gate ready markers in source emission order. Disposable fixtures validate parser grammar only, not real Unreal physics or actual game launch.
Portable C++20 tests check counts, duplicate gates, partial Actor creation, invalid plan indices, road alignment and missing scenery. This feature has not been compiled with UE 5.8 or tested on real Windows/Android machines.
A source-only v0.5.6 GitHub pre-release exists; no playable EXE/APK exists. See the startup audit design.

v0.5.5 published source-only — player-facing finish scorecard¶

RecentTimedLaps retains a fixed eight-entry true timed-lap history, resets on restart and excludes invalid/zero laps. Results menu and non-compact finished HUD can compare the latest two measured laps with a signed +slower/-faster delta.
New engine-neutral BuildFinishedRaceInsights uses genuine RaceProgress and the already shared bounded finish-time policy.
Shows an achieved best lap against this run's theoretical split sum, plus a fastest-to-slowest measured lap spread only with two or more positive timed laps. Instant zero-duration gates do not produce fake lap consistency data.
Results-menu and non-compact finished-HUD source now render those values if a valid finished race exists; no reward, save, career or checkpoint behavior changes.
Strict C++20 tests cover actual ordered lap progression and clock edge cases. Real Unreal 5.8 compilation, HUD readability and installed Windows/Android playtest are not verified.
v0.5.5 is a source-only pre-release, not an installed game. Design and release notes.

v0.5.4 published source-only — bounded checkpoint QA summaries¶

New engine-independent fixed-size GateDiagnosticCounters tracks total samples, true crossings, baseline/recovery events and first classified gate rejection reasons.
Shared GateDiagnosticWindow holds bounded ten-second frame time and counters; invalid/nonfinite durations cannot poison summaries and one long hitch cannot create an entire QA interval.
New scripts/AnalyzeCheckpointQA.py validates and aggregates user-supplied runtime-log text offline, with explicit unverified-provenance warnings. Synthetic parser unit tests run alongside the Unreal editor-script stubs.
Counts saturate rather than wrap and can be merged/reset without heap allocations, GPS coordinates, player names or network services.
Non-shipping Unreal console mode latebrake.CheckpointDiagnostics 2 adds a ten-second aggregated per-gate summary instead of continuous frame logging. Modes 0 (silent) and 1 (event transitions) remain.
The standalone regression test proves real motion-trace decisions, merge arithmetic, saturation, reset, invalid categories and recovery isolation. The Unreal logging code is not engine-compiled or hardware-qualified.
v0.5.4 is a GitHub source-only pre-release; no EXE, Android APK or installed game qualification is available. QA summary design.

v0.5.3 published — deterministic gate diagnostic outcomes¶

Added explicit classification for valid gate crossings, invalid samples or velocity, wrong-way/slow motion, oversized frame travel, absent plane crossings, lane misses and height misses.
Motion trace details distinguish a first baseline, an authorized teleport generation rebase, malformed positions and a legitimate crossing without changing the existing bool scoring method.
Added strict portable C++20 tests for the four gate directions and diagnostic/boolean parity.
The diagnostic evaluator is engine-independent. An additional default-off, non-shipping latebrake.CheckpointDiagnostics Unreal console variable logs local event/reason transitions, with no network output. Unreal compilation, console behavior, logging and installed-device validation are unverified. See gate diagnostic design.

v0.5.2 published — source-only race integrity¶

Genuine bounded forward checkpoint plane crossings with low-FPS swept sampling and four ordered sectors. A 1,200 cm frame-distance cap remains; measured real-world frame-hitch acceptance is pending.
Car-local teleport generations reject even short recovery/restart shortcuts, and pawn changes rebase samples.
Invalid finished elapsed/lap times cannot award unrecordable records, credits, medals or completed counters.
Career replay stages required-car selection and persists before restarting, with save-failure rollback; active career races lock garage mutations.
Rival lap targets follow the event and Android viewport interruption clears residual smoothed drive input.
The release workflow passed Windows/Ubuntu/macOS C++20, PowerShell negative packaging policy and Python editor stub tests. No verified game executable or Android APK/AAB was built or attached.
Release notes and release page.

GitHub releases (source-only)¶

v0.1.0 — published pre-release of the original C++ project and racing foundation.
v0.1.1 — published pre-release of racing timing, fastest lap and checkpoint stability.
v0.2.0 — offline circuit/time-attack and experimental rival source.
v0.2.1 — AI steering/recovery source stabilization.
v0.3.0 — garage source foundation.
v0.3.1 — garage and HUD source hardening.
v0.3.2 — driving input and cache safety.
v0.4.0 — circuit decorations and north-up minimap.
v0.4.1 — experimental Android control HUD and touch reliability.
v0.5.0 — career, two championship series, challenges, offline progression and source-level development menu.
v0.5.1 — split timing, save/launch safety, mobile touch guards, batched circuit scenery and stricter build checks. Source archive only; no installed game.
v0.5.2 — checkpoint and race integrity fixes; source-only, no playable build.\n\n- v0.5.3 — directional rejection reasons and opt-in local Unreal diagnostic log source; source-only, no executable.\n\n- v0.5.4 — bounded QA counters and local log inspection. Source-only; no playable build.
v0.5.5 — genuine timed-lap and within-run theoretical finish insights, source-only. No executable.
v0.5.6 — original collision plan and audited startup marker grammar, source-only.
v0.5.7 — collision component setup and planned safe spawn/recovery checks, source-only.
v0.5.8 — component Pawn/PhysicsBody/WorldDynamic blocking policy, source-only.

These tags are source previews. They are not downloadable playable game installers.

v0.4.1 published source work (NOT engine verified)¶

New portable touch-pad rectangles shared by the Android HUD and input hit-testing, for steering, gas, brake, pause, restart and recovery.
Touch capture starts only with presses on visible pads; nonfinite input is neutralized, pedal drags through the gap release both pedals and moves cannot capture an unrelated finger.
Touch pause action is bound to work when the game is paused; restarting while paused unpauses before race reset.
Compact HUD prioritizes timing and vehicle status over upgrade pricing, leaving space for large touch pads.
Added engine-independent C++20 tests for responsive layout, pad separation, steering values and invalid coordinates; standalone smoke testing performed with GCC 14, not Unreal.
Outstanding: compile and playtest the Unreal touch dispatcher, pause behavior and HUD on Android hardware; validate lifecycles and accessibility; do not imply a playable APK.

v0.4.0 changes¶

Centralized race circuit reference data for player spawn, gate checkpoints, recovery and rival AI waypoints; reduces divergence among duplicated literals.
Added pure C++20 decoration plan and runtime primitive road marking, curb, spectator stand and banner source code.
Added nonblocking cosmetic geometry (still one static-mesh actor per piece; future instanced-mesh optimization needed).
Added north-up minimap projection and experimental desktop HUD circuit visual, player position and next gate.
Expanded standalone C++20 tests for course consistency, decoration placement, and invalid/outside positions.
No new drivable track variant, Unreal Editor validation, cookable original map, or playable binary claims.

v0.3.2 development branch¶

Pure C++20 input neutralization for nonfinite/overflowing values, touch scaling and smoothed throttle commands.
Player/AI throttle inputs are sanitized; pause and recovery clear analog and touch controls.
Simulated car tick ignores nonfinite frame time and resets corrupt/nonfinite physics linear velocity.
The game mode caches selected garage tuning and only updates when selected vehicle/upgrade levels/pawn change.
Failed SaveGame writes set an explicit HUD warning.
Added portable tests for input safety and garage tuning cache keys.

This does not constitute an Unreal 5.8 engine build, an instrumented driving test, or a ready-to-install game package.

v0.3.1 changes¶

Corrupt negative garage mask now resets ownership to Arrow, not all prototypes.
Garage model exposes next affordable unlock, next owned car and upgrade prices; game-mode actions provide feedback to the HUD.
HUD text layout adapts to viewport width/height and offers condensed information for small screens, though Unreal render tests are still required.
Saved race times are checked for invalid/malformed values; race completion counter saturates instead of overflowing.
Portable C++20 tests cover malformed saves, feedback-related garage model queries, responsive HUD metrics and record bounds.

v0.3.0 added in this development branch¶

Original fictional starter garage profiles, with different force/grip/speed multipliers and primitive-only cabin silhouettes.
Offline earned-credit unlocks and 3-level Engine/Grip upgrades with saturation and validation.
SaveGame fields to persist selected car, owned vehicles and upgrade levels (legacy fallback).
HUD and keyboard controls for garage operations (Q/E/U/I).
New C++20 garage economy/progression regression tests.
Does not include authored complete car models, wheel suspension, a production garage menu, or any tested game packages.

v0.2.1 improvements (merged and source preview published)¶

Deterministic rival waypoint-lap and stalled-car state tracker with bounded recovery count.
Integrates self-recovery after eight seconds of sustained near-zero speed, preserving route progress.
Moves AI planning ahead of its own base-car physics tick; additional steering smoothing for both human and autonomous inputs.
Starts braking earlier near a waypoint; rejects negative speed readings.
HUD now labels route laps explicitly as approximate AI telemetry, not scored race placement.
Adds pure C++20 CTest targets for route progress and steering filter.

v0.2.0 implementation (merged and source-preview published)¶

Portable offline event catalog: three-lap Circuit Race and one-lap Time Attack, both using the starter four-checkpoint circuit.
Keyboard bindings 3 and 4 switch events and restart the active race.
Separate personal-best race records by event; backward-compatible SaveGame field for Time Attack.
Portable waypoint pilot computes steering, throttle and braking from the target, heading and speed.
Experimental autonomous rival pawn follows four circuit waypoints in Circuit Race; the rival is removed in Time Attack.
Player-only checkpoint registration prevents the rival from advancing the player's lap count.
Offline event completion rewards, recovery-aware clean bonus, accumulated and bounded credits.
Portable C++20 tests for event configuration, pilot inputs, lap rules, gate validation and credits.

Successfully verified¶

GitHub Actions builds and executes the portable C++20 test suite on Windows, Ubuntu and macOS for earlier v0.2.0 development commits.
Check the newest branch-head workflow before tagging a pre-release; tests cannot exercise Unreal gameplay symbols.
GitHub CI does not have Unreal Engine source/SDK/tooling available.

Not implemented or not qualified¶

Unreal 5.8 compilation, Unreal Header Tool generation, in-editor driving/playtesting, performance profiling or packaged hardware testing.
A cooked project-owned map, original finished vehicle model, Chaos Vehicles wheel/suspension rig, production-ready mobile controls and tested phone lifecycle behavior.
Race-aware overtaking, full AI opponent ranking/finished times, traffic, production garage/championship UX and multiplayer. Prototype upgrades, garage logic and championship source already exist; they still need actual engine playtesting.
Tested save migrations, touch inputs, actual vehicle/rival cornering, AI avoidance, pause/resume and HUD at varied viewports.
Windows EXE, Android APK/AAB or Linux native binary not available.

Next acceptance gates¶

Install licensed UE 5.8 + platform SDKs on a supported workstation and compile all Unreal-targeted C++.
Test event switching, Time Attack/circuit result separation, rival spawn/despawn, waypoint motion and player-only gate scoring.
Verify credit rewards paid exactly once, personal-best saves/migration, recovery penalties and race restarts.
Author a cookable .umap and validate real Win64 and Android packages/device playtests.
Investigate Chaos Vehicles suspension and steering; replace provisional rigid-body mechanics after measurement.
Publish stable v1.0.0 only after complete declared release scope and tested Win64/Android artifacts.

Track the first playable-release gates in issue #2.

v0.5.0 published source pre-release audit (2026-10-20)¶

Subsystem	Source state	Remaining gate
Race & checkpoint clock	Four ordered gates, lap timing, slowest-lap tracking	UE/physics playtest
Career catalog	Stable IDs, 12 events, prerequisite graph	Real UI and balance QA
Championships	Two three-round cups, medal points and once-only bonuses	UE integration playtest
Challenges	Six portable validation rules incl. clean/precision/consistency/Kestrel/endurance	Device timing and vehicle QA
Garage	Existing Arrow/Kestrel/Phantom saved state preserved, bounded credits	Actual save migration
SaveGame v2	Career medals/selection + unit preference appended; future schema write guard	Unreal serialization, interruption/rollback tests
Menu/UI	10-page asset-free paused Canvas menu, career selection, speed unit toggle, device touch actions	Editor compile, viewport/accessibility and UMG work
Mobile lifecycle	Deactivation/background/foreground/unpossess cleanup source	Physical Android cancel/focus-loss tests
CI	Portable CMake/CTest across Windows, macOS, Ubuntu	Does not compile Unreal
Packaging	No verified game binaries or project-owned cookable map	UE installed/cook/package/hardware evidence

Issues #2 and #13 are still open; source CI cannot close them. The current in-container environment has a C++ toolchain but no Unreal Engine 5.8 installation, and the GitHub connection cannot manufacture validated game packages.

The published v0.5.0 tag is an immutable source-only pre-release at merge commit ad17b47886b8d3f9633299f74d85b4949aa1b5a8. Release and core CI each passed Windows, Ubuntu and macOS portable tests; PowerShell syntax validation also passed. GitHub contains no attached executable assets. These checks do not validate the Unreal runtime or physical device behavior.

v0.5.1 source-release build readiness — no executable yet¶

Default game map and cooker now target /Game/Maps/LatebrakeCircuit. The actual Unreal-generated .umap does not exist in the repo yet.
Removed unused ChaosVehicles plugin and game-module dependency; this project currently uses a physically simulated rigid-body prototype.
Added Unreal Engine 5.8 UBT Editor compilation helper, Editor-only Python map-authoring script, PowerShell wrapper and UAT BuildCookRun pipeline for real Win64/Android candidate packages.
Added platform-specific package shape/hashes + self-declared installed QA verification and negative test fixtures; Windows CI checks syntax.
Added a manual self-hosted UE 5.8 Actions workflow for candidate artifacts, with no automatic release attachment and no claim that a runner is connected.
Still unverified: real UHT/UBT compilation, map creation, cooking, installation, Windows/Android physics/menu/save QA, device performance and game binaries. Issues #2 and #13 remain open.
v0.5.0 remains an immutable source-only snapshot, and v0.5.1 is also a source-only prerelease. Neither version adds playable EXE/APK assets.

See actual packaging procedure.

v0.5.1 source changes since v0.5.0¶

Fixed editor-map existence checking that erroneously queried the EditorAssetLibrary API for a level; Unreal documents that API as excluding levels. Existing levels are now preserved and loaded.
Added seven isolated Unreal Editor script flow tests using disposable fake engine objects, not engine assets.
Candidate packaging refuses nonempty output folders, unreadable or forged .umap headers and missing real engine/map prerequisites.
Added UNVERIFIED build provenance manifest (source commit, engine/map and per-file SHA256); no gameplay success is inferred from hashes.
Fixed pause key handling so an open development menu closes before the game resumes. Real Unreal focus/lifecycle behavior still requires QA.
No Win64 EXE or Android APK has yet been produced or attached. Issues #2 and #13 remain open.

Additional pre-release engine-readiness work — no executable yet¶

Android runtime source now includes a dedicated local PlayerController for game-only input and custom touch UI, connected to RaceGameMode.
UE map-authoring now demands a fresh successful editor save receipt, rather than trusting process exit code and preexisting map alone; failure paths are covered by engine-free stub tests.
The runtime circuit emits a 4/4 checkpoint launch marker; an independent PowerShell script can check a real installed-game log after Unreal/packaging actually runs. CI deliberately tests only failure cases with synthetic text.
These changes have not been compiled against UE 5.8 or device tested; v0.5.1 is still a source-only pre-release, with issues #2 and #13 open pending actual game binaries and QA.

v0.5.1 — source-level SaveGame failure recovery improvements¶

ProfileWriteCheckpoint captures the previous garage, career medals, completed-race count and best race/lap/time-attack times before committing a result. An unsuccessful SaveGameToSlot now restores the session's previous values rather than leaving unsaved credits and unlocks usable.
Garage purchases, active vehicle selection, engine/grip upgrades and MPH/KMH preference likewise restore prior values on a failed write.
Portable tests cover retryable first-completion rewards and championship bonus after a deliberately failed save.
This is not a crash-safe atomic filesystem transaction. No genuine UE SaveGame serialization, disk-failure simulation, hardware QA or executable has run here. v0.5.1 is also source-only and issues #2/#13 remain open.

v0.5.1 held-touch input stabilization (source only)¶

Engine-independent TouchDriveState now owns two-finger driving input; the Unreal pawn routes press/move/release and lifecycle/menu clears through it rather than duplicating mutable finger flags.
Control safety: second/third fingers cannot steal controls; dragging from telemetry cannot activate pedals; pedal neutral gaps, vertical steering departures, and invalid coordinates neutralize input.
A standalone pause suppresses new gas/brake/steering capture until an explicit resume. Held control HUD states share the physics input source. Strict portable C++20 tests cover the state machine.
The tests can pass on all three OSs without the Unreal SDK, but this is not proof of Android input delivery or a working Unreal executable. The same real map/engine/platform build blockers remain open.

v0.5.1 mobile viewport input safety (source only)¶

Touch viewport dimensions are now observed before each Android car physics tick, and within every touch event. A size/orientation change cancels existing steering and pedal ownership immediately.
Physical finger tracking is maintained across geometry changes to avoid duplicate action firing and stale-control reacquisition until release.
Disposable portable C++20 tests cover rotate, resize, invalid viewport, delayed movement, duplicate press and genuine re-press behavior.
This does not prove Android touch-event dispatch, frame performance or packaged-game playability; keep engine/device qualification issues open.

v0.5.1 runtime startup smoke gate (source only)¶

The future real installed-game log verifier now requires both the authentic four-gate startup marker and one complete, earlier batched scenery marker (7 groups and 93 instances). A missing, duplicate, malformed or explicitly incomplete scene cannot pass the gate.
Disposable CI parser fixtures exercise only rejections. They are not runnable Unreal evidence, renderer benchmarks or validated gameplay.

v0.5.1 instanced course visuals (source only)¶

Single prototype circuit decoration plan now groups 93 static cosmetic cube placements into seven color/style batches under one Unreal actor using UInstancedStaticMeshComponent, rather than 93 separate actors.
Existing asphalt/ground/barrier collision is preserved separately; decorative collision, overlaps, navigation and shadow casting are disabled.
Portable C++20 regression tests compare every proposed batched placement against the existing stripe/curb layout and verify group counts.
Startup logs distinguish complete vs incomplete instance creation. UE 5.8 UHT/Editor compilation and renderer/phone profiling are not verified; no FPS or verified packaged build is claimed.

v0.5.1 progression and recovery safety (source only)¶

A career event now stages its event ID and any required owned vehicle inside an in-memory profile checkpoint, persists that selection, and only then resets/reconfigures the active race. Failed SaveGame writes reject the launch and restore the previous profile without switching races.
Player RECOVER charges an entire 5-second penalty and increments its recovery counter before repositioning; a finished race, unchargeable clock or saturated counter cannot grant an uncharged teleport.
Portable C++20 tests check invalid/locked event selection, missing required vehicle, fail/retry/commit semantics and recovery count/time overflow.
There is still no UE 5.8 engine build or real Win64/Android installation. These assertions are engine-facing source integration, not hardware QA.

v0.5.1 race split timing (source only)¶

Portable RaceProgress now tracks the fastest strictly positive split for each ordered sector and compares a fresh split only with the previous best of that identical sector. Negative delta means faster.
A run-local theoretical lap becomes available once every sector has a valid best. It is labelled as theoretical, not a completed personal best, and is cleared on restart/event switch instead of being written to save.
The non-compact HUD renders these diagnostics. A separate strict C++20 SectorTiming regression target covers ordering, time penalties, signed deltas, reset and numeric bounds.
No Unreal Editor/UI testing or actual installed gameplay was performed. See sector timing acceptance tests.

v0.5.1 release integrity work — no executable published¶

A candidate's post-UAT SHA256 file manifest is now verified immediately after packaging, not just written and uploaded without a check.
The manifest verifier requires exact file count, paths, sizes and hashes. It rejects stale/missing, extra or modified archive files, unsafe relative paths, dirty tracked source trees and wrong project/platform metadata.
Both platform-specific QA gates require a manifest and human installed test evidence with build_commit equal to the archive source commit.
The dual-platform release script delegates to both full platform gates and rejects different source commits or Unreal versions.
CI uses only short-lived synthetic text files for integrity tests. No actual Unreal Engine build, cooked level, executable, APK or installed game was validated or published by these checks.

Unreleased v0.5.2 event-specific rival lap targets¶

The source-level rival pilot now configures waypoint count and required route laps from the selected player race rather than remaining fixed at the three-lap quick-race default through championship event changes.
Existing and newly spawned rivals are reinitialized per event; career replays clear the rival's previous route/stuck/recovery state.
The desktop HUD labels the rival's approximate completed/expected waypoint loops to avoid misrepresenting a short career event.
The cross-platform portable route tests exercise all current opponent-enabled career events, replays and corrupt route dimensions.
Still source-only. No genuine Unreal engine compile, gameplay, Windows executable or Android APK verified. Published v0.5.2 source-only pre-release is unchanged.