Skip to content

Latest commit

 

History

History
692 lines (614 loc) · 287 KB

engine-progress.md

File metadata and controls

692 lines (614 loc) · 287 KB

Progress on the spec

Check against engine-tz.md: what from "What to do" and "Done when" of each module E1–E11 is already in place, where it lives and how it is verified. Status as of 17 October 2026: all five phases, A–E, are built (see "Phases"). Phase E covers stylised materials, foliage, effects and decals, budgets and the performance test, Steam, the Windows build, the crash report, screenshots without a window and the internal 3D resolution. With it comes the tail of E11: a replay from a snapshot together with content edits and levels placed by id, an agent player on the stand, and scenarios for the modules of phase E. What is still open is what cannot be checked here (a clean machine, a second Steam account, 60 FPS on the target PC — the maintainer has these), streaming of tile geometry for physics (not needed yet, see "Known limitations") and mini-dumps with a window for the player beyond the crash report (E10.7: this stage is postponed by the owner's decision). CI on GitHub (.github/workflows/ci.yml) runs on every pull request, every push to main, release tags v* and by hand (jobs test, clippy, template, headless-cli with a three-minute soak on a live stand, and replays-window); test and template run their tests with cargo-nextest (profile ci: a test that passes only on a retry fails the run). soak.yml plays the half hour of E7 every night, nightly.yml runs the long checks (every reference replay with heavy mode, 100000 worldgen seeds, the GPU tests on a software driver, the performance tests) and opens an issue labelled nightly when one fails, cross.yml verifies the reference replays on Windows and Ubuntu 22.04 every week, and record-replays.yml records the reference replays on Linux on demand.

Statuses:

  • ✅ done: the code is in the repository, and there is a test, a scenario or a command that checks it;
  • 🟡 partly: it works, but not all of the spec item is done or checked (the "where" column says what is missing);
  • ⏳ ahead: the phase (A–E) in which the item is done. There is no code for it yet.

Rules for this file: set the status from the code and the tests, not from intent. If an item cannot be checked here, say so. When you change a module, change its section too.

Phases

The phase scheme from the spec ("Order of the phases") and the state of acceptance. Acceptance of a phase is the "Done when" of its modules, checked by scripts in CI.

phase GDD stage modules state
A combat prototype (GDD 39) E1; E2; E3; from E4 — the content base, prefabs, content check, deterministic loading; from E11 — combat overlays, immortality, prefab spawning, scenario tests ✅ built and checked locally and in CI. All items of "Done when" for E1–E3 and parts of E4/E11 are done and checked by the tests and the commands below. The v0.2.0 tag is not set yet (the maintainer sets it, see CHANGELOG.md)
B world E5; E6; from E4 — levels from Blender; from E11 — clearance/path_to on the navmesh, snapshots 🟡 built, checked locally and in CI. "Done when" for E5, E6, levels from Blender and snapshots is done and checked by tests, scenarios and replays (table below); the level pipeline is also checked on a real export from Blender 5.2.2 LTS. path_to and clearance on the navmesh were finished in D4. Streaming of tile geometry for physics is not done and is not needed yet: a full-size region from the spec (8×8 tiles of 96 m, about 1900 colliders) with the broad phase of physics loads in 0.6 s and ticks in 0.5–0.6 ms (performance test reference96, E10.4); only the picture streams. The v0.3.0 tag is not set
C co-op (stage 3) E7; E8; from E11 — the "host + clients" stand ✅ built and checked locally and in CI: groundwork (clients without SimSet, replication rules, the state codec, the deferred step, exit hooks, launch flags), the channel layer of shards_net (E7.2), the co-op session and the "host + clients" stand (E7.1, 3, 4, 6, 7; E11.6), saves E8.1–5 (shards_save), player settings E8.6 (shards_settings), saves in co-op (shards::coop: the character travels with the player, the host keeps the world), prediction of one's own body, smoothing of other players and the network overlay (E7.4, 5, 8; C4), the network CLI and the stand scenarios (C7), saves and two-player co-op in the template, a long soak run with shards soak (C9). Acceptance of E7 is half an hour of a host and two clients at 150 ms latency and 2 % packet loss, without a desync (table below). The tag is not set
D content and UI E9; the rest of E4 and E11 ✅ built, checked locally: UI E9.1–3 (shards_ui, D1) — screens and menus from content, the UI tree for the agent, drawing with accessibility labels, HUD and menus in the sandbox and the template; localization E9.4 (shards_locale, D2) — texts in Fluent, the language switches on the fly; audio E9.5 (shards_audio, D3) — buses, voices, spatial sounds, music in layers that follow the game; the rest of E4 and E11 (D4) — the developer menu and console (shards_dev, E11.1; every item of the list in 32.8 GDD is both in the menu and in shards), the NPC overlay (npc_overlay, F7), path_to and clearance on the navmesh (E11.5), a check of the level file's socket markers against the tile's sockets (E4.4). The tag is not set
E platform E10; from E11 — snapshots with content and level edits, the agent player, scenarios for the modules of phase E 🟡 built, checked locally. All items of "What to do" in E10 are there: stylised materials (E10.1, shards_look: mesh looks from content — light in bands, flat faces, outlines), foliage with levels of detail (E10.2, shards_scatter), effects and decals (E10.3, shards_fx: particles from pools by content, attack telegraphs as decals on the ground), budgets (E10.4: tick time — step, [perf], --tick-budget-ms; frame time and counters in status, the performance test --perf; the full-size scene reference96 and the broad phase of physics), Steam (E10.5, shards_steam: lobbies and the game server over the relay, achievements, cloud; checked on a fake Steam, and the game server, relay, achievements and lobby search also on the real one, with one account), the Windows build (E10.6: shards package, --smoke, quit; checked on Windows 11, the clean machine by emulating its environment), the crash report (E10.7: crashes/…json, crash_report), screenshots without a window (E10.8: --offscreen) and the internal 3D resolution (graphics.render_scale). E11 is closed: a replay from a snapshot carries content and level edits placed by id, the agent player is checked on the stand, and each module of phase E has a scenario. The status is 🟡 because of the "Done when" items that cannot be checked here: 60 FPS at 1080p on the target PC, running the build on a real clean machine, and two players over the Steam relay (needs a second account). The tag is not set

What was checked for the acceptance of phase A (all commands were run from the repository root, without a window, unless said otherwise):

what how it was checked
engine build and tests cargo test --workspace, in CI the nextest runs of docs/manual.md, "Tests and CI" (--profile ci without the tick-time tests, then those alone with --profile ci-perf -j 1) and cargo test --workspace --doc (0 failing; the number of tests per crate is in "Tests"); cargo clippy --workspace --all-targets --locked -- -D warnings and the same for the template, with no warnings; template/Cargo.lock does not differ from the root one
the template apart from the engine cargo test --manifest-path template/Cargo.toml (in CI cargo nextest run --manifest-path template/Cargo.toml --profile ci) (the number of tests is in "Tests"); a copy of template/ outside the repository, renamed, with a path dependency on crates/shards: cargo test, a run without a window, shards scenario, re-recording of a replay (a separate repository with a tag cannot be checked this way: there is no tag yet)
scenarios against a live game cargo sandbox --headless --paused --port 0 --port-file F, SHARDS_PORT_FILE=F cargo shards scenario crates/sandbox/scenarios/*.scenario → 5 of 5 scenarios passed
content cargo sandbox --check-content → ok: 38 definitions in 9 files; a broken copy of the content gives errors with the file, the line and a hint (docs/manual.md, "Content")
reference replays without a window cargo sandbox --replay tests/replays/combat_prototype.json --verify → identical to the recording (39 checks); the same for obstacle_course.json (17 checks) and for the template's replay (5 checks)
the same replays in a window xvfb-run -a cargo sandbox --replay tests/replays/obstacle_course.json --verify --windowed → identical to the recording (17 checks) [1010 ticks …, 21 frames] (software Vulkan, lavapipe); likewise combat_prototype.json (39) and the template's replay
screenshot with labels xvfb-run -a cargo sandbox --paused … and shards shot: a PNG and a legend

What was checked for the acceptance of phase B (the commands were run from the repository root without a window, unless said otherwise; cargo test --workspace: all pass, 0 failing; template: all pass):

what how it was checked
the template generates an 8×8 region from test tiles template/: the valley (valley, 4 tiles: meadow, columns, gate and a ruin from a glTF file), tests tests/game/region.rs; cargo run -- --worldgen-report valley --seeds 1..1000 → 1000/1000 passed (63 after a retry)
1000 seeds pass the check cargo sandbox --worldgen-report wilds --seeds 1..1000 → 1000/1000 passed (42 after a retry), 0 fell back, 0 failed, 0 panicked [1000 seeds in 0.31s]; tests a_thousand_seeds_pass_their_checks_quickly (shards_world), a_thousand_seeds_of_the_valley_pass_its_checks (template); the dungeon crypt — the same 1000 seeds in 0.17 s; the CI jobs headless-cli and template run the report
one seed and version — one manifest, byte for byte tests an_8x8_region_generates_passes_its_checks_and_is_byte_stable, the_same_seed_builds_the_same_world_down_to_ids, the_same_seed_and_version_give_the_same_manifest_byte_for_byte (template); the region scenario checks the hash 7bbfdc3b62623fbc of the wilds with seed 42 and repeats it after another region
moving between regions with a loading screen, without a window tests regen_replaces_the_region_through_the_loading_screen_and_keeps_the_hero, a_region_changed_from_on_enter_in_game_does_not_enter_the_game_again, going_to_the_valley_passes_the_loading_screen_headless_and_keeps_the_hero (template); the scenario and replay region (the player is the same, the tick did not move)
an enemy walks around the columns by the navmesh and does not leave its zone scenario npc_navmesh (npc_detour — going around the colonnade, npc_beyond_leash — never past the leash), replay npc_navmesh.json; tests an_npc_walks_around_pillars_by_navmesh_and_stays_on_its_leash, a_sentry_chases_to_its_leash_goes_home_healing_and_never_crosses; the template's raider: a_raider_comes_by_the_navmesh_and_keeps_to_its_camp
with one player, no more than two of three enemies attack scenario npc_director (30 s of combat, three_attacking never), test one_player_three_enemies_never_more_than_two_attack_at_once, replay npc_director.json
everything matches in the replay cargo sandbox --replay tests/replays/<file>.json --verify for all six (obstacle_course, combat_prototype, npc_director, npc_navmesh, region, snapshot): identical to the recording; the same in a window under Xvfb (--verify --windowed); test every_reference_replay_verifies_headless; the template's replays smoke and valley
the template builds a level from a Blender file with markers template/assets/tiles/ruin.gltf + ruin.level.ron (required markers); tests a_typo_in_the_level_is_an_error_that_names_the_fix, the ruin's column stands where the tile puts it. The file is an export from Blender 5.2.2 LTS in the glTF Embedded variant (tools/blender/ruin_tile.py, without a window); the test the_committed_ruin_is_the_tile_the_spec_describes checks it against the description of the tile
the replay starts from a snapshot; the boss phase — loading a snapshot scenario snapshot and replay snapshot.json; tests go_to_boss_phase_two_is_a_snapshot_loaded_by_name, a_snapshot_in_the_generated_region_goes_on_the_same_in_a_fresh_arena; ai_core::snapshot, shards::run (exit code 2 for a snapshot that the build does not accept)
the module scenarios run in CI test (every_scenario_file_passes_on_a_fresh_game, …after_another, …backwards) and headless-cli (forward, then backward in one live game)
content check reads levels and navigation cargo sandbox --check-content → ok: 70 definitions in 23 files; broken copies: a typo in a component on a node, a missing marker, an outdated navmesh file, a typo in a socket or a point — errors with the file, the node and a hint (docs/manual.md)
clearance/path_to on the navmesh ✅ (D4) path_to asks the same route planner (RoutePlanner) as move_to path=true: inside a region the navmesh answers ("provider": "navmesh"), outside it the local grid answers ("local grid"); clearance closes a direction where the navmesh ends more than a metre before physics does (E closed 4.0m (the navmesh goes no further)). Tests navmesh.rs (stitching at a sealed edge, move_to_path_follows_the_navmesh_beyond_the_local_planners_reach), perception.rs (local grid outside the region), scenario npc_navmesh

What was checked for the acceptance of phase C (Windows, debug build; cargo test --workspace and the template's tests are in "Tests"):

what how it was checked
a host and two clients without a window play for half an hour with agent scripts at 150 ms latency and 2 % packet loss, without a desync cargo sandbox --stand 2 --headless --paused --port 0 --port-file F --net-sim latency=150,loss=0.02, SHARDS_PORT_FILE=F cargo shards soak --seed 30 --minutes 30 --regen wilds --regen-minutes 5 --save-minutes 3 → PASS soak seed 30: ticks 0 → 108000 (30:00 of game time), 7005 rounds, 5 region changes, 9 saves, 0 desyncs on the host and on both clients (6 minutes). The same with client processes over real UDP (--stand 2 --stand-udp, seed 31): PASS, 0 desyncs; the soak steps drove the host at 2.7 times real time, so the clients' input often arrived late (about 5300 inputs per client), and prediction was often reset (average error 1–1.5 m). Also: half_an_hour_of_three_players_on_lossy_links_stays_in_sync (#[ignore], 168 s); each CI run runs two_minutes_of_three_players_on_lossy_links_stay_in_sync and three minutes on a live stand in CI (headless-cli); half an hour — soak.yml, every night
joining and leaving do not lose progress a_player_who_leaves_has_the_latest_in_their_file_and_comes_back_to_it, a_rejoin_within_the_grace_keeps_the_body_and_sends_the_file_what_it_missed, a_rejoin_after_the_grace_restores_the_character_the_host_kept, world_progress_a_guest_made_is_in_the_hosts_world_save_after_the_guest_left (net_coop.rs); template: a_guest_brings_their_trophies_to_the_next_session
network scenarios on the in-memory transport run in CI every_stand_scenario_file_passes_on_a_fresh_stand, a_stand_scenario_run_twice_gives_identical_journals (scenario_files.rs), every_stand_scenario_passes (template); live stands in headless-cli, one per stand line of the files in crates/sandbox/scenarios/stand/ (shards scenario)
"save → load" on 1000 random states loses no data a_thousand_random_states_round_trip_through_files (shards_save/tests/save/roundtrip.rs)
a damaged file is restored from a copy every_kind_of_damage_to_the_primary_is_restored_from_the_first_backup, the_next_backup_is_tried_when_the_first_is_bad_too (damage.rs)
a file of an old version migrates and loads old_files_migrate_and_load on the committed samples of version 1 (migrate.rs)
template: saves and two-player co-op scenarios/saves.scenario, scenarios/stand/coop.scenario, tests/game/coop.rs

Summary

module phase state
E1. Core, build, template A ✅ (saves and two-player co-op in the template — C9)
E2. Movement A ✅ physics on parry3d, controller, input, camera, path estimation, movers (F6); navmesh — E6; look as input (Intent.look, a body that faces it, the eye, the look tool, the AIM line) — F1a; crouch (Crouch, crouch_height, the crouch tool) — F2; air movement in the style of Half-Life (accel: Projected) — F7; the control lock (F12); ladders (volume: ladder, ladder_speed, MotionMode::Ladder)
E3. Actions, combat, animation A ✅ combat driven by data, the animation bridge, telegraphs
E4. Content and levels A (part), B, D ✅ base, prefabs, content check, levels from Blender (the pipeline is checked on a real export from Blender 5.2.2 LTS; the ruin.gltf of the sandbox and of the template is also a Blender export, the glTF Embedded variant)
E5. World generation B 🟡 generator, solver, checks, manifest, dungeons, reports, region change, active zones — ✅; only the tile picture streams (the geometry for physics loads in full: a full-size region loads in 0.6 s, so streaming it is not needed yet)
E6. Navigation and enemy AI B ✅ navmesh by tiles and body classes (and of hand-made levels that ask, nav: true, baked in memory), behaviour, perception, director, planner, avoiding bodies (selective RVO); gunfire, hiding, ranged fighters, turrets (F11); scripted sequences (F12)
E7. Networking and co-op C ✅ transport, session, input, replication, joining and leaving, prediction and smoothing, network overlay (shards_net), network CLI and stand scenarios, long sessions with shards soak; acceptance — half an hour with three players at 150 ms and 2 % loss, without a desync
E8. Saves and settings C ✅ saves (1–5, shards_save), player settings (6, shards_settings) and saves in co-op (7, shards::coop)
E9. UI, audio, localization D ✅ UI, localization and audio
E10. Rendering, performance, platform E 🟡 stylised materials (shards_look: looks, light in bands, flat faces, outlines) — ✅; foliage and instancing (shards_scatter) — ✅; effects and decals (shards_fx: particles from pools, telegraph decals) — ✅; lights from content, flicker, the shadow budget and colour grading volumes (shards_light, picture.grading, F13) — ✅; Steam (shards_steam, feature steam) — 🟡 (on a fake Steam; on the real one, the game server and a player over the relay, achievements, lobby search, with one account; joining a lobby with a second account, the overlay and a successful cloud write are not done yet); budgets and the performance test (tick and frame time, counters, draw calls draws, --perf, the full-size scene reference96 with loading a region and baking its tiles nav_bake_s) — ✅; the Windows build — 🟡 (everything except running on a real clean machine; replays between Windows and Linux were checked on one machine, other processors were not); crash report — ✅; screenshots without a window — ✅; internal 3D resolution (render_scale) — ✅
E11. Developer tools A (part), B, C, D ✅ scenarios (also for the modules of phase E), overlays (combat, colliders, navmesh, tiles, NPCs, network), developer menu and console, god, spawn_prefab, goto_tile, snapshots (with content and level edits placed by id), clearance and path_to on physics and the navmesh, an agent player on the stand

General requirements of the spec

№ requirement status how it is met
1 the engine has no LLM, code in English, documentation in Russian, Bevy 0.20.0 ✅ AGENTS.md; Bevy 0.20.0 in [workspace.dependencies], the exact versions of all dependencies are in Cargo.lock. The documentation is in English, not Russian, by decision of the repository owner (17 October 2026): README.md is a short page about the project, the manual it used to be is docs/manual.md, and the manual, the spec, this file, CHANGELOG.md, AGENTS.md and the template's README were translated from Russian. Also checked for the modules of phases C–E (17 October 2026): they have no LLM and no model calls
2 simulation in FixedUpdate inside SimSet, randomness through SimRng, components are part of the replay hash ✅ tests gameplay_systems_have_a_total_order (sandbox, shards_action) and the_engine_with_motion_has_a_total_order_in_the_fixed_tick (shards_motion); the hash is taken over the reflected components of AiVisible entities
3 gameplay without a window is the same as with one ✅ --verify --windowed, test observe_reads_the_same_with_a_window_camera_or_without
4 every module is open to the AI: describe, journal_event, tools, conditions ✅ for A and B; 🟡 for C–E: everything except their own conditions A and B: register_ai_component, add_ai_tool, add_ai_query, add_ai_condition in shards_core, shards_content, shards_motion, shards_action; world: the TILE/POI lines in observe, ai/status → world, near_poi; levels: markers in the description of entities; NPCs: the state line, the log of transitions and tokens, npc_state, the npc_* conditions. C–E (checked 17 October 2026): networking — the net_* and player_* tools, the net_* conditions, joining and leaving in the journal, net in ai/status; saves and settings — save_game, load_game, continue_game and others, settings, settings_set, the save: lines, the save and settings fields; shards::coop — the save: lines and save_game what=character; UI — ui_*, the UI section in observe, the ui: lines; language — locale, text; audio — audio, sound_play, music_set, the MUSIC line, [local] entries; looks, foliage, effects — looks, scatter, effects and their switches, fields in ai/status, Look in the body's description; Steam — six tools and the steam field; developer menu — dev_menu, console; crash report — crash_report; budgets — the ticks: line, [perf], the frames and counts fields. Apart from networking, the modules C–E have no conditions of their own for --until: they are waited for in the journal (journal:save:, journal:music:). For this reason the Steam lobby search scenario waits for entry blindly with step 60; a condition such as steam_joined would remove that need
5 numbers and definitions are asset files with hot reload ✅ for A and B; 🟡 for C–E: the network and sound numbers below A and B: content/**/*.<kind>.ron — movement, actions, movesets, statuses, animation sets, prefabs, the input map; tiles, sockets, regions, dungeons, points, levels, behaviour, perception, director, attack plans, navmesh settings. The baked navmesh is in the files assets/nav/, not RON content: --bake-nav bakes it. C–E: the kinds net, save, screen, theme, locale and the .ftl files, sound, music, audio, devmenu, look, scatter, effect, fx, achievement, perf — with hot reload; the tests of looks, UI, language and foliage check an edit on the fly. The player's settings are in settings.toml, not content (this is by design; the game reads the file again when you edit it by hand while it runs). Not in content: the numbers that shape how networking feels — smoothing and prediction (interp.rs: KEPT, JUMP; predict.rs: DEAD_ZONE, MODE_TICKS, ERROR_WINDOW), the host's patience and the client's pace (GONE_PATIENCE_MS, DESYNC_RESYNC_COOLDOWN_SECS, KNOCK_EVERY_MS, PACE_FAR, PACE_BRAKE) — constants, not fields of NetDef; sound fades (playback.rs, LOST_FADE in music.rs). Without a test: editing an effect on the fly (sync_pools rebuilds the pools) and the theme from a file (E9.3)
6 third-party crate: a check for Bevy 0.20, pinned, hidden behind the engine's API ✅ checked against the crates.io index on 13 and 14 October 2026: avian3d 0.7.0, bevy_enhanced_input 0.26.0 and lightyear 0.30.1 require Bevy 0.19, so physics runs on parry3d =0.31.1 (inside shards_motion, its types are not in the public API), the input map is our own; ron =0.12.2 for content. Phases C–E (checked 17 October 2026): crc32fast =1.5.2 (shards_save), toml =1.1.8 (shards_settings), flate2 =1.1.10 (shards_net), accesskit =0.24.1 (shards_ui, feature render), fluent-bundle =0.16.0, fluent-syntax =0.12.0, unic-langid =0.9.6 and sys-locale =0.3.2 (shards_locale), winit =0.30.13 (the window icon in shards), steamworks =0.13.1 (shards_steam, feature sdk), ttf-parser =0.25.1 (only the shards_ui tests) — all pinned exactly and not visible in the API. The check found one exception: through shards::locale::def, FluentResource (Parsed, parse_language) was visible; now they are inside the crate. The networking is our own, shards_net (bevy_replicon 0.45 supports Bevy 0.20, but was not taken), and the particles are our own (bevy_hanabi has no version for Bevy 0.20). Of the ^ version requirements, only serde, serde_json, schemars, clap, ureq, libc and Bevy itself remain (exact versions are in Cargo.lock); serde, serde_json and schemars are part of the engine's API on purpose (shards::serde etc.), clap is hidden in shards::run
7 per module: unit tests, a scenario in the sandbox, a replay check, a README section ✅ for A and B; 🟡 for C–E: the replay of some modules is by construction, without a test see the modules below. A and B: the scenarios npc_director, npc_navmesh, region, snapshot and their replays; README — one section per module (E4.2, E5, E6, snapshots), now these are sections of the manual docs/manual.md. C–E (checked 17 October 2026): unit tests in every crate (table "Tests"); scenarios — stand/coop_smoke, stand/session_guards, stand/agent_player, saves, world_save, settings, remap, ui, locale, audio, dev_menu, looks, scatter, effects, budgets, display, crash_report; in the template saves, menus, stand/coop; in Steam lobby_search (under cargo test); replay — the reference tests/replays/saves.json, the host's replay in the network tests, the hash is not changed by settings (isolation.rs) and by music (music.rs); the manual section — one per module (shards::coop — a paragraph in "Saves"). Gaps: the docs say that language, the developer menu, effects and foliage do not change the hash, but no test checks it (effects and foliage have no AiId by construction); no test checks that calls from the developer menu and the console go into the replay as the agent console; net_sim, net_kick, net_resync, net_end, net_overlay, player_join, player_leave, continue_game, and for Steam the achievements, steam_host, steam_invite and the cloud — only in Rust tests, not in scenarios; shards package and quit have no scenario (E11)
8 a module is a series of PRs, starting with phase A — the order of work

E1. Core, build and game template

№ What to do Status Where and how it was checked
1 crate shards: EnginePlugins, EngineConfig (with a window or without one, port, seed, tick, modules), re-export ✅ crates/shards, crates/shards_core. Modules are switched off with EngineConfig::without (--without audio,scatter): 17 modules can be removed (shards::modules; steam only in a build with its feature). A module that another one needs goes only with it. Connecting modules (coop, levels as tiles) are removed automatically. core, content, settings, motion, rules and action are always there. The set shows in ai/status (engine.modules). A test switches off each module and runs the engine for 60 ticks (tests/engine.rs). A game on real content without modules is not checked
2 a mode without a window: the same plugins, minus the window, rendering and sound ✅ crates/shards/src/plugins.rs (without_display); test headless_is_the_same_plugins_minus_display; MinimalPlugins is no longer in the sandbox
3 states: loading, menu, game, region loading screen, pause ✅ crates/shards_core/src/state.rs, loading.rs; tests crates/shards_core/tests/core.rs. EngineState::{Loading, MainMenu, InGame, RegionLoading} and PauseState, the loading gate. RegionLoading now works: every region change goes through it (regen, region_load), with tests in shards_world (regen_replaces_the_region_through_the_loading_screen_and_keeps_the_hero). Main menu: a game with after_loading: MainMenu and a screen main_menu: true shows it where a person can be (EngineConfig::menu: a window or --offscreen, without a session or named saves; --menu/--no-menu). Without a window, in tests and replays, it goes straight into the world with the same ids. Time stands still in the menu. new_game and continue_game start the game inside the call (menu.rs; tests core.rs +6, shards_save/tests/save/continue_game.rs, template/tests/game/main_menu.rs). Loading image: EngineConfig::loading_image covers the whole window in Loading and RegionLoading (shards_ui/src/loading.rs, tests/ui/main_menu.rs). A region change inside one call draws no frame, so the image is not visible during it. The template has the main menu and the image. The menu has not been looked at on a real display
4 versions: SemVer, git tags, CHANGELOG 🟡 CHANGELOG.md, version 0.2.0 in [workspace.package]. The maintainer sets the tags. Neither v0.1.0 nor v0.2.0 exists yet
5 template in template/: a character, an enemy, an arena, a save, two-player co-op ✅ template/: a character, an enemy, an arena, the game's own content kind, a tool and a condition, scenarios, a replay, 28 tests (and one #[ignore]: recording the reference replays). Saves (C9): own sections trophies (character) and fallen (world) in src/progress.rs, autosave of the cleared yard, scenarios/saves.scenario. Two-player co-op (C9): content/session.net.ron, scenarios/stand/coop.scenario, tests/game/coop.rs (a guest at 150 ms and 2%: the trophy is his on every copy and in his file, the next game starts with him, the host's replay)
6 CI: tests, clippy, template build, --verify of replays ✅ .github/workflows/ci.yml (jobs test, clippy, template, headless-cli, replays-window), .github/actions/setup. It runs on GitHub on every pull request, every push to main, release tags v* and by hand

Boundary ("the game adds plugins on top of EnginePlugins and does not change engine code"): ✅, the template and the sandbox are built on shards alone, test the_game_depends_on_shards_and_nothing_else.

For the AI (ai/status shows the version and modules): ✅ test status_names_the_engine_and_its_modules.

Done when Status How it is checked
the template builds and passes its tests apart from the sandbox ✅ template/ is a separate workspace with shards as its only dependency; CI job template; cargo test in its copy outside the repository
one replay matches with a window (under Xvfb) and without one ✅ --verify and --verify --windowed give one report; CI job replays-window (optional, continue-on-error)
CI is green on every PR ✅ the jobs run on every pull request and every push to main; on the branch for phases A–C all five are green (replays-window is still optional, continue-on-error)

E2. Movement: physics, character, input, camera

№ What to do Status Where and how it was checked
1 physics in FixedUpdate, deterministic; layers, trigger volumes, raycast and shapecast ✅ crates/shards_motion/src/physics/; tests tests/motion/physics.rs. There is no point in taking avian3d: it is for Bevy 0.19. Own kinematic physics on parry3d: colliders with ColliderId, layers, volumes (water, flow, trigger), raycast/shapecast/overlaps/volumes_at. Broad phase: a ground grid at four levels (cells of 2, 16, 128 and 1024 m; src/physics/broad.rs). A query checks the colliders of its cells in ColliderId order, with the same checks that used to run over all of them. So the answers and the order are the same as with a full scan. Unit tests compare them on random worlds from a fixed seed, with 40 to 2500 colliders. The reference replays of the sandbox and the template were recorded again, byte for byte. Where cells cost more than a scan (fewer than 32 colliders, a query the size of the world, a ray across the whole region), and for a query that is not finite, it scans. In a release build on 8×8 tiles of 96 m (2644 colliders), eight body queries take 16 µs instead of 50 (broad_phase_timing, #[ignore]). Loading the region expanse takes 0.6 s instead of 3.9, and a tick takes 0.5 ms instead of 0.9
2 controller: walking, running, sprinting, jumping, steps, climbing over ledges, slopes, swimming, gliding; a fall event ✅ src/controller/; tests/motion/controller.rs (28), edge_cases.rs, course.rs; Landed { fall_height }
3 controller parameters: an asset with hot reload ✅ content kind locomotion (CharacterParams); test locomotion_content_sets_the_numbers_and_a_reload_changes_them_on_the_next_tick
4 input: an action map into Intent, keyboard, mouse, gamepad, remapping with saving, hold/press, contexts 🟡 src/input/; tests/motion/input.rs (30). There is no bevy_enhanced_input for Bevy 0.20, so the map is our own. A remapping is saved in the controls settings (E8.6, settings.toml; an old input.ron is moved over once, and only if the game asks for it: InputSettings::for_game). accessibility.hold_to_toggle turns holding into a toggle. The key screen is the Binding widget (shards_ui, E9): a row waits for a key, a mouse button or a gamepad button and sends it to controls through ui_set. An input that is already taken is refused, and the action that holds it is named (tests/ui/bindings.rs, scenario remap.scenario, the panel "Keys and buttons" in the sandbox and the template). The gamepad is checked by tests on Gamepad entities. Stick look (C9): per-axis scale_x / scale_y and a curve on Binding::Stick, default-neutral and unserialized when default (map.rs unit tests, a_stick_with_a_bad_curve_or_scale_is_a_content_error_that_names_the_file). A real device has not been tried
5 camera: orbit, walls, lock-on and switching, aim assist, shake, field of view ✅ src/camera/ (the maths without a window: math.rs; systems: systems.rs, feature render); tests/motion/camera.rs. The camera is only a view. Gameplay and observe do not read it. C8: bodies are drawn between their last two ticks (shards_motion::interp: Interpolated on the visual child, captured in FixedLast, blended in PostUpdate; the follow camera uses the same pose; resets on jumps; setting graphics.interpolation; tests: 10 unit tests in src/interp.rs, 2 in tests/motion/camera.rs, render_interpolation_changes_no_game_state in sandbox/tests/sandbox/replays.rs, and one #[ignore] GPU test in offscreen.rs: the model moves between ticks, the body does not) C7: its numbers are content (camera kind, CameraTuning, src/camera/tuning.rs), the game adds to the base values through CameraOffsets (FOV, dip, pitch cap), the arm grows back smoothly after a wall, every smoothing is the exact exponential, the flick cooldown runs on Time<Virtual>; tests tests/motion/camera_content.rs, camera.rs. The picture (src/camera/picture.rs): the content's picture gives the cameras a tone mapping and a bloom (HDR), off by default, the camera's own given back when it is taken out; tests in the file (5). C6: lock-on is a simulation module when the game has a lock_on definition (src/camera/lock.rs: the content kind, the scored pick, the switch rule measured from the player, the aim point, the frustum at the base field of view, the line of sight; shards_action::lock: every lock checked every tick (dead, gone, out of range, hidden for obstruction_s, LockSight), the lock_switch press from a flick or the mouse wheel (one switch per turn of the wheel), the rule action.lock_on_valid (a game's despawns go before the check); a lock on an ally or another body the pick would never name is let go of; wheel_threshold in the content; a button binding for lock_switch is refused; a co-op client takes over a lock the host let go of, InputCapture::adopt_target); without one the camera picks and lets go as before; tests src/camera/lock.rs (7), tests/motion/camera.rs (2), camera_content.rs (1), shards_action/tests/combat/lock.rs (9), camera::math (1, the wheel), shards_net inputs (1), the control test of the rule, scenarios lock_on.scenario and stand/lock_on.scenario
6 API for warnings about off-screen attacks ✅ threat_indicators(world, viewer, forward) in shards_action::zone; markers at the edge of the screen — shards_action::render::hud
7 (F1a) look as input: Intent.look: Option<Gaze> (Gaze { yaw, pitch }, dir, flat_dir, toward; left out of the serde and the reflection form while None, so the nineteen reference replays, their snapshots and the recorded inputs are byte for byte what they were), the net mirror IntentState::look (the host drops angles that are not finite), core.intent_sane on a look that is not finite; the locomotion options face (Move or Look: a Look body's yaw is the look's every tick, no turn rate, and its aiming actions, tracking, backstep and leap search steer by it, machine::looked_at; the input map turns the keyboard's and the stick's axes by the look's yaw for such a body, by the camera's otherwise), pitch_limits_deg (default -89..89) and eye_height (default 0.9 of height), checked; shards::motion::{eye_of, look_dir, aim_point_of, params_of}; the player tool look (yaw=/pitch= in degrees, at=eN [part=NAME], clear=true; recorded as an input) and the AIM line of observe (shards::action::view_hit: a ray from the eye along the look against the world, the bodies and the hurtboxes, naming a body's part), the look fragment of a body's line ✅ crates/shards_core/src/intent.rs, crates/shards_motion/src/{eye,intent,controller/mod,controller/params}.rs, crates/shards_action/src/{look,machine,leap,predict,context}.rs, crates/shards_net/src/inputs.rs; tests: intent.rs (7: the axes, toward as the inverse of dir, no NaN straight up or down, the reflection form byte for byte as before and a snapshot written before the field read back), params.rs (4), eye.rs (3), machine.rs (1: steering by the look), tests/motion/input.rs (1: the walk turns by the look), shards_net::inputs (1: the codec round trip and the host's cleaning), sandbox/tests/sandbox/look.rs (9: the part a view passes through, a view that goes through any number of bodies that take no hits, a body that turns at once and walks the world's directions, a swing that goes where it looks and, as the control, one that goes where it walks, a run with looks replays identically and continues alike from its snapshots at --heavy 30, a client's look reaching the host in co-op) and snapshots.rs (a_look_and_the_body_that_faces_it_come_back); the scenario look.scenario and its reference replay look.json; the sandbox's locomotion viewer, prefabs viewer and range_dummy and the parts range_dummy (content: 229 definitions in 71 files with the weapons slice's). The type is Gaze because shards_look::Look is a component that prefabs name by its short name. Not in F1a (F1b): the first-person camera, the hidden own body, the view model, the view from a bone
8 (F1b) the first-person camera, the hidden own body and the view model: FirstPersonCamera (shards_motion::camera::first_person; chosen by the game or by camera content's mode: FirstPerson, default ThirdPerson; the orbit camera it may share an entity with stands still) turns the local player's Intent.look from the look axis (sensitivity, aim_sensitivity, inversion, the body's pitch limits; written only on a frame the axis moved, so a tool's look, a recorded input and a replay that plays are never overwritten) and sits at the interpolated body's eye, turned by whatever Intent.look holds, with the eye eased on steps, the landing dip (critically_damped_step), an optional bob and lean (camera content's first_person section, every field left out at its default), the shake and the game's offsets; read_input walks by the look under it; camera_mode (developer tool, session choice over the content); the own body's meshes on OWN_BODY_LAYER 62 (lights and other cameras with no layers get the layers while it exists, so the shadow stays and a mirror sees the body), a second camera (ViewModelCamera, VIEW_MODEL_LAYER 63, its own fov and near plane, loads the world and clears the depth) with a rig the bridge animates from the body's actions through ShowsBody (no second fighter, no AiId, picture only); the content kind view_model (SIMULATION = false) and MovesetDef::view_model (an id, left out when None) so an Arsenal switch swaps it; the audio listener of a first-person body is its eye (eye_of); the latency measured (one tick and one frame at most) ✅ except item 7 (the view from a bone: not built, optional) crates/shards_motion/src/camera/first_person/ (mod.rs, systems.rs, tool.rs), crates/shards_action/src/{view_model.rs,render/view_model.rs} and render/bridge.rs (ShowsBody), crates/shards_audio/src/mixer.rs, crates/shards/src/audio_wiring.rs, crates/shards_motion/src/input/mod.rs; tests: first_person/mod.rs (15), tuning.rs (1), tests/motion/camera/first_person.rs (18), tests/motion/camera/shot.rs (1), shards_action view_model.rs (2), crates/shards/tests/action_render/view_model.rs (3), shards_audio mixer.rs (1), tests/sandbox/first_person.rs (2, and an --offscreen shot, ignored without a GPU); the scenario first_person.scenario; the sandbox's models/view_model.glb (cargo run -p sandbox --example make_view_model), the animset arms, the view model arms (content: 274 definitions in 92 files with the other slices merged; the eye follows the crouch of F2); no reference replay changed. Not in F1b: the view from a bone, the window's cursor grab
9 (F12) the control lock: ControlLocks (a lock for each reason: movement, actions, a look Cone { at, deg }; absent while nothing is locked), lock_controls and unlock_controls, applied inside the tick as a mask on Intent taken by MotionSystems::Lock (SimSet::Act, before every reader) and given back by MotionSystems::Unlock (FixedLast, before the replay check; the input map writes only differences, so a held key must come back when the lock lifts), the look clamped and kept in Intent.look; crates/shards_motion/src/control_lock/ (the player tools' refusals that say why, the dev tools lock_controls and unlock_controls, the CONTROL line of observe, the engine rule motion.control_lock_sane) ✅ tests tests/motion/control_lock.rs (9: movement taken and the keys handed back, an order the body holds through the lock is not ended as blocked, a latched glide that ends under the lock is not given back, press by press which lock takes what, the cone and a look that went round, a cone on a body, the words (journal, observe, refusals, tool errors), a snapshot keeps the locks, the refusals of lock_controls) and unit tests in control_lock/mod.rs (2); tests/sandbox/sequence.rs (the locks reach the action machine and the controller, the keys come back; the unlock on SequenceEnded); a control test of motion.control_lock_sane in engine_rules.rs. Not built: the lock in a co-op client's prediction, the look nudge toward a point (picture only)

For the AI: the movement mode and speed in describe (ground 3.6m/s) are ✅; jump, sprint and glide are ✅; clearance and path_to by physics are ✅. path_to is a local grid A* (0.5 m, src/perception/path.rs). In a loaded region, move_to path=true and path_to ask the navmesh (E6) through RoutePlanner (provider in the answer). clearance closes the direction where the navmesh ends (closed; D4). Two floors within 1 mm are one floor (FLOOR_NOISE), so a body with step_height: 0 reads flat floor as free, not as ledges or drops (clearance and path_to; test a_body_with_no_step_height_sees_flat_floor_as_free_not_as_ledges in tests/motion/perception.rs). A move or move_to order that gets no closer for 2 s ends as blocked (src/orders.rs, tests/motion/orders.rs); the movement tools refuse a dead body.

Done when Status How it is checked
an agent runs the obstacle course by script: steps, a ledge, water, a drop with the glider ✅ crates/sandbox/scenarios/obstacle_course.scenario (the player with scope player); tests course.rs of the sandbox and the_obstacle_course_is_finished_the_same_way_every_time
without a window and with one the result is the same, and the replay of the course matches ✅ tests/replays/obstacle_course.json: test every_reference_replay_verifies_headless, --verify --windowed under Xvfb, CI job replays-window

E3. Actions, combat and animation

№ What to do Status Where and how it was checked
1 action as an asset: phases, cancel windows, displacement curve, cost, hitboxes, flags, network id ✅ crates/shards_action/src/def.rs (kinds action, moveset, combat_tuning); tests in def.rs and tests/combat/actions.rs. The displacement curve is data that is baked from a clip (F4): an action has bake: (animset, clip), and --bake-motion [ACTIONS] and the tool motion_bake (src/bake.rs, src/clipfile.rs) take the root-bone motion (the set's root_motion) at the tick rate (60 Hz). They keep only the forward motion (along +Z of the model; sideways goes into the report, and vertical motion is left to the picture). They also take the sample at the end of the action when it ends between ticks, thin the keys (0.5 mm), and edit the displacement field in the action's file in place. The same clip gives the same bytes. The clip's timing is checked against the action's phases (the phases property from Blender). The content check names the stale curve and the command. The sandbox's strikes and roll (light_1–light_3, heavy, roll) and the template's (light_1, light_2, roll) are baked. Tests: bake.rs (10), bake_motion_writes_the_curves_content_checks (run). The glTF reader neither hangs nor crashes on a broken file (node cycles, empty and wrong accesses are content errors; .gltf buffer names are decoded: %20). Vertical motion (a jump in the clip) is not baked. Enemy actions show the hero's clips phase by phase (D1.4: the clips carry their phases) and are not baked: their displacement is still numbers in the content. net_id is unique (validation)
2 action machine: Intent, input buffer, cancels through cancel windows, combos, block and perfect block, dodge ✅ src/machine.rs; a_three_hit_combo_chains_only_inside_cancel_windows, a_press_outside_the_window_is_buffered_then_rejected, dodge_i_frames_evade_a_hit_and_a_late_dodge_is_hit
3 hitboxes and hurtboxes in FixedUpdate through physics; one action hits a target once ✅ src/combat.rs (overlaps on the HURTBOX layer after movement); one_action_hits_a_target_once_however_long_it_overlaps
4 damage pipeline, the Damaged, Staggered and Died events, order by AiId ✅ src/combat.rs; hits_resolve_in_ai_id_order_whatever_the_query_order, damage_hooks_run_after_the_engine_modifiers
5 fighter resources: health, stamina, poise ✅ src/fighter.rs; stamina_waits_for_its_delay, broken_poise_comes_back_full
6 framework for statuses, without specific effects ✅ src/status.rs; statuses_build_up_from_hits_and_run_the_game_hooks, the_limit_holds_a_status_at_full_buildup, resistance_scales_buildup. The sandbox content has no statuses: checked with test content
7 animation: glTF with skins, a graph driven by the action state, blending, a shared skeleton 🟡 src/anim.rs (kind animset, select_clip), src/render/bridge.rs; crates/shards/tests/action_render (a skinned model and clips from another file with the same skeleton; a real humanoid from Blender: a roll on the spot, a bow from a second file). The model on a body: src/render/model.rs (GltfModel, the sandbox's and the template's way) loads its glTF file whole, so the model and the bridge's clips share one handle and one read (a file#Scene0 load reads the file again, bevy#10549, and could spawn the model twice); its scene (scene, 0 by default) is spawned when the file is in, and spawned again, the old one taken away, when the component is changed to another file or scene; a_gltf_model_shares_the_bridges_load_and_is_spawned_once. The model is a low-poly humanoid, built by the script tools/blender/humanoid.py (Blender 5.2 without a window, the export is byte for byte): 16 bones and 11 clips idle, walk, run, light_1–light_3, heavy, roll, block, hit, death (the sandbox also has bow, taunt and drink in a second file). The phase timings come from each game's own actions. The sandbox and the template put it on characters when there is a window or --offscreen (Animated is only for the picture; the replay does not check it). Steps raise dust (cues → effect). The swing sound whoosh is not played by a clip marker (that one sounds only where the model is drawn) but by the action's Sound effect. It is decided on the simulation clock, is the same without a window, and is the same for a co-op client (the host's ActionSound event). The set is checked against its files: a missing file, clip or root bone is a content error, and so is an action's anim that no set plays. The root bone stays on the ground (root_motion), and the action's displacement moves the body. Layers (upper and lower body, D7): layers: {"upper": (root: "spine")} in a set names a part of the body (a bone and everything under it). actions/tags take (clip: "drink", layer: "upper"). An entry written as a plain string still plays on the whole body. While an action runs, the layer's bones follow its clip, and the rest follow the movement clip. The layer's clip has its own node in the graph, with a mask over the bones outside the layer (bind_players builds the mask groups from the model's bones). The bridge itself drives the layer clip's share on the layer's bones (weight s / (1 − s) against the movement, whose weights sum to 1; AnimationTransitions drives one main clip), with the same blend as ordinary blending. Layer clips blend into each other with no gap in the movement. Picture only: ActionState, the replay and the snapshot do not see layers. Content check: a layer without a bone (root is empty or missing from the file) and an action with a missing layer are errors. The sandbox's flask (drink) drinks with the hand while the legs keep walking. The drink clip is in the second file, and the other clips and humanoid.glb kept their bytes. Not done: leg IK. The template and the sandbox use one skeleton for all characters. Layers are checked by tests on the humanoid, and by a --offscreen screenshot of the sandbox (the player walks east and drinks: the legs mid-step, the hand raised to the face). The screenshot was checked by eye, not compared with a reference image. Animation events are only for effects and sound. Props and clip families (D1.1, animation design D1): sockets, carry, mounts and by_moveset in a set, the kind prop, ActionClip::ends_equip, PropSwaps, the Sockets system parameter, the tool animation and the anim field of ai/status. The engine spawns the props (PropOf, no AiId) under the socket's bone and evaluates their place every frame from the action's time and the simulation clock (mount_places), so a join, a snapshot load and a hold are right; a sword goes to the hip during the drink and stays there for 0.05 s when a roll cuts it; a weapon switch shows the old kit until the new one is drawn and ends at once on a whole-body action or an event. Tests: action_render/sockets.rs, anim::mounting, existing_animsets_keep_their_json, the guarantee test a_replay_verifies_with_animated_bodies_and_the_picture_does_work. Motion modes (D1.2): the mount keys "@mode:<mode>" (rules while the drawn mode is <mode>, stepping aside yield_after seconds after an action in it) and "@left:<mode>" (after leaving it: wait, or until the fade out of the mode's clip is done, then the moves and the ModeLeft event), LayerDef::off_in, AnimSet::drops (the model lowered by a swing afloat, written on the root_motion bone by the new stage AnimSystems::Model), the tool's mode line. Tests: action_render/modes.rs, render::modes, anim::modes. The phase map (D1.4): ClipDef::phases (clip seconds), loops and holds; an action with the same phases is seeked phase by phase (phase_seek, AnimSet::progress, select_clip_timed, select_layer_timed), the body's clip, a layer's, the stagger and dead clips alike; a longer run stretches the last phase, a looped phase repeats at the authored speed and fires its own cues on each pass, never the earlier phases' (phase_place, ClipChoice::repeats, crossed_cues_in); a held phase plays at the authored speed and then holds its last pose (a long death or downed pose lies still instead of falling in slow motion; the sandbox's spar_down shows the held downed clip); checks for the phases, loops and holds (never both on one phase), an action sharing some names but not all (a moveset's unmapped stagger and death actions against the stagger and dead clips too), and the file's phases extra or length; the tool says by phase. The sandbox's attack, roll, block and drink clips carry their phases, so the warden's slash strikes as its active phase starts (it showed the strike about 80 ms early). Tests: anim.rs 5, bake.rs 1. Facing (D1.3): a body that faces a target (LocomotionInput::face) picks its gait's clip by its heading from its facing (Heading, quarters with 10° of slack; walk.back, run.left, idle.facing, ...), and without one plays back as the gait's clip backward (cues going down) and left/right as the clip itself; a switch between gaits carries the stride (carry_phase); ActionClip::turn turns the model to a face: Keep run's heading and back, on the root_motion bone (render/turn.rs); checks for the keys and turn; the tool says the heading and the turn. The sandbox's keep-facing spar roll turns the model. Tests: anim.rs 5, render/turn.rs 4, render/bridge.rs 3. Event overlays (D1.6): AnimSet::overlays maps an engine event (OVERLAY_EVENTS: blocked, parried, damaged, guard_broken, staggered, part_broken, landed) to a clip on a layer that plays over it from the event, by the simulation clock, with fade_in, a smoothstep fade_out and a strength; the action's clip and locomotion keep what it leaves; the same event restarts it from its share, death or a layer going off cuts it; the clip's cues fire (through the bones, as a body or layer cue does: D1.7); ActionClip::blend_out for a layered mapping's fade out; the tool lists the overlays and event= plays one on a drawn body. The sandbox's humanoid flinches on its upper body when damaged or blocking. Tests: anim.rs 2, render/bridge.rs 5, the sandbox's animation.rs 1. Cues at a bone (D1.7): a clip's cue may name a bone of the model and a strength (both left out of the JSON at their defaults), and AnimationCue then carries the bone's world position (at, from its GlobalTransform, found by node name and never below a prop) and the strength, so shards_fx::play_scaled plays the cue's effect at that point with fewer, smaller particles and shards_audio::play_scaled sounds it from there at a scaled volume, and the content check refuses an empty bone, a bad strength and, with the asset folder, a bone the model's file lacks, whichever file the clip comes from (tests: the cue defaults and checks in anim, bake::a_cues_bone_must_be_a_node_of_the_model and a_cue_on_a_clip_from_another_file_names_a_bone_of_the_model, the bridge's two bone-cue tests, a_cue_at_a_bone_plays_at_that_point_and_its_strength_scales_the_burst in fx, a_clip_cue_sounds_from_its_bones_point_and_its_strength_is_the_gain in audio). The slices of the animation design as reshaped from the GDD are all built.
8 telegraphs: zones on the ground, sound cues, symbols ✅ src/zone.rs, src/draw.rs, src/render/overlay.rs, src/cue.rs (SoundCue is played by the audio module of E9.5: the telegraph's sound plays at the place where the hit will land); the symbols !, ⚠, ↯, ✖, ▲, ◆, ↓, ↑ and ◌ (a ring with a gap, for an attack that cannot be blocked) are vector glyphs in draw::glyph_strokes, with ASCII stand-ins in draw::ascii_symbol
9 weapons: slots, switching, ammo, reload (F4, the FPS spec) ✅ crates/shards_action/src/arsenal.rs (Arsenal, grant_weapon, take_weapon, select_slot, add_to_charge, the switch system, the tools reload, weapon, give_weapon, take_weapon, give_ammo, the rule action.arsenal_sane, the prefab check), def.rs (Cost::charge_count, Effect::Refill, MovesetDef::{auto_reload, weapon} and their checks), machine.rs (Blocker::{Dry, NothingToRefill}, the auto reload in can_start, refill, Refilled), crates/shards/src/ui_wiring.rs (you.ammo, you.reserve, you.weapon); tests crates/shards_action/tests/combat/weapons.rs, crates/sandbox/tests/sandbox/weapons.rs (a cut reload loads nothing, a snapshot keeps magazine, reserve, slot and a waiting switch, the rule), the unit tests in def.rs and arsenal.rs; scenario weapons and its reference replay weapons.json. The wheel stays lock_switch in the standard map; a game without lock-on binds weapon.next/weapon.prev itself. Not built: an arsenal in a save, a draw time of its own (a game starts one from WeaponSwitched)
10 shooting: hitscan and 3D aim (F3, the FPS spec) ✅ crates/shards_action/src/shot.rs (FireDef, Effect::Fire, shot_ray, shot_aim, trace_shot, cone_dir, fire, the shared ray walker under view_hit, ShotFired, ShotImpact, the tool fire, the query shot_trace, the SHOT observe line, one journal line per shot), combat.rs (land: the landing of a hit shared by hit windows and pellets; DamageCtx::{guard_damage, shot}), objects.rs (SpawnAim::Look, SpawnDef::aim_error_deg), def.rs (the Fire and aim_error_deg checks), crates/shards_npc/src/perception.rs (a shot's Noise), crates/shards/src/net_wiring.rs (the net events); tests crates/shards_action/tests/combat/shots.rs (head and torso, a wall, pierce, allies and the dead, falloff, the same pellets in two runs, an NPC's aim error, recoil held to the pitch limits, a guard's guard_damage, a Look spawn along a pitched look, the tool and the query), crates/sandbox/tests/sandbox/hitscan.rs (three head shots against five body shots, pierce and a pillar, the scatter gun alike in two games, the noise, the reference replay with --heavy 10), the unit tests in shot.rs; scenario hitscan and its reference replay hitscan.json. Not built: a co-op guest's kick (the guest's next input frame replaces the host's kicked look), hit markers and tracers in a window

For the AI: the action's phases in describe are ✅; the hint "you are in the hit zone, step out N m" (ALERT …) is ✅; the tools light_attack, heavy_attack, block, parry, use_technique and lock_on (C6: side=left|right, the scored pick, the lock describer, lock lost lines) are ✅; refusals in the journal are ✅ (an_input_that_runs_out_is_journaled_as_rejected).

Done when Status How it is checked
the sandbox, driven by data, reproduces the GDD 39 fight: a three-hit combo, a heavy attack, block, dodge, stamina, an enemy with four attacks, poise, healing ✅ content crates/sandbox/assets/content/combat/; tests crates/sandbox/tests/sandbox/actions.rs (10)
an agent runs the fight by script, the same with or without a window, and the replay matches ✅ combat_prototype.scenario (the guard is beaten in 11 rounds; test the_combat_prototype_is_won_whatever_the_warden_chooses runs it after six different pauses), replay tests/replays/combat_prototype.json, --verify --windowed

E4. Content and levels

№ What to do Status Where and how it was checked
1 content base: typed definitions, stable ids, hot reload, schema and reference checks ✅ crates/shards_content (db.rs, load.rs); tests/content.rs (25). The format is RON. BSN comes when Bevy has a .bsn loader
2 level pipeline from Blender ✅ crates/shards_level (E4.2): glTF 2.0 with custom properties → colliders, sensors, markers (spawn, socket, navlink, trigger, interactable, camp, landmark, custom:), prefabs, components by name; content kind level; tools level_info, spawn_level, level_reload; hot reload (during co-op an edit waits, and nothing is placed from a file that has a waiting edit); tests tests/level/ (97). It reads only the JSON of the file. The crate is gltf =1.4.1 (we do not use Skein). Checked on a real export from Blender 5.2.2 LTS: tools/blender/outpost_level.py builds a level the way an artist does and exports it without a window. The export does not repeat byte for byte: the triangle order of the Boulder mesh varies from run to run, but the geometry is the same. tests/level/from_blender.rs (14) checks everything listed above on these files: node paths, axes and scales after Z-up → Y-up, all markers, all collider shapes, sensors, a prefab with overrides, components from the text, the dictionary and the flag, content check, the tools, hot reload, and errors with node paths. crates/shards/tests/level_render.rs draws outpost.glb with Bevy's loader. The export revealed four mismatches, now fixed: to as a property of a Data-Block, required extensions (lamps) without the render feature, properties on the mesh data, and the default scene instead of a null one. Compressed meshes are not supported (Draco, meshopt with EXT_ and KHR_, quantization; Bevy does not draw them either). The glTF Embedded variant is checked on an export: outpost_embedded.gltf is read, placed and drawn, the same as outpost.glb. The sandbox's and the template's ruin.gltf is exported by Blender in this variant (tools/blender/ruin_tile.py)
3 prefabs: an entity from an asset plus overrides ✅ src/prefab.rs; prefabs_spawn_with_extends_and_overrides, prefab_problems_are_found_when_content_loads. Now it is RON with components by name and extends. There are no BSN scenes
4 shards content check ✅ shards content check (a running game) and --check-content (without a game, code 0/1), check_dir. It reads level files (level: nodes, components, prefabs, required markers), whether the tile level files exist, and the baked navigation. The socket markers of a level file are checked against the tile's sockets in the RON (D4: add_content_check is a check that a module adds to a kind; TileLevelsPlugin installs it; test socket_markers_of_a_tiles_file_stand_where_the_tile_has_their_sockets). A tile file is read as a level file (the same check_level). It must be readable, and the problems in its nodes (a component, a prefab, a navlink that leads nowhere) are tile errors naming the file and the node. A file that a level definition also names is reported by level alone (tests a_tile_file_with_an_unknown_component_is_a_content_error_naming_the_tile_the_file_and_the_node, a_tile_file_is_checked_with_the_content_around_it_one_error_for_every_problem, a_tile_file_that_does_not_read_is_a_content_error_naming_the_file, a_tile_file_that_a_level_definition_names_too_is_reported_by_the_level_alone)
5 deterministic loading: the simulation starts after loading, and loading does not shift ticks ✅ LoadingGate and SimGate; nothing_ticks_until_loaded_and_loading_never_shifts_a_tick; the tile level files are behind the gate too (the_start_region_waits_for_its_level_files_and_stands_before_the_hero)

For the AI: content_list, content_get, spawn_prefab and reload by name (content_reload) are ✅; content errors in the journal are ✅. A content change made on the fly goes into the replay through content_apply (a_reload_is_recorded_and_its_replay_plays_the_same_game). Levels: markers in the entity descriptions (the_ai_sees_the_markers_that_matter); file errors with the node and the property (a_bad_component_name_is_found_with_the_file_the_level_and_the_node_path); a changed file replaces its instances through a recorded action (an_edited_file_replaces_the_spawned_level_through_a_recorded_action); the replay hashes the placed levels and the digests of their files (a_recording_against_another_version_of_the_file_diverges_at_its_first_check).

Done when Status How it is checked
the template builds a level from a Blender file with markers ✅ locally template: assets/tiles/ruin.gltf as the valley tile and ruin.level.ron with the required markers; the template's tests region.rs and content.rs; the file is an export from Blender 5.2.2 (tools/blender/ruin_tile.py, glTF Embedded), the same as the sandbox's
an edited number in an action's asset shows in the running game, with no restart ✅ an_edited_file_is_reloaded_while_the_game_runs, an_edited_number_changes_the_next_hit_and_replays_the_same; by hand: an edit of damage in the running game gave content reloaded: combat/player.action.ron (1 definition changed)
content check finds a broken reference and names the file ✅ a_missing_reference_names_the_file_the_id_and_the_field; by hand (docs/manual.md, "Content", "World and generation (E5)", "Levels from Blender (E4.2)")

E5. World generation and streaming (phase B)

Crate shards_world. Tests: crates/shards_world/tests/world/ (69) and unit tests (17).

№ What to do Status Where and how it was checked
1 a generator framework built from steps ✅ src/generate.rs: the stages Points, Roads, Cells, Fill, Secondary, Decorate and Checks, and the engine's steps (engine.*), work on data. The game adds a step (add_worldgen_step) or replaces a stage (replace_worldgen_stage). Randomness is GenContext::rng() on DetRng (seed, version, attempt, step). Tests game_steps_join_the_pipeline_and_their_panics_are_reported_with_the_seed, an_8x8_region_generates_passes_its_checks_and_is_byte_stable
2 socket solver ✅ src/solver.rs, src/sockets.rs: sockets with a height and parts, turns, fixed cells, borders, limits on numbers, propagation, lowest entropy, a bounded backtrack. A change log instead of copies (a 64 × 64 grid fits in 8 MiB). Tests fixed_cells_borders_and_limits_hold, a unit test for memory in solver.rs
3 checks: reachability, slopes, distances ✅ src/checks.rs: spawn, reachable, slope, distance, isolated_roads, custom. The rules are data of the region, and each failure names its rule and its cells. Tests checks.rs (8). Reachability follows passable sockets, the tiles' links and the navigation links. A tile's navlinks name the navlink markers of its level file, with the links groups that say where each one leads from and to. They are one way, as in the navmesh (a_navlink_takes_walkers_one_way_from_the_area_it_starts_in; a group without sides is a plateau that only a navlink leads to, a_point_on_a_plateau_is_reached_by_its_navlink_alone). Generation stays a pure function of the content and does not open files. content check checks that the navlinks match the file's markers (tests levels.rs: a navlink in the file that the tile did not name, a named one that is not in the file, two with one name). Which groups a navlink joins is the author's word, as with links: nothing checks them against the ground
4 region manifest ✅ src/manifest.rs: shards-region/1, a canonical record (keys in alphabetical order, three decimal places, one tile to a line), hash FNV-1a, origin is not written when it is (0, 0), and loading does not run the generator. Tests the_version_and_the_content_are_part_of_the_manifest, a_saved_manifest_loads_back_as_it_was. It is kept in the world save (E8): the region section v2 holds the manifest itself, loading builds the region from it, and an update that changes the generator does not rebuild an old world (a_saved_world_stays_as_it_was_after_an_update_changes_the_generator, a_world_another_generator_made_loads_on_the_host_from_its_manifest_and_its_clients_get_it, scenario world_save)
5 dungeons from rooms ✅ src/dungeon.rs: the kinds room and dungeon, the main path found by depth-first search, branches, hand-made rooms as fixed nodes (the minimum path length is raised to their number; a room with one door is a content error). Tests dungeon.rs (4), a_crypt_loads_like_any_region
6 shards worldgen --seeds 1..1000 --report ✅ src/report.rs; shards worldgen --region R --seeds S --report, <game> --worldgen-report R --seeds S, the tool worldgen_report. The report gives passed, retried, fallback, failed and panicked seeds; the causes with example seeds; errors (when the fault is not an attempt); and distances. Tests a_thousand_seeds_pass_their_checks_quickly, a_seed_that_fails_with_no_attempt_to_blame_says_why_in_the_report, worldgen_report_runs_in_a_live_game, unit tests in shards. By hand: 1000/1000 passed … in 0.31s
7 streaming; enemy AI only in active zones 🟡 The region loads whole behind the loading screen (RegionLoading). Enemy AI runs only in active zones (ActiveZone/Dormant, zones.rs; test npcs_far_from_every_player_go_dormant_and_wake_when_one_comes). Only the picture of the tiles streams by distance (stream.rs, visual_lods, only when the game draws: a window or --offscreen; test tile_visuals_come_and_go_with_the_players). The tiles' geometry for physics is created in full at once, and there is no loading by distance. At the current sizes it is not needed. A region of the full size from the spec (the sandbox's expanse: 8×8 tiles of 96 m, about 1900 colliders, autotest reference96) loads in a release build in 0.61 s, together with the navmesh of both body classes (2.3 million nodes each), against the 10–15 s in the spec. A tick takes 0.46–0.63 ms. Physics queries do not grow with the region, thanks to the broad phase (E2.1; without it loading takes 3.9 s and a tick 0.9 ms). Foliage also scatters in full on loading, so on a large region there is less of it (see "Known limitations")

Loading a region: regen, region_load, goto_tile, region_info, world_overlay, the start region (start_region), on_region_loaded for modules (the navmesh), the region's origin. Tests: regen_replaces_the_region_through_the_loading_screen_and_keeps_the_hero, a_session_that_changes_regions_replays_identically, a_manifest_with_a_prefab_content_lacks_is_refused_before_the_old_region_goes, players_and_goto_tile_stand_on_a_floor_above_the_tile_plane_not_inside_it. Tiles from level files (TileLevelsPlugin): level_tiles_stand_where_their_nodes_say_for_every_quarter_turn, a_session_with_level_tiles_changing_regions_replays_identically, a_level_with_problems_refuses_the_change_before_anything_is_touched. The world_overlay overlay (tile bounds, sockets, points, roads) is ✅: what it passes to the gizmo is computed first (TileDraw::of) and kept in the TileDraw resource (as CombatDraw does for the combat overlay). So the tests in tests/world/overlay.rs (7; they need the render feature, which shards_world has in its dev-dependencies) read this without a GPU or a window: nothing_is_drawn_until_the_tool_asks_for_it_and_the_tool_turns_it_off_again, every_tile_gets_its_bounds_every_socket_part_a_mark_every_point_a_ball_and_every_road_a_line, the_road_marks_of_a_turned_tile_sit_on_the_turned_sides_and_meet_their_neighbors, the_parts_of_an_edge_run_clockwise_round_the_tile_whichever_way_it_is_turned, a_crypt_has_room_bounds_doors_and_no_sockets, a_new_region_is_drawn_as_soon_as_it_has_loaded_and_the_overlay_stays_on, without_the_gizmo_plugin_the_tool_still_answers_and_nothing_is_drawn; the picture itself was checked by eye: under Xvfb, shards shot shows it together with the navmesh overlay.

For the AI: in observe, the TILE and POI lines (TILE (1, 1) gate rot 0 · wilds seed 42 v1, POI e23 spawn.0 0.0m here · …) — ✅; tools regen, goto_tile, worldgen_report, region_load, region_info — ✅; ai/status → world; condition near_poi.

Done when status how it is checked
the template generates an 8×8 region from test tiles ✅ template: the valley valley (4 tiles, three camps), sandbox: wilds (9 tiles)
1000 seeds pass the check ✅ --worldgen-report wilds --seeds 1..1000, the same for valley; tests; CI jobs headless-cli, template
the same seed and version give a byte-for-byte identical manifest ✅ the_same_seed_and_version_give_the_same_manifest_byte_for_byte (template), scenario region (hash 7bbfdc3b62623fbc)
moving between regions through the loading screen works without a window ✅ regen_replaces_the_region_through_the_loading_screen_and_keeps_the_hero, replay region.json, --verify --windowed

E6. Navigation and enemy AI (phase B)

Crate shards_npc. Tests: crates/shards_npc/tests/npc/ (135, 6 of them in overlay.rs with the render feature) and unit tests (50); crates/shards_world/tests/world/nav.rs.

№ what to do status where and how it is checked
1 navmesh over the tiles, global route ✅ src/nav/: tiles and rooms are baked ahead of time (--bake-nav, nav_bake, files assets/nav/*.navtile.ron, a hash checked against the definition, the prefabs and the level file, BAKE_VERSION). When a region loads, they are stitched along open sockets and navlink, and carved out by solid bodies that the baking did not see. Route: A* over the tile graph → A* over the corridor grid → string pulling. Queries work without a window. The movement rule is the same step_onto that path_to and the controller use. Its own navmesh, not vleue_navigator/oxidized_navigation/landmass. Tests navmesh.rs: a_tile_bakes_to_the_same_bytes_every_time, bakes_are_checked_against_their_tiles_and_baked_again_when_stale, stitching_turns_tiles_with_them_and_follows_open_sockets, carving_is_the_solids_standing_now_not_their_history, routes_go_around_a_pillar_inside_a_tile_and_across_three_tiles, a_hundred_routes_on_an_8x8_region_stay_within_budget; generated_regions_get_a_navmesh_that_routes_between_their_points (shards_world). Body classes — ✅: bodies in nav (NavBodyDef: locomotion, radius, height); each class is baked into its own folder (assets/nav/large/; the format and BAKE_VERSION are the same; the agent files are unchanged, byte for byte) and stitched into its own region navmesh. NPC routes, its straight line to a goal in sight, nav_path, and move_to path=true/path_to/clearance use the tightest class that serves the walker's whole body (NavRegion::serving: not narrower, not lower, the step, climb and slope no worse, the same swim depth; among those, the narrowest, then the lowest). A body that no class serves plans on the local grid with its own body, and npc_state (nav.routes, with what the body lacks for each class: NavRegion::unserved) and npc_overlay say so; nav_path body=large, nav_info → bodies, and --check-content names the file of each class. Tests bodies.rs (9): a_large_body_routes_on_its_own_navmesh_through_the_door_it_fits (a 1.5 m opening fits only agent; the large body goes through the 3.5 m door and no closer than 1.15 m to the wall), an_npc_as_wide_as_the_large_class_walks_its_navmesh_and_says_so, an_npc_outside_the_region_plans_on_the_local_grid_and_the_tools_say_so (npc_state, nav_path and npc_overlay say the same thing), under_a_games_own_route_provider_the_tools_name_no_body_class, every_body_class_bakes_to_stable_bytes_and_content_checks_each, body_classes_are_checked_like_any_content (and the class capsule with its own radius/height), the_classes_of_a_region_are_its_navmeshes_by_name, a_tall_npc_routes_on_a_class_as_tall_and_never_under_a_lintel_it_does_not_clear (an NPC 2.4 m tall under a 2 m lintel: it uses the class tall and goes through the door, not the gap under the lintel; the route, the straight line to the goal, npc_state, nav_path and the passage itself), a_tall_npc_no_class_serves_plans_on_the_local_grid_with_its_whole_body (with no class of the right height, the local grid plans with its whole body, and the reason is in npc_state); unit tests for choosing a class, nav::region (3); scenario npc_bodies (the sandbox's guard in wilds — class large)
2 agents: following a path, avoidance, limiting the chase area ✅ following and the Home leash — ✅ (a_sentry_chases_to_its_leash_goes_home_healing_and_never_crosses); avoiding bodies — ✅: selective reciprocal velocity obstacles (src/nav/avoid.rs, system nav_avoid in NpcSystems::Drive, only Intent); the numbers are avoidance in npc_tuning or in a behaviour; npc_state → nav.avoiding, npc_overlay → avoiding e7, condition npc_avoiding; tests avoid.rs: two_npcs_meeting_head_on_in_a_corridor_pass_without_touching_or_stopping, four_npcs_closing_in_on_a_player_keep_their_bodies_apart, without_avoidance_npcs_walk_their_routes_as_if_alone, the_same_pack_ends_in_the_same_places_twice, npc_state_and_the_overlay_say_whom_an_npc_steers_around, unit tests nav::avoid (8), two_npcs_walking_into_each_other_pass_without_touching; scenario npc_avoidance; a goal in plain sight — a straight line only where the navmesh confirms the steps on the ground; with no route, the NPC stands still (an_npc_does_not_walk_off_a_cliff_toward_a_target_in_plain_sight, an_unreachable_goal_is_a_clear_error); outside the navmesh — a sweep of the body's capsule from step height to the top of the head, and under a lintel lower than the body there is no straight line (a_goal_through_an_arch_is_in_plain_sight_only_for_a_body_that_clears_it); an NPC that has drifted from the checked straight line farther than its radius plans again (NavAgent.planned_from, an_npc_put_off_its_straight_line_plans_again_before_walking_off_a_ledge); the avoidance limits in the content — avoidance_numbers_are_checked_in_the_tuning_and_in_a_behaviour
3 NPC behaviour framework, perception ✅ behavior (a state machine in the content; no utility scores), hooks add_npc_condition and add_npc_state; sight with physics rays, hearing (Noise), memory; randomness through SimRng. Tests fsm.rs (4), perception.rs (10), warden::the_warden_as_data
4 combat director: attack tokens ✅ director: tokens by the number of players (set in the data), a budget, allowed combinations, roles for the waiting NPCs; a token comes back when the attack ends, when patience runs out, on death, on sleep, when the target is lost, on an agent's order, or when the limit drops. Tests director.rs (12), scenario npc_director
5 attack planner ✅ attack_plan: weights, distance windows, cooldowns, bans on sequences, a budget; shared by the skeletons and the sandbox's guard (the guard runs entirely on it). Tests planner.rs (13 unit tests), schedule.rs (1 unit test), the_written_out_states_wait_then_strike, scenarios combat_prototype and boss_fight with NPCs
6 gunfire, hiding, ranged fighters, turrets (F11, the FPS spec; items 1-4) ✅ crates/shards_npc/src/threat.rs (NpcThreats, the perception option notice: Threats: a non-combatant notices only bodies it saw attack while armed or heard fire a shot, whatever their team; the condition threat_known), hide.rs (hiding_spot, hiding_search: navmesh nodes reached by a breadth-first walk, farthest from the threat first, ties by node id, WORLD rays from the threat's eye to the eye and the middle of the body, at most 4096 nodes and 96 rays; the hooks hide and cower, the condition no_hiding_spot), ranged.rs (AttackPlanDef::keep_range, keep_band, NpcFireLine traced once a tick after the brains, Refusal::LineOfFire after Machine, fifteen rules), turret.rs (the content kind turret, Turret { def, active, rest }, the system after the intents, set_turret_active, TurretSwitched), crates/shards_action/src/shot.rs (FireDef::aim_error_moving and aim_error_far, line_of_fire, fire_effects), ai.rs (the describer npc_ranged, npc_state threats, hiding, range, turret, perception.notice, npc_schedule line_of_fire, the dev tool turret_active, the conditions npc_hidden and npc_line_blocked); Npc now requires Intent (a non-combatant without Fighter is driven too). Every new field is left out at its default and lives on new components inserted only for new content: every existing reference replay verifies unchanged. Tests: unit tests in shot.rs (the aim error by speed and distance, the checks), turret.rs (3: the turn rate and the limits from the rest, the short way round, the checks), ranged.rs, threat.rs, planner.rs (the rule table over fifteen rules); tests/npc/ranged.rs (3: a hiding spot behind a pillar and none off the navmesh, a guard of its own side seen firing is a threat and the unarmed hostile player none, a shot heard within its noise and not beyond); crates/sandbox/tests/sandbox/npc_ranged.rs (6: two bystanders hide and stay out of sight, one cowers off the navmesh, a gunner holds its band and never fires through its ally, a strafing gunner hits less, a turret within its limits, on and off, the reference replay with --heavy 10); the scenario npc_ranged.scenario and its reference replay npc_ranged.json (the 24th); the sandbox's neutral content **/ranged.*.ron (268 definitions in 86 files with the movers'). Not built: guards that move between cover points (item 5, waiting for the design)
7 (F12) scripted NPC sequences: the content kind sequence (roles; steps MoveTo, Face, Play, Sound, Wait, WaitFor, Signal), play_sequence and stop_sequence, Sequences (snapshot state, the replay check sequences) and SequenceHold, the step system in NpcSystems::Decide, the brain dormant while held (decide skips it, the director, planner and combo count it as under orders, the turret and the line of fire stand down), ActionSound for a line, force_action for an action, the condition registry for WaitFor; crates/shards_npc/src/sequence/ (def.rs, run.rs, step.rs, tools.rs: the dev tools sequence_play and sequence_stop, the query sequences, the condition sequence_playing, the SEQUENCE lines of observe, npc_state.sequence, the engine rule npc.sequence_holds); the sound check of a Sound step is the umbrella's (audio_wiring.rs) ✅ tests tests/npc/sequence.rs (14: a whole scene tick by tick, a host keeps an empty resource for a snapshot without one, a held brain chooses nothing and goes on, every refusal of play_sequence, the orders an agent gave dropped (and the tools that give orders refuse a held body), stopping, a run an observer stops while it steps, a death, a body gone and a step past its timeout, a scene with no bodies, a snapshot at the start and part-way through every step, a snapshot without a run, the content checks, the words), def.rs (1); crates/sandbox/tests/sandbox/sequence.rs (7: the room's file, the scenario, a game that unlocks on the end of the scene, the locks on the machine and the controller, a snapshot at every step of the scene, the sound checks, the reference replay in heavy mode); control tests of npc.sequence_holds in engine_rules.rs; the scenario sequence.scenario and its reference replay sequence.json (the 26th). Not built: steps that run side by side on two NPCs, a Sound that waits for its line, a MoveTo to a body

For the AI: the NPC status line in observe (fight e5 · token · leash 9/10m, idle (dormant)) — ✅; transitions, issuing and returning tokens in the journal — ✅; tools nav_path (body=), npc_state (nav.routes), npc_set_state, nav_info (bodies), nav_bake; conditions npc_attacking, npcs_calm, npc_beyond_leash, npc_detour, npc_avoiding. Navmesh overlay (nav_overlay: cells, links across edges, navlink, NPC routes; E11) — ✅: what it hands to the gizmo is in the resource NavDraw (shards_npc::nav::overlay), and the tests tests/npc/overlay.rs (6, with the feature render: cargo test -p shards_npc --features render; in cargo test --workspace it is enabled) read this without a GPU or a window: nothing_is_drawn_until_the_tool_asks_and_it_brings_the_tile_overlay_with_it, cells_are_green_to_walk_blue_to_swim_and_red_where_a_solid_carved_them_out, only_cells_and_links_near_a_player_are_drawn, links_across_tile_edges_are_cyan_lines_and_navlinks_yellow_arrows, an_npc_with_a_route_has_it_drawn_from_where_it_stands_to_its_goal, without_the_gizmo_plugin_the_tool_answers_and_nothing_is_drawn; the picture is shown by shards shot under Xvfb together with world_overlay. NPC overlay (npc_overlay, F7; D4) — ✅: a line for each NPC near the players (state, goal, token, leash, what it sees and hears, route) and a gizmo in the window; the test npc_overlay_answers_a_line_per_npc_near_the_players, scenario npc_navmesh, the window checked by eye.

Done when status how it is checked
an enemy in the sandbox walks around the pillars by the navmesh and does not leave its zone ✅ scenario npc_navmesh, test an_npc_walks_around_pillars_by_navmesh_and_stays_on_its_leash, the template's raider has a_raider_comes_by_the_navmesh_and_keeps_to_its_camp
with one player, no more than two of three enemies attack ✅ scenario npc_director (three_attacking does not hold on any tick), one_player_three_enemies_never_more_than_two_attack_at_once
everything matches in the replay ✅ npc_director.json, npc_navmesh.json; tests a_recorded_npc_fight_plays_back_identically, a_recorded_npc_walk_on_the_navmesh_plays_back_identically; snapshot: an_npc_fight_loaded_at_any_tick_ends_the_same, a_generated_region_with_npcs_on_its_navmesh_loads_and_goes_on_identically

Navmesh limitations: it is baked for the agent body and the bodies classes; a walker (and an NPC) that no class serves (wider or taller than all of them, a weaker step, climb or slope, or swims at another depth) plans on the local grid with its own body (a_walker_that_climbs_less_than_the_baked_body_plans_on_the_local_grid, a_tall_npc_no_class_serves_plans_on_the_local_grid_with_its_whole_body): a tall NPC needs its own class in bodies, or else it walks the local grid, which is slower and searches a bounded area; each class is one more tile bake and one more navmesh of the region in memory and at load time, and nav_overlay draws only the agent navmesh; bodies cannot jump, a navlink suits a descent, a climb within the body's climb and step limits (navlinks_the_body_cannot_make_are_not_used); carving can only switch cells off; the navmesh must be baked again after a change to a tile or to any class's body (BAKE_VERSION — after a change to the baking itself).

E7. Networking and co-op (phase C)

№ what to do status
1 session: single-player, host, client ✅ NetPlugin: --host, --join, --stand N; NetState, net_status; in a single-player game the module does nothing (the reference replays stay the same). Tests crates/sandbox/tests/sandbox/net.rs (two of them are measurements under --ignored), net_lifecycle.rs
2 transport: UDP on a LAN, in-memory transport ✅ crates/shards_net (no Bevy): MemoryHub (in memory, deterministic: one seed and the same sends give the same deliveries), UdpTransport (LAN), simulated conditions LinkConditions/Conditioned over any transport, Link (unreliable "last one wins", reliable ordered, blobs, deflate with an unpacking budget, acknowledgements, RTT, loss, speed, timeouts); 81 unit tests (src/tests.rs, conditioner_tests.rs, hub.rs, udp.rs, wire.rs, track.rs). The session built on it (on Bevy) covers items 1, 3, 4, 6–8
3 input with a tick number ✅ Intent frames with a tick and a surplus; the host applies them on its own tick to the player's body (and after a respawn); limits on a frame and on a packet (and on a packet's bytes before parsing); epochs when the world is rebuilt; while the host's ticks run in sequence (net_resync, desync, region change), input in flight survives a Rebase, the client's clock does not go back, and a held input that the host reset is sent again; a snapshot that moves the tick starts the input again, even if its world is waiting for room in the channel; the host's replay records everyone. a_dodge_on_a_client_is_an_input_of_the_host_at_its_tick, a_dodge_over_a_lossy_link_lands_on_its_stamped_tick, net_sync.rs, net_guards.rs
4 replication ✅ deltas by the replication rules in the area of interest and by references; hashes every desync_every ticks; a desync is logged, net_desync (on the client and on the host), and the world is rebuilt no more than once every 5 s (the count starts again with a snapshot that moves the tick); a view whose references have hit the cap of 64 is not checked while that holds (every_entity_in_view_is_sent_when_its_references_reach_the_cap); values that cannot be read back (NaN) stay on the host. Other entities in the client's window are shown between two states of the host (interp, a buffer with unit tests; a new entity is in its place at once); their game Transform is the host's newest state (others_are_where_the_hosts_newest_state_has_them). Not checked in a window
5 prediction ✅ C4: the client's own body moves on the tick of the key press (NetSet::PredictInput → Predict → PredictEnd, the same systems for orders, movement and actions with With<Predicted>); actions start at once and the host confirms them; damage comes only from the host; a correction by ticks (correction_rate), a snap on a large error, a diverging movement mode, death, and the first comparison after the world is rebuilt or the clock jumps; after a snap the body is left alone until the state it took catches up with the host's stamps; path points already passed stay passed, and an order the host has finished arrives with its aim/target. crates/sandbox/tests/sandbox/net_predict.rs (14 tests, 150 ms and 2 % loss: running, a pillar, a path through points, a walk to an attack's target — error 0 m), unit tests shards_net::predict, inputs. The review of C4 (9 findings) is closed; the new tests were checked against the unchanged code
6 the world through a manifest ✅ the world arrives as a snapshot with the region's manifest, and the client builds the region itself; a region change and a snapshot on the host send the world again and check the players against the new world; a player the host added itself stays, whatever number a guest held before it: the bodies of peers are marked NetSeat, and the guest bodies of a snapshot from another process leave (a_region_change_on_the_host_sends_every_client_the_new_world, a_snapshot_loaded_on_the_host_goes_to_its_clients, a_body_the_host_joined_itself_stays_through_a_rebuilt_world, a_number_a_guest_left_is_the_hosts_own_once_it_joins_a_player_there, guest_bodies_of_a_snapshot_loaded_into_a_new_host_leave_and_free_their_numbers, net_sync.rs)
7 joining and leaving ✅ the hook join_policy ("not during a boss"), a refusal with a reason for a different build and a full session; leaving and timeout — the body waits for rejoin_grace_secs; return by the host's token (stored in <save-dir>/net/, checked over UDP: a_client_joins_a_host_over_udp_loopback); a second game with the same token takes the slot (and holds it while it waits for join_policy: a_slot_a_second_game_took_stays_its_own_while_it_waits), the first gets a Bye with a reason, and the character goes with the connection that has left, even when that connection is not the host's first (a_second_game_with_a_players_token_takes_the_slot_and_the_first_is_told); the host leaving and net_end end the session once, with the characters given to the clients: players leave, and those waiting are refused (net_end_lets_the_players_go_and_refuses_whoever_waits); a client that has finished goes quiet, and the host does not admit a peer on acknowledgements alone; --exit-with-host: 0 — the end came from the host, 1 — refusal, kick, loss of the host, 2 — the session could not be opened; over UDP, pause/resume/speed belong to the host. Before the session ends, the host saves the world and its own character; the clients' characters leave with SessionEnd once (E8, shards::coop)
8 network debugging ✅ net: lines in the journal (rate-limited for what a peer triggers), net_sim (latency and loss on the fly), net_status, net_kick, net_resync, net_end, conditions net_joined, net_left, net_disconnected, net_desync; the network overlay net_overlay (F6: channels, desyncs, prediction error, snaps) and the field prediction in net_status (C4); on the client, also desyncs and last_desync (C9). Network CLI (C7): shards --peer c1, wait --peer all, shards stand and stand stop, stand scenarios (stand clients=2 …, @c1). Long runs: shards soak (C9)

Groundwork (C1): the client does not run SimSet (simulates/predicts, NetSet::Predict, Predicted), the replication rules (net_ignore, rules_hash), the state codec shared with snapshots (ai_core::state), application tokens of one process, tool routes for the client, an agent bound to a player, a deferred step, SeedLock, exit hooks, and the flags --host/--join/--stand.

Session protection (S2): joining starts with a knock that carries no state at the host (shards_net::cookie): the host answers the knock with a cookie — SipHash-2-4 under its own random key, over the address, the client's session, the channel protocol version and a window of 30 s — and it remembers nothing (over UDP the answer goes through Transport::reply, and the address does not become a bound peer); a peer is admitted only by a datagram with a message and the cookie of this address and session (it lives 30–60 s), which the client carries in its acknowledgement fields until it hears from the host. The channel and session protocol is 2; the host answers a game of the previous build with a refusal on its protocol 1 (at most 8 times a second). The limits of the strangers table and the parse budgets are unchanged. A character over 64 KB (up to 1 MB) is sent after Hello in pieces of 32 KB; the peer holds the player's place while they are sent; the client saves its own character through the host (save_game what=character: CharacterAsk → CharacterSave, at most once a second); content does not change while other machines are playing on it (ContentGuards: refusal of content_reload, content_apply, level_reload; an edit from disk waits for the end of the session). Tests: shards_net (cookie 3, datagram format 3, UDP 1, session 8: the knock, another address's cookie, sessions, a made-up and an expired one, the strangers table, an old build, a character in pieces), shards_content (an edit waits while content is held), shards_level (a file with a waiting edit is not applied), net_guards.rs (+5), net_coop.rs (+4), net.rs (the knock over UDP), stand scenario session_guards.scenario.

Session (C3) and fixes from review: a guest acts only with its own body (the host runs only forwarded tools, with a limit on calls and agents), everything a peer sends is limited and goes to the journal truncated, the return token is issued by the host (the host lets a second game with the same token in, and lets the first go with a reason), a player the host added itself survives a rebuild of the world; over UDP the client's clock comes from the host (the transport decides, not a test flag). Fixes from the second review (C3 fix review: the client's clock after the world is rebuilt, and input for a world that waits for room in the channel after a snapshot, held input that the host reset, the desync count after a snapshot, the NetSeat stamp, an incomplete view without a check, sizes before parsing, the text of Bye and of parse errors, waiting for room in the channel by bytes, a line per second about unsent data, the slot of a second game, net_end and silence after the end, speed on the stand, exit codes, the stand's exit hooks, the stand host's settings) are closed by tests in crates/sandbox/tests/sandbox/net_*.rs, by the unit tests of shards_net and shards (run.rs); each of them was checked against the unchanged code: it fails or (for new functions) does not build. Not done under this review: a limit on how often Hello, Ready and Bye come in a row (see the section below; with S2 a peer is admitted only by the cookie, but the rate of messages from a peer already admitted is held only by the parse budgets).

CodeRabbit review of PR C3: over UDP the client's clock does not run backwards (far ahead of the host, the client runs at half speed; far behind, it jumps only forward; unit tests client::tests), net_events from the old world are not shown after the world is rebuilt (events_of_the_world_a_snapshot_replaced_are_not_shown_and_do_not_hold_back_the_new_ones), step and resume from one participant in one frame run in the order they were called (a_step_and_a_resume_asked_in_one_frame_run_in_the_order_they_were_asked), snapshot_load with an inexact restore puts the world back (a_load_that_would_not_be_exact_is_refused_and_puts_the_world_back, a_load_that_cannot_restore_exactly_fails_and_changes_nothing). The third review of C3 (round 3): a jump in the host's tick is noticed before the frame's players are admitted (a_client_admitted_in_the_frame_the_hosts_ticks_jump_keeps_its_inputs_through_a_resync). A view that has had its reference cap lifted sends the client the world once, and does not wait for a desync (a_view_that_stops_being_capped_gives_the_client_the_references_it_read_as_nothing). The "view complete" world keeps the view's memory and goes out no more than once every 5 s (a_view_that_stops_being_capped_through_the_hysteresis_gives_the_world_once_not_every_few_ticks, a_cap_that_comes_and_goes_costs_a_world_per_cooldown_and_not_one_per_flip). Deltas are not sent to a player until the rebuilt world has been sent to it, while that world waits for room in the channel (a_region_a_guest_changed_while_its_link_was_full_reaches_it_whole_not_as_deltas_first). A departed peer that is still acknowledging waits for its Bye behind megabytes in the queue (a_player_sent_away_is_waited_for_while_it_takes_in_what_is_queued_ahead_of_its_goodbye; a deaf peer leaves as before). Stranger: a first message that is not a Hello is refused (what cannot be parsed is refused with both reasons), a shared parse budget (polling goes in PeerId order and starts from the one that was skipped; player numbers for players whose Hellos arrive in one tick follow the PeerId order: on a stand, the order of creation; over UDP, the hash of the address, players_that_say_hello_in_one_tick_take_their_numbers_in_the_order_of_their_ids), a limit on the number of peers not yet in the game (a new one does not evict an unread one; no more than max_players peers hold a place: a_hello_is_not_lost_to_the_strangers_that_arrive_with_it, a_burst_of_strangers_in_one_tick_never_fills_more_than_the_cap_and_spares_the_first_few, a_hello_that_comes_in_pieces_is_held_for_a_while_and_then_makes_room_as_any_other, a_message_ahead_of_a_gap_pins_no_seat_and_a_hello_still_gets_in, strangers_holding_part_of_a_hello_pin_no_more_seats_than_a_session_has_players, a_hello_in_pieces_is_spared_before_messages_that_can_never_be_a_hello; admitted players who have left are evicted last, by time of leaving: a_table_full_of_players_that_were_put_out_and_still_owe_acknowledgements_makes_room_for_a_hello, a_guest_put_out_between_ticks_is_the_last_a_full_table_forgets_not_the_first), the JOINING_POLL_BYTES budget is checked by an unreliable stranger (a_stranger_whose_first_message_is_not_a_hello_is_refused_at_once, peers_that_do_not_play_yet_share_a_budget_and_each_takes_a_turn, the_host_holds_so_many_strangers_and_the_oldest_makes_room, a_stranger_that_is_not_refused_is_read_for_so_many_bytes_a_poll_and_no_more). Not done: the calls_queued check before a Call from an admitted guest is parsed; a smaller max_undelivered_bytes for the channel before joining (the channel inflates messages up to the poll budget). A world rebuilt by a guest's call reaches the clients (a_region_change_a_guest_forwards_reaches_every_client_as_a_world_again). Rebuilding the world resets the mark of a capped view and the deadline of the view complete world (a_world_replaced_in_a_capped_view_is_not_followed_by_a_world_for_the_cap_that_is_gone), as does any whole world, except view complete (a_world_sent_again_to_a_player_in_a_capped_view_is_not_followed_by_a_world_for_the_cap_that_is_gone); the Link::reliable_acked counter also counts the pieces of a blob (unit test a_blob_that_takes_long_to_cross_keeps_raising_what_the_peer_has_acknowledged). A peer's work per poll is limited, a released peer is not read, a join has a deadline, net_kick peer= (a_guest_makes_the_host_decode_no_more_than_a_budget_in_one_poll, what_a_stranger_sends_after_its_refusal_is_not_read, a_peer_that_never_says_hello_is_dropped_however_it_keeps_sending, a_peer_that_never_acknowledges_its_refusal_is_forgotten_all_the_same, net_kick_sends_away_a_peer_that_has_no_player_yet, a_player_the_game_keeps_waiting_is_not_dropped_for_joining_slowly_and_a_kick_reaches_it). A world larger than the channel can carry is refused once (a_world_over_what_a_link_carries_sends_its_player_away_once_instead_of_waiting_every_tick, a_world_no_link_carries_is_tried_not_waited_for). A refused snapshot load does not push the old journal lines out (a_refused_load_does_not_push_the_oldest_journal_lines_out). A client waiting for the host's state wakes up when a delta arrives (a_state_that_came_wakes_a_client_that_waits_for_news, a_state_that_came_makes_a_stands_client_run_again). A kick and the end of a session that a full channel does not accept are named in the host's journal (a_kick_a_full_link_will_not_carry_is_said_in_the_journal, the_end_of_a_session_a_full_link_will_not_carry_is_said_in_the_journal). Tests for what is described but was not checked: the world waits for a channel that is full by bytes and is not taken again every tick (a_world_waits_for_a_link_that_is_full_by_bytes_without_being_captured_again: the snapshot check counts how many are taken), exit codes 1 and 2 (a_game_the_host_refuses_exits_with_1, a_game_that_loses_its_host_exits_with_1, a_game_that_cannot_take_the_hosts_world_exits_with_1, a_host_whose_port_is_taken_exits_with_2), the kick of a waiting player (a_player_the_game_keeps_waiting_is_not_dropped_for_joining_slowly_and_a_kick_reaches_it). Each was checked by reverting the code. The test a_world_of_an_earlier_tick_that_waits_for_room_still_starts_the_inputs_over passed, before the third review, on the code without the host's fix (it looked only at the client's clock) and did not see the input: now the host has an applied frame, and after a world that waited for room, the input record (applied_input_tick, inputs.newest) is started again, and the new frame lands once on its tick. Checked with two reverts: the host computes carry the old way (it fails on the client's clock), and the host does not reset the record (it fails on the input record). The caveat "each test failed on the code without the fix" (the paragraph above) holds for the other tests of that review.

E8. Saves and settings (phase C)

№ What to do Status
1 character and world saves, slots ✅ shards_save: two kinds, slots [a-z0-9_-], --world/--character (a single-player game and the host load a slot before the first tick; a client ignores the world slot and brings its character in Hello); tests/save/launch.rs, tools.rs. Engine sections region, position, vitals (loading brings the body back to life), crates/sandbox/tests/sandbox/saves.rs. The region section (version 2) stores the region manifest: the world is built from it, without the generator, and after an update that changes the generator it stays the same; if the content that names the manifest is missing, the load is refused before any change; a manifest that does not match its hash means the copy is damaged, and loading takes the backup; scenario world_save.scenario
2 schema and migrations ✅ sections with versions and a chain of migrations; a gap in the chain breaks the build; version 1 sample files in tests/samples/; a save from a newer version is not damage: it is refused, with no copies, no .damaged files and no overwrites, and writing to such a slot is refused too (tests/save/newer.rs). The engine's first migration is region 1 → 2 (manifest: null: such a region is generated again and checked against the hash, as before; the next save writes version 2; a_save_of_version_1_is_made_again_from_its_seed_and_saved_with_its_manifest_next_time). A section of another crate under the same name takes the history too: the migrations of the replaced one go with it
3 atomic write, checksum, copies ✅ .tmp + sync_all + rename + fsync of the folder, shards-save/1 crc32 len, three copies, recovery with a journal entry, damage matrix (tests/save/damage.rs), save_damage for QA; a replay on playback does not write to disk (tests/save/playback.rs)
4 "save now", autosave ✅ save_now, autosave_on, debounce from *.save.ron, written in FixedLast, the state hash does not change; on exit, pending requests are written at once (flush_saves); reference replay tests/replays/saves.json
5 registry of saveable data ✅ SaveRegistry, tool save_registry, the save field in ai/status
6 settings on the Bevy framework ✅ crates/shards_settings: groups for graphics, audio, controls and accessibility on bevy::settings (settings.toml), add_settings_group for the game's groups, storage after the game's build (install, --settings-dir/--no-settings), writes a second later and on exit (including changes made by the game's code), tools settings/settings_set. No file is lost: a file that is not TOML becomes a .bad copy, and the last good one is kept as .bak; a failed write returns the copy and is retried; reset returns the game's defaults. Applied by: the window (apply_graphics), the camera and input (shards_motion: field of view, shake, sensitivity, MotionBlur, hold_to_toggle, rebind ⇄ ControlSettings with the same checks as settings_set, moving input.ron when the game asks), warning flicker (shards_action). Tests: shards_settings (18 in src/, 44 in tests/settings/), shards_motion/tests/motion/input.rs, camera.rs, sandbox/tests/sandbox/settings.rs, scenario settings.scenario. Not checked on a real display, apart from a screenshot under Xvfb (the window size from the settings); the volumes are applied by the audio module (shards_audio, E9.5; the ui bus is added); render_scale is the internal 3D resolution stretched to the window (shards::render_scale, E10 item 9); the window and UI at native pixels
7 saves in co-op: the character with the player, the world with the host ✅ shards::coop: Hello carries the character up to 64 KB; a larger one (up to 1 MB) follows after it in parts (slot --character, without the flag the slot is taken from --name; stand c1…cN). The host applies it in the recorded player_join (it checks what was sent; a join that fails removes the body). CharacterSave goes to the client on save_now, on autosave and on save_game for the player's body, on leaving and at the end of a session. save_game what=character on a client asks the host (S2: the host takes the body the player is playing with, at most once a second; the client writes the slot named by that request). SessionCharacters gives a returning player the newest copy the host has, and a departed player's token goes back to its owner. The client does not write or load the world; a world loaded by the host goes to the clients again. At the end of a session, the host writes the world and its character and names the slot to the clients. crates/sandbox/tests/sandbox/net_coop.rs (39), shards_save/tests/save/routing.rs (3). Default slots are slot1 (not world/character, as in the first entry of the spec)

E9. UI, audio, localization (phase D)

№ What to do Status
1 widgets ✅ crates/shards_ui: the content kind screen, widgets Panel, List, Grid, Tabs, Text, Hint, Bar, Cooldown, Compass, Allies, Compare, Button, Slider, Toggle, Choice; values from sources (add_ui_source, the engine's you.* and allies) and the player's settings (setting), button actions (close, back, open, quit, tool, the game's action add_ui_action); content checks. Tests src/ (7), tests/ui/ (16), scenarios sandbox/scenarios/ui.scenario, template/scenarios/menus.scenario. The sandbox's HUD stays its code (visuals.rs), the template's HUD is content
2 screen stack, focus ✅ UiStack, layers Hud/Menu/Modal, focus and ui_navigate as on a gamepad (rows, grids, wrapping at the edge), pausing a single-player game from the menu (pauses), keys: pause opens pause; the menu context (navigate with repeat, confirm, back) and the mouse both call ui_* from the input agent; the replay repeats them (tests/ui/controls.rs, screens.rs). The gamepad's D-pad (Binding::Buttons2D) moves through menus as well as the stick and arrows (a_gamepad_walks_the_menus_with_the_d_pad_and_the_stick)
3 themes and text scale, accessibility labels ✅ the theme content kind (colours, sizes, margins); fonts are multiplied by accessibility.text_scale; each widget has an AccessKit node (role, label, value) and InputFocus for focus: tests/ui/draw.rs (window without GPU). Not checked with a real screen reader or on a display. The theme sets the font (font); without it, the engine's font shards::ui::DEFAULT_FONT is used (Fira Sans, OFL: Latin, Greek, Cyrillic; text_that_names_no_font_draws_with_the_engines_which_has_russian, a --offscreen screenshot with the Russian menu). There is no *.theme.ron file now, neither in the sandbox nor in the template: since the font with Cyrillic became the engine's font, they draw with the engine's default theme (ThemeDef::default). The theme kind is parsed like any content, but there is no test that loads a theme from a file or changes it on the fly
4 localization ✅ crates/shards_locale: languages in the content (locale), texts in Fluent (assets/locale/<language>/*.ftl) with parameters, plural forms and a phrase inside a phrase, a fallback language, the locale.language setting and a language change on the fly (open screens are rewritten before the call returns), @id in screen texts and the labels of Choice options, the theme font, hot reload of .ftl, content checks (parse errors with a position, an @id that is missing in every language), the tools locale and text. Tests src/ (10), tests/locale/ (6), scenario sandbox/scenarios/locale.scenario, and in the template menus.scenario and tests/game/screens.rs. The first launch takes the system language (src/system.rs, sys-locale): settings on disk without a language get the first system language the game has, and it is saved; tests and --no-settings run in the game's language (tests/locale/ +4). Right-to-left writing and complex layout (bidi, ligatures) were not checked
5 audio: buses, layered music, spatial sounds ✅ crates/shards_audio: content kinds sound, music, audio (the mixer, one per game); buses music, sfx, ui, voice with the player's volume (audio.<bus> × audio.master, applied to what is playing); voices with priority and a limit (a strong sound takes the voice of a weak one, max_instances); a voice cut short by the game (stop: it fades to silence on its clock and its line goes at once; an emitter's is refused, its emitter is switched off instead); spatial sounds with falloff near→far and panning from the listener (the HUD body, camera rotation); beyond far they do not start; sounds of telegraphs (SoundCue) where the blow lands, the action effect Sound (ActionSound: from the body on the action's tick, without a window, and on a co-op client it is a host event), animation keys (only with a drawn model) and engine events (damaged, blocked, died, ui_pressed, …); music: stems of one loop, layers by conditions (npc_near, npc_engaged of the NPC module or the game's conditions), the tense layer at once, the calm one after hold, smooth fades in and out; Music in the snapshot, journal lines of the local kind (the host does not send them); the tools audio, sound_play, music_set, the MUSIC line in observe, the audio field in ai/status; content check (WAV/Ogg files, stem length, layers, events, sounds of telegraphs and Sound effects); playback through Bevy audio with the audio feature. Decisions are made on the simulation clock, the same without a window. Tests src/ (10), tests/audio/ (16), scenario sandbox/scenarios/audio.scenario, and in the template tests/game/audio.rs: the music changes layer when the fight starts (explore → tension → combat, when the hero gets close to the grunt). The sound on a real output device is not checked (CI and the check ran without a sound card); the files were synthesised by the make_sounds example
6 full-screen flashes (U2) ✅ crates/shards_ui/src/flash.rs: the content kind flash (colour, strength, fade in, hold, fade out, pulses), flash(), PlayFlash, the dev control tool flash_play; one node over the HUD and under menus, on real time; accessibility.flashes reduced (at most 0.35, pulses at most 2 a second and half as deep, eased fades) and off (none, still journaled). Tests src/flash.rs (5), tests/ui/flash.rs (5); the sandbox has reality and crack. Not looked at on a real display
7 font spans (U1) ✅ crates/shards_ui/src/markup.rs: ThemeDef::fonts (named fonts) and [font=name]…[/font] in a Text or Hint value, drawn as TextSpan runs, again in place on a change; agents and screen readers get the text without markup; content checks for names, files and span fonts in screens, a Warn once for a font the theme lacks at draw time. Tests src/markup.rs (4), tests/ui/fonts.rs (2). The engine ships no symbol font. Not looked at on a real display
8 subtitles (U4) ✅ crates/shards_audio/src/subtitles.rs: SoundDef::subtitle and speaker (text or @id, checked against every language), a line for each sound the mixer starts, shown for its length plus 0.75 s (at least 2 s) on the voice's clock, once for the same line (moved up to the newest), gone when no voice says it; the UI source subtitles[:n] (the newest lines in the language played, empty with accessibility.subtitles off), [local] subtitle: journal lines, the lines in audio. Tests src/subtitles.rs (4), tests/audio/subtitles.rs (4). The sandbox's settings screen has a Subtitles toggle; the sandbox has no spoken sounds yet, so it shows no line. Not looked at on a real display
9 compass categories (U3a) ✅ ai_core::LandmarkCategory (identity: out of the replay check and inspect, kept by snapshots and co-op clients), PoiDef::category, a level node's LandmarkCategory property; the compass keeps the 4 nearest of each category (you.heading:<n>), the theme's symbols draw a category before the name (spans allowed), screen readers and ui_read get its name; you.nearest:<category> and shards::nearest_landmark give the distance a game pulses a sound or a needle by. Tests tests/ui/compass.rs (3), a region's shrine in tests/world/regions.rs. The sandbox has no compass on its HUD. Not looked at on a real display
10 map widget (U3b) ✅ crates/shards_ui/src/map.rs: WidgetDef::Map (a picture over the world's area, width × height), places from a game source (UiValue::Map, MapPoint with MapState rumor/discovered/completed and a category), the viewer added by the widget, a rumour drawn on the edge toward the place; the theme's map_colors and symbols; marks redrawn in place; agents and screen readers read it in words (a rumour as a direction). The states live in the game's save. Tests src/map.rs (4), tests/ui/map.rs (4). The sandbox has no map. Not looked at on a real display
11 placed sounds: looped emitters and occlusion (F10, the FPS spec) � crates/shards_audio/src/emitter.rs and occlusion.rs: SoundDef::looped (a looped sound plays only from a SoundEmitter; a mixer event, a telegraph or a Sound effect that names one, and a looped sound with a subtitle or max_instances, are content errors; play refuses it at run time), the component SoundEmitter { sound, playing } (reflected, so a level node, a prefab or code places it; replay_ignore; emitter_play, emitter_stop, the tools of the same names) that the mixer holds a voice for while the listener is within far and lets go beyond it, under the normal priority rules (a one-shot of a lower priority never takes a loop's voice), asking again at every refresh and starting nothing when nothing changed; occlusion, opt-in with the mixer's occlusion: Some((gain: 0.3)): a WORLD ray from the listener to each spatial voice through PhysicsWorld, every collider on the way letting through its SoundTransmission or the mixer's gain, multiplied, the ears' own floor, the source's collider, bodies and sensors left out; audio lists the emitters and each voice's occlusion (gain 0.10 prio 40 (loop) (occluded: Wall e15 �0.30)); the content check reads emitters in prefabs and level files. Local only: nothing in the replay hash or snapshots, local journal lines. Tests tests/audio/ambient.rs (16), tests/sandbox/ambient.rs (2), the scenario ambient_audio.scenario; the reference replays verify unchanged. Not done: a per-voice low-pass (Bevy 0.20's sinks have none; the gap is in the manual), the listener at the eye (F1b), playback on a real output device (not checked)

E10. Rendering, performance, platform (phase E)

№ What to do Status
1 stylised materials ✅ crates/shards_look (E10.1): the content kind look (*.look.ron): color (without it the mesh keeps its own colour), shading (Toon(bands) from 2 to 8 bands, Matte, Unlit, Lit), flat (flat faces), outline (width in pixels, more than 0 and at most 16), glow, materials (glTF materials). The Look component on an entity or an ancestor (prefab: "Look": ("stone")); otherwise the look comes from the glTF material name; a mesh without a look keeps the game's material. Light: the sun with banded shadows, the rest of the light evenly, nothing shines, exposure does not touch glow (ExtendedMaterial<StandardMaterial, Toon>, WESL shader). The outline is an inside-out shell: its width is in screen pixels, normals are averaged over the mesh's points, a mesh with skin uses the same SkinnedMesh, and it casts no shadow. Hot reload recolours the meshes in the same frame. Picture only: feature render, a window or --offscreen; without a picture nothing is styled; a Look in a prefab is an ordinary component (replay, snapshot, co-op clients), and a game Look that only the picture needs goes on child meshes. Low-poly presets are set with extends (a look starts from another one: low_poly — flat faces and an outline). For the AI: looks, look_outlines, the looks field in ai/status, Look in inspect, two developer menu items (world). Content check: colour, bands, Lit, outline width, a material of one look, a prefab with a Look for a look that does not exist. The sandbox and the template are drawn with one white material and looks (look/sandbox.look.ron, looks.look.ron); live on the GPU with --offscreen: bands, flat faces and outlines in the picture, looks: 11 looks · 49 meshes styled (36 outlined) · 2 without a look. Tests: shards_look — 12 in src/, 23 in tests/look/ and 1 under #[ignore] (a picture on the GPU: outline 3 px on all sides, on the sphere in bands the three most common shades — 97 % of pixels against 9 % for a sphere in Bevy's light); sandbox — a body with a look at the co-op client, scenario looks.scenario. Not done: only StandardMaterial; the outline only along the silhouette, one width per look (does not depend on distance); Look::new in code with an unknown id is not checked; in a window on a display it was not checked by eye (only --offscreen)
2 foliage and instancing ✅ crates/shards_scatter (E10.2): the content kind scatter (*.scatter.ron): tiles by id and #tag, regions, density, spacing, scale, tilt, max_slope, the height band, clearance, kinds, shadows, from 1 to 4 levels of detail with fade; primitive meshes (Blades — a tuft of grass, Cone, Rock, Box) or glTF. Placement is a pure function (the region's seed, cell, id) through DetRng and the static world: the ground is found with a ray over the static colliders around the tile (PhysicsWorld::subset; moving ones do not count; nothing grows inside walls or on columns), clearance is a sphere on the ground along its normal (a slope does not take away the place); graphics.foliage keeps the start of the same list; no more than 10 000 mesh entities of the definition per tile (a content error and a warning in the journal). A foliage kind with an outline, a spacing below 0.01 m and a definition that is too dense are content errors; editing a tile's or room's tags scatters again. An instance and a level are an entity with a shared mesh, the kind's material and a VisibilityRange under the tile's root: Bevy builds the batches itself (in the reference scene, 1364 drawn meshes from 48 different ones; with the E10.3 effects, 1382 from 50, item 4); past the last level it draws nothing, and it culls outside the camera; Toon dissolves the levels. The tools scatter and scatter_set, the scatter field in ai/status, mesh_assets in counts and in the perf budgets, two developer menu items. The sandbox is region/wilds.scatter.ron (7182 instances, 13864 entities on 64 tiles), the template is region/valley.scatter.ron. Tests: unit tests (14; PhysicsWorld::subset — in shards_motion), crates/shards_scatter/tests/scatter/ (11: a slope and a wall, a moving collider, a tile tag, a region change, a definition that is too dense, and others; and one #[ignore] on the GPU: the grass is green in pixels, a switched-off one and one past the last level are not drawn), scenario scatter.scenario. Release --perf reference --offscreen run with foliage on an RTX 5080: 379 frames per second at 1080p, worst frame 4.2 ms, all 8 budgets. Not checked: the "average PC" from the spec, a glTF mesh on a real file, the window on a display
3 effects and decals ✅ crates/shards_fx (E10.3): the content kind effect (*.effect.ron) — count, rate and duration, lifetime, speed, spread, aim (Up, Hit) and lift, gravity, drag, size and size_end, color and color_end, shape (Quad, Cube, Shard, Disc), size_ease and swell, glow, unlit and intensity (light past white, for a camera with the camera content's bloom: HDR), offset, radius, spin, push, strength (count_per, speed, size), max_live; the fx content kind (*.fx.ron, one per game) — an effect for an engine event (damaged, blocked, parried, evaded, guard_broken, staggered, died, healed, telegraph) and for a clip label; PlayEffect (.strength, .push) and shards::fx::play / play_with (PlayOptions { toward, strength, push }) for the game's own. Particles are our own (bevy_hanabi has no version for Bevy 0.20), on the CPU, with pools: max_live meshes per effect are made at content load and hidden; an overflow takes the slot of the oldest one; one mesh and one material per effect (colour in MeshTag) — they are drawn in batches; flight is solved by a formula on the simulation clock (pause freezes it, step moves it). A hit plays the effect on the side of the body that faces the attacker. Telegraph decals: ForwardDecal with the zone's material in WESL (circle, sector, rectangle, "stadium"); the fill grows towards the hit; enemy and ally colours are as for gizmos; the gizmos still draw the outline and the symbol (TelegraphStyle::decals); DepthPrepass for AiCamera cameras while decals are on; telegraph_decals on=false returns the gizmos. Picture only: without a window or --offscreen nothing plays; the entities have no AiId. For the AI: effects, effect_play, telegraph_decals, the fx field in ai/status, developer menu items effects (world) and telegraph_decals (combat). Content check: ranges, colours, a pool smaller than a burst, an event with a typo, a second table, references to effects. The sandbox: fx/sandbox.effect.ron (hit and block sparks, a parry flash, death dust, a healing glow) and a table, scenario effects.scenario; the template: three effects and a table. Live on the GPU with --offscreen (RTX 5080): decals under the attacks of the guard and the skeletons, sparks, dust and glow in the screenshots; the automatic test --perf reference --offscreen with foliage and effects — 327 frames per second, all 8 budgets (item 4). Tests: shards_fx — 18 in src/, 19 in tests/fx/ (including a faulty effect plays within the check's limits, and the decal's bands are measured from the zone) and 2 under #[ignore] (pictures on the GPU: a decal paints the floor only inside the zone's circle, without decals there are no warm pixels, particles glow at the launch point, a disc lies level; an effect six times past white blooms under an HDR camera and a plain one does not); shards_action — gizmos have no hatching and no fill when decals are on. Not done: particles on the CPU (not tens of thousands), without textures, trails, collisions or light; decals only for telegraphs; the sandbox's and the template's reference replays are re-recorded (content hash; at the top of the branch chain, on Windows and on Linux); in a window on a display it was not checked by eye (only --offscreen)
4 budgets and the performance test ✅ tick time (task 11): the ticks: line of step, a [perf] entry in the journal, perf in ai/status, --tick-budget-ms (ai_core::perf, crates/sandbox/tests/perf.rs), the Tracy profiler (feature trace_tracy in shards, sandbox and the template). Frame time (shards::frames, E4 phases): a frame is the main world (First … Last) and the render world for it; the slower of the two counts; without waiting for the display; frames run by step while paused do not count; frames in ai/status over 600 frames (average, worst, how many over the budget --frame-budget-ms, fps, the main world and render, GPU time and triangles from Bevy's render diagnostics). Counters in counts: entities, meshes, meshes that at least one look draws, and camera meshes. The automatic test --perf ID runs on the perf content (shards::bench): a region with a seed, preparation lines, warm-up, measurement (without a window the ticks run as fast as possible; with --offscreen, real time and frames), a line per budget, codes 0/1/2; a debug build does not judge; the sandbox's reference scene reference (the wilds, 8×8 with seed 42, their foliage and effects, 15 enemies, 1080p): release build on RTX 5080 — 327.2 frames per second, 2.84 ms per frame on average, worst 4.47 ms, all 8 budgets; 15 836 entities and 14 641 meshes — this includes the foliage (about 13 900 entity-meshes) and 400 hidden meshes of effect pools that are not drawn; 1382 meshes from 50 different ones are drawn (a repeat with 1–2 rustc processes of other branches running — 313.6 frames per second, all 8 budgets; without effects — 378.9 frames per second, 2.44 ms; before the foliage — 389 frames per second, 2.33 ms, 7 budgets); WARP — 0.9 frames per second, code 1. Draw commands (draws, shards::draws): the render world counts over Bevy's render-phase batches, after batching (binned phases — one multi-draw set, one batch, one entity that does not fit into a batch; sorted phases — the item where a batch starts; cameras and shadow maps summed; a multi-draw counts as one), draws and draws_max in frames and the draws budget of perf; in the reference scene, 75 draws for 1395 drawn meshes (the draws budget in reference.perf.ron is 150, added in S1 together with re-recording the reference replays: perf definitions are part of the content hash that they check, and a field that was not set does not appear in the definition's JSON; the measurement on 17 October — 76 draws, 327.8 frames per second, all 9 budgets); in the sandbox arena 57, and at render_scale 0.5, 62 (the draws of the camera that shows the picture); with them the release build — 313.7 frames per second, 2.97 ms per frame, all 8 budgets; the build before and after the fix, run in turn on a quiet machine: 331/332/315 against 330/327/319 frames per second. Tests: frames (+2: the commands travel with their frame; there are no commands where the batches are closed), bench (+2: the verdict and the draws line; a budget that is not named does not change the definition's JSON), under #[ignore] in the sandbox draws_follow_how_bevy_batches_not_how_many_meshes_are_drawn (GPU: forty cubes with forty materials of one pipeline — no extra commands; four pipelines — more, but not one command per mesh). Earlier tests: frames (4), bench (3), run (perf_plays_a_definition_and_names_what_stops_it), tests/engine.rs (the_status_counts_what_there_is_and_headless_has_no_frames), sandbox/tests/perf.rs (the reference scene without a window; with offscreen — #[ignore], needs a GPU). The full-size scene reference96 (S1): the sandbox's expanse region — 8×8 tiles of 96 m each, as in the spec (E5), built from four of its own tiles (tile_size: Some(96.0): a gate, a meadow with boulders, a grove of columns, a courtyard in walls; about 1900 colliders), three camps, its own foliage (twenty times sparser than the thickets: it is scattered over the whole region on load), 15 enemies, 1080p; budgets for tick, frame, region loading (3 s; the spec allows 10–15), baking the navigation of its tiles (nav_bake_s — a new kind of budget: shards_npc::bake_region bakes the region's tiles for all body classes, like --bake-nav, without writing files; it is measured after loading and only if it is named), entities, meshes, triangles, draws. Release build on RTX 5080, four runs: 351–354 frames per second, 2.61 ms per frame on average, worst 8.7–9.0 ms, tick 0.63 ms (worst 7.2–7.6), loading 0.61 s, baking 4 tiles × 2 classes 0.80 s, 116 159 triangles, 62 draws, 34 976 entities, 1985 drawn meshes from 13 different ones, all 11 budgets; without --offscreen the tick is 0.46–0.52 ms. With physics without a broad phase (brute force, added only for the measurement): loading 3.9 s, tick 0.93 ms without the picture and 1.13 ms (worst 11.9) with it, 317 frames per second. Tests: bench (the verdict for nav_bake_s and - when nothing was baked; JSON without an unnamed budget; errors in the definition), shards_world (tile_size: a tile for other cells does not enter "all tiles", and an error where it was named), sandbox/tests/perf.rs (reference96 without a window: loading, 8 bakes, 15 enemies, 12 in combat, more than 1800 colliders). Not done: the "target PC" is not chosen — checked on RTX 5080 and WARP; the draw commands are what Bevy's phases hand to the pass (a multi-draw is one command), not calls inside the GPU, and without GPU preprocessing (WebGL) there is no number; full-screen passes (upscale, tonemapping, bloom) are not counted; there is no CI job with the automatic test. The sandbox scenario budgets: budgets are perf content; the scenario reads the definitions by the named budgets and checks that a definition that cannot run is rejected with a reason (region, setting line, zero ticks, budget not above 0, share outside 0…1, loading budget without a region, a typo in a budget name), and does not read the time. The ticks: line of step and the perf field of status are not checked by the scenario: the live game prints the line, and the test game in the process (report_perf: false) does not, so an expectation that is right in both runs cannot be written, and status is not a tool; crates/sandbox/tests/perf.rs covers them
5 Steam 🟡 crates/shards_steam (E10.5), behind the steam feature of the umbrella crate (off by default; steam_sdk — the real client: steamworks = "=0.13.1", steam_api64.dll). Sessions over the relay: --steam-host (a lobby for max_players, "friends only" by default, --steam-lobby friends|private|invisible|public, data game/engine/content/rules/host, steam_invite), --steam-server (an anonymous Steam game server on 127.0.0.1:27215, no lobby; clients join it by its id; the host with its own player 0), --join steam:<id> (a lobby is type 8, a player or a server is types 1, 3, 4; steam: waits for an invitation), +connect_lobby <id> → --join steam:<id>, --steam-relay-only (ICE off), --steam-app N (SteamAppId/SteamGameId, without steam_appid.txt). The transport SteamTransport runs on ISteamNetworkingMessages (channel 0, unreliable without Nagle; a dropped session is restarted); on top of it, conditioner_from (--net-sim); shards_net does not open UDP (ExternalTransport). Sessions are accepted only from the lobby (host), from anyone (server), and from its own host (client). Achievements are content, achievement (AchievementDef: API name, name and description as Fluent messages, hidden), UnlockAchievement (a network event: the host decides, and each machine unlocks it for its own player) and unlock_achievement; not during a replay, and not on a client by itself; written to Steam a second later and on exit; a local journal entry; not simulation state. Cloud: a copy of each slot write (SaveWritten); on launch, before the slot loads, the two are compared: a newer cloud copy is taken, a newer disk copy goes up, and on a tie both are kept (slot -cloud); a damaged one is not taken; a copy of a newer version is neither taken nor overwritten; the disk write is write_guarded; during a replay there is no cloud; the write is one FileWrite, and a quota error states the free space. --stand N --stand-steam [--steam-lobby TYPE] — a stand in one process, whose members meet through a fake Steam (the host makes a lobby, the clients wait for it: steam_lobbies, steam_join); Stand::settle and loading_locally do not wait for a client that needs another transport (waits_for_transport), and SteamSession::from_launch takes the lobby's owner from NetLaunch::Stand too; the scenario crates/shards_steam/scenarios/lobby_search.scenario (an invisible lobby, a search, joining by the id from the answer, 300 game ticks, 0 desyncs) runs in a test and against a live stand. Callbacks with risky parsing are read as raw numbers; a callback that fails stops the callbacks with one error; the Steam client starts before rendering; on exit: copies, achievements, closing sessions, leaving the lobby. Tools steam (the route to a peer: state, relay, POP, ping from GetSessionConnectionInfo), steam_lobbies (search for this game's lobbies and build: RequestLobbyList with equality filters on the lobby data, on the slots and on the distance "worldwide"; Steam finds only public and invisible lobbies, and the host's answer explains why its lobby is not in the result; it waits for the callback, pumping the callbacks itself), steam_host, steam_join, steam_invite, achievement_unlock; the steam field in ai/status; the steam section of the developer menu. shards package puts only the Steamworks SDK library next to the program, accepts it in the import check, and removes steam_appid.txt. Tests: shards_steam — 31 in src/, 38 in tests/steam/ (all on FakeSteam); shards — run (Steam flags, lobby type and the ready line, a stand on top of the fake Steam), plugins (the Steam client before rendering), tests/engine.rs with steam; shards_save — SaveWritten; shards_cli — only the SDK library next to the program. On real Steam (480, one account, 2026-10-16): the game server and a player by id only through the relay (relayed via <pop>, 16–17 ms, 0 desyncs); the achievement from the host was recorded by the client on the account; a cloud copy that is not a save was not taken; the cloud quota for app 480 — 4 KB. On real Steam again, with a build that has the fixes made after this check: the host's lobby --steam-lobby private (private: invite only); the cloud quota message (Steam Cloud has 105 B free of 4 KB; this save is 292 B); the achievement from the lobby's host; and the server with a player through the relay again (18 ms, 0 desyncs). Lobby search there too, from a second game of the same account: the host's invisible lobby is found (1 of 3 · build matches, with all=true too; the host's answer marks it this game's lobby); the friends lobby is not (the host's answer shows a note:); the lobby size comes back as a number; joining the lobby from a second game on the same account is refused with the message this Steam account owns the lobby: … (on real Steam, the earlier its owner left message was seen). Not done: joining a lobby from a second account, +connect_lobby, the overlay and a successful cloud write on real Steam are not checked (in the tests, the src/real.rs backend only builds and passes clippy); the public lobby search and a search from a second machine are not checked; the acceptance check "two players via Steam relay" on two machines is done with real people (docs/manual.md, "Steam (E10.5)", manual check); there is no server list, voice, statistics or rich presence; a session can only be changed by restarting
6 Windows build 🟡 shards package (shards_cli::package): the dist profile (in the template lto = "thin"), the game's dist feature (without remote and hot_reload; shards/dist turns off the developer keys), the C runtime is linked in statically (+crt-static), the program icon from assets/icon.png (the .res resource is written by shards itself), on Linux RUNPATH=$ORIGIN (cargo rustc -- -Clink-arg=…: for the program only, without RUSTFLAGS) so that libsteam_api.so is found next to it (under WSL1 on a small program with steamworks: readelf -d of the package shows RUNPATH [$ORIGIN], and ldd finds the library next to it; the whole game with steam_sdk did not build on Linux), the folder dist/<name>-<version>-<OS>-<arch>/; checks: the PE imports are system ones only; --check-content and --smoke run on a copy in a temporary folder with a bare environment; nothing is written or deleted in the game's folder. The window icon (shards::window_icon); windows_subsystem = "windows" in the template with dist, and output goes to the terminal that launched it; quit and shards quit instead of signals; closing the console counts as SIGHUP; --stand-udp clients in their own process group (CTRL_BREAK); paths without the \\?\ prefix (ai_core::paths). Tests: shards_cli (package: 8; a link in assets/ — on unix only; a_game_is_asked_to_quit), shards_core (quit_answers_then_ends_the_game_through_its_exit_hooks), shards (window_icon), ai_core::paths (a name with an unpaired surrogate — on Windows only); live — shards package of the template, shards quit, stand stop of a stand in the process and over UDP. Determinism between Windows and Linux on x86_64 (and the Steam Deck) is done in the code: sin, cos, atan2, exp, powf and the rest go through libm in Bevy, glam, simba and the engine's code (in [workspace.dependencies]: the libm feature of Bevy, indexmap for parry3d, and a direct dependency glamx =0.3.1 with libm for simba/libm_force — all from enhanced-determinism, except scalar-math; the calls are bevy::math::ops); glam keeps SIMD (SSE2 — the same instructions on any x86_64 OS); clippy.toml (the root and template/, disallowed-methods) bans the f32 methods from std, so they cannot come back; the test ai_core::determinism keeps the results of ops bit for bit. Between architectures (x86_64 ↔ ARM, Apple Silicon) it is not promised: the full enhanced-determinism would give it through glam without SIMD (scalar-math), but with it Vec4 and Mat4 lose their 16-byte alignment, Bevy 0.20's MeshUniform becomes 168 bytes against 176 in the shader, and rendering stops (the GPU test of shards_fx failed on this); shards does not build such a configuration (a const with align_of in crates/shards/src/lib.rs; checked: with enhanced-determinism the engine and the template do not compile). Checked by running the replays across the two OSes: nine reference replays (seven from the sandbox and two from the template) were recorded on Windows 11 (x86_64-pc-windows-msvc) and on Ubuntu 24.04 (glibc 2.39) under WSL1 (x86_64-unknown-linux-gnu), with Rust 1.99.0 on both sides; the files matched byte for byte, and each OS passed --verify on the other's recordings (every_reference_replay_verifies_headless, reference_replays_still_match); both sides were checked at e635768; the Linux recording was made at 5d1dbfe (the simulation code is the same). WSL1 runs real ELF binaries on the same machine; there is no virtual machine; the processor is the same on both sides: the OS, the C library and the build were checked, not different x86_64 processors. The reference replays were re-recorded. Not done: a run on a real clean Windows (a VM); other x86_64 processors, macOS, ARM and Steam Deck hardware are not checked
7 crash handler that writes the report to one file ✅ ai_core::crash (E2 phases): a report shards-crash/1 in crashes/crash-<time>-tick<N>.json (or in the player's folder, if writing to the working folder is not allowed) — the panic (message, place, thread, stack), the game (EngineConfig::version), the machine (OS, processor, memory, graphics card), ai/status, the journal, the log and the session's replay; --replay accepts the report. It is written on a failure of a gameplay system (together with the crash replay), on a panic in another thread that nobody caught (a panic caught by code — crash::handled — is shown by the next report), on a panic that takes the game down (shards::run, code 101, no replay), and by the tool crash_report (a developer menu item; with path inside crashes/ it goes to that file, which is replaced, as with snapshot_save). The game itself writes it with crash_replays (on by default); the tests, --verify, --smoke, --check-content, --worldgen-report and --bake-nav turn it off. A report that crash_report asks for is written even without it. The panic handler is set by shards::run. Tests: ai_core::crash (6: among them path — the file is written there, a second call replaces it, and a path outside crashes/ is refused with an example), the sandbox scenario crash_report (writes crashes/scenario.json, path refusals), system_failures.rs (the report of a gameplay failure and its replay, a panic in another thread and the tool's answer, crash_report), shards::run (a_panic_that_takes_the_game_with_it_leaves_a_crash_report); live — crash_report of the sandbox without a window. It catches only panics: access violations, driver errors and abort pass it by; in the dist build the stack has no function names (there is no .pdb); there is no window with a message for the player. The scenario writes the report with path=crashes/scenario.json and replaces it on each call, so it leaves one file (in the sandbox test crates/sandbox/crashes/scenario.json, in a live game under CI the root crashes/ folder; the folder is in .gitignore); a report without path gets a new name each time, and the scenario cannot delete files, so it is checked only by the Rust tests system_failures.rs, which clean up after themselves
8 screenshots without a window ✅ --offscreen (EngineConfig::offscreen, E3 phases): the window's plugins without a window; cameras aimed at the main window draw into an image of the size window (ai_core::display::Offscreen, shards::offscreen); the UI goes to the last camera, and the HUD and overlays by the condition ai_core::display::drawn; shot takes the picture; each frame waits for the GPU (without this, software rendering ran out of memory), no longer than 30 s: a stuck GPU ends the game with code 1; display in ai/status; without a GPU — code 2 with advice. Checked on Windows 11: RTX 5080 (Vulkan) and WARP (WGPU_FORCE_FALLBACK_ADAPTER=1) give one picture. Tests: offscreen_is_the_window_plugins_without_a_window, a_headless_game_has_no_picture_and_says_how_to_get_one (shards), offscreen_is_a_way_to_play_not_to_check (run), a_stuck_gpu_ends_the_game, every_camera_aimed_at_the_window_draws_into_the_image (offscreen), an_offscreen_game_takes_shots_without_a_window (sandbox, #[ignore]: needs a GPU). Not done: Mesa lavapipe on Linux was not checked; there is no CI job with screenshots. The sandbox scenario display checks only the refusal, without a GPU: shot in a game without a window and without --offscreen answers nothing to capture: this game runs headless and names cargo sandbox --offscreen; the picture itself is a test under #[ignore]
9 internal 3D resolution (graphics.render_scale, from E8.6) ✅ shards::render_scale (feature render, a window and --offscreen): the 3D world is drawn into an image of render_scale × the window's pixels (0.5…2, the side no more than 8192) and stretched over the whole window with a linear filter; the UI, HUD, menus and developer console are at native pixels. Every Camera3d aimed at the window (or at the --offscreen image) is re-aimed at the image (ai_core::display::SceneImage); one Camera2d without RenderLayers (it sees no meshes, and counts are the same as at 1.0) shows the image over them with an ImageNode under all the screens and carries the UI; at 1.0 nothing is added (the cameras draw into the window, with no extra pass); going back to 1.0 returns the target and removes the display. The camera target's scale is render_scale × the window's scale, so the camera's logical size stays the same (world_to_viewport; the HUD's threat markers and the UI nodes did not change); the shot legend is computed as the picture's size / the camera's logical size, and the eN labels are on the same pixels as at 1.0 (to the pixel). The image was chosen over Bevy's MainPassResolutionOverride, which narrows the viewport inside a full-size texture and waits for an upscaler, DLSS. settings_set group=graphics key=render_scale takes effect in a running game; display.scene in ai/status; shards_settings::apply_graphics no longer sets scale_factor_override. Tests: shards::render_scale — 10 in src/ (the image size, the texture limit, the window and the system's scale, going back to 1.0, the game's camera with someone else's image, no 3D cameras), ai_core::shot — labels in the picture's pixels (1), shards_settings — the window is not touched by the scale; under #[ignore] in the sandbox render_scale_draws_the_world_at_a_fraction_of_the_picture_and_shows_it_over_all_of_it (GPU: a 640x360 image with a 1280x720 window; the picture is whole and close to the one at 1.0, e5 within a pixel, settings_set there and back). Live on the GPU with --offscreen (RTX 5080): shards shot at 0.5. Not done: the looks outlines and gizmos are drawn in pixels of the 3D picture (at 0.5 they are twice as thick on screen), and this is not compensated; in a window on a display it was not checked by eye; a game camera with an order below the displaying camera is covered by the picture. The sandbox scenario display (without a GPU): render_scale is read, changed and written to the journal like any setting; a value outside 0.5…2, or one that is not a number, is refused with the allowed range and moves nothing; the settings screen's slider (0.5…2, step 0.25) is tied to it; at the end the scale is 1; the 3D image and display.scene in status are not available to the scenario (without a picture they do not exist, and status is not a tool)
10 gore: marks on any surface and debris that lasts (F9, the FPS spec) ✅ crates/shards_fx/src/{mark.rs,gore.rs,marks_render.rs,debris.rs}: the content kind mark (*.mark.ron, SIMULATION = false: texture, color, size, rotate, fade_in, fade_out, lifetime: Secs | UntilCleared, max_live, depth, roughness, unlit, tags, each checked: sizes above 0 and min at most max, fades 0 or more, caps 1 to 4096, a picture path inside the assets folder that exists) laid as a ForwardDecal with Bevy's StandardMaterial (lit), its quad turned so its +Y is the surface's normal, so it lies on any wall, ceiling or floor (the telegraph decals' projector, its own material); a pool per kind that recycles the oldest laid; spawn_mark / spawn_mark_seeded / PlayMark for the game, and fx's marks links (MarkLink { mark, place: At | Behind(m) | Below(m), count, spread, offset }) from shot_impact (a hole), shot_hit (blood on the wall behind a body, a ray along the shot from the shooter's ShotFired), damaged, died and part_broken; the events shot_impact, shot_hit and part_broken join the table's effects, with Aim::Surface and Aim::Away; debris: EffectDef gains collide, restitution, friction, rest: Fade | UntilCleared, mesh (a glTF per particle, no UVs needed), image (a textured quad) and tags, all left out of the written form at their defaults; a landing particle is stepped (1/60 s on the simulation's clock, a ray a step through PhysicsWorld::raycast on WORLD, a budget of 2048 rays a frame that the next frame catches up from), bounces, slides, follows the ground down a step and comes to rest lying on it, and UntilCleared keeps it past the 30 s cap; clear(world, tag), clear_all, the tool fx_clear, and a clear on WorldRebuilt (a region change, regen, a snapshot load) and on leaving InGame; the tools mark_spawn and fx_clear, effects listing the marks alive per kind and the debris at rest, ai/status fx: {marks, debris, rays} (the gore's performance counters); the picture only: no AiId, nothing in a replay or a snapshot, nothing headless, a game that draws and one that does not play the same game (the state hash is the same). Tests: debris.rs 7 (bounces, tunnelling, friction, walls and ceilings, an edge, late frames, the shown pose), mark.rs 5, marks_render.rs 2, tests/fx/gore.rs 12 (a mark on a floor, a wall and a ceiling, the cap at ten times the budget, fades, a shot's impact and body hit, a blow and a death, chunks that stay, clearing, PlayMark, a machine that draws nothing, a count held to the limit), content.rs +1, offscreen_gore.rs 2 (#[ignore]: the pixels of marks on three surfaces and kept off a pillar, chunks of a mesh with no UVs on the floor), tests/sandbox/gore.rs 3; the scenario gore.scenario; the sandbox's content/fx/gore.{mark,effect,prefab}.ron, textures/marks/*.png and models/chunk.glb (cargo run -p sandbox --example make_gore); the picture docs/media/gore-room.png. Not in F9: marks on bodies (a decal that sticks to a character) and on moving surfaces, PartBroken forwarded to a co-op client

E11. Developer tools and the AI layer

№ What to do Status Where and how it was checked
1 developer menu and console through call_tool ✅ crates/shards_dev (D4): the menu (F10; dev_menu) has the module entries (add_dev_entry: time, world, combat, AI, network, saves) and the game's entries (content kind devmenu). Toggles show the label for the other state. Entries with a missing argument are completed in the console. An entry that does nothing says why. The console (`; console) takes a line tool key=value … and runs it through call_tool as the agent console (scope Dev), with history, Tab completion from the tool schemas, and the input context dev while typing. Tests in crates/shards_dev/tests/dev/ (6, among them the overlay keys with the panel open) and unit tests (2), ai_core::dev (2), the scenario dev_menu; the window was checked by eye (console open=true, dev_menu open=true, shards shot; the keys F10, `, arrows, Enter, Tab, Escape — with real key presses)
2 overlays: hitboxes, hurtboxes, attack zones; navmesh; NPC state; network; tile borders ✅ combat_overlay, physics_overlay, overlay (id) — ✅ (shards_action::render, shards_motion::overlay); the navmesh and NPC routes — nav_overlay (shards_npc::nav::overlay); tile borders, sockets, points and roads — world_overlay (shards_world::overlay): ✅ — what they hand out as gizmos is in the resources NavDraw and TileDraw, and the tests read it without a GPU or a window, as CombatDraw does (shards_npc/tests/npc/overlay.rs 6, shards_world/tests/world/overlay.rs 7); the picture was checked by eye (shards shot under Xvfb). NPC state — npc_overlay (shards_npc::overlay, F7; D4): a text line on each NPC near the players, and gizmos in the window (the line above the NPC, a line to the target, the view cone, where it lost the target, noise, the leash), test npc_overlay_answers_a_line_per_npc_near_the_players, scenario npc_navmesh; network — net_overlay (C)
3 tools: invulnerability, teleport to a tile or a point, boss phase, prefab spawn, slowdown ✅ god, teleport (to a point), goto_tile (to a tile; test goto_tile_lands_on_the_ground_of_a_tile), spawn_prefab, spawn_level, speed; switching to the boss phase through a snapshot (snapshot_load, test go_to_boss_phase_two_is_a_snapshot_loaded_by_name, scenario snapshot)
4 snapshots at any tick ✅ ai_core::snapshot: snapshot_save/snapshot_load, shards save-snapshot/load-snapshot, a replay shards-replay/3 from a snapshot; the region, its level-tiles and the navmesh come back with the snapshot (add_snapshot_prepare, RegionBuild, add_snapshot_rebuild("navmesh")). A load that was refused after the preparation puts the world back as it was, along with the level numbers (LevelCounter), which are snapshot state. Content edits made before the snapshot (ContentEdits) and levels placed by id (PlacedLevels) are included too: a load puts the edits over the game's files, and places the levels under their numbers and the collider ids around the region (add_snapshot_prepare_after). A level file that the game has not loaded yet is requested, and the load asks to be retried a little later. A replay requests the files that its start edits and its content_apply will add, as soon as it is armed (add_playback_hook), and the loading gate waits for them: content_apply and regen or spawn_level in one tick are played back the same way. tests/sandbox/snapshots.rs (33), ai_core::snapshot (23), shards::run (2), shards_npc/tests/npc/snapshot.rs (4), the region and level tests of shards_world (tests/world/levels.rs: files ahead of the replay, a snapshot with an edit that added a tile, levels by id in a fresh game, in a replay and on refusal). Not included: a level that the game places by itself, not by id (spawn_level_file), and what a content edit rebuilt outside entities with AiId (the sandbox's layout walls): such a load is stopped by the static_colliders check. On a co-op client, the edits and the levels by id are its own (net_ignore_resource), and so are the level numbers
5 clearance, path_to, line of sight by physics rays ✅ for physics — src/perception/, physics_line_of_sight; tests/motion/perception.rs. For the navmesh (D4) — path_to through RoutePlanner (the field provider: navmesh in a region, local grid outside it), clearance with closed, where the navmesh ends before physics does (reach), nav_path (plus the tiles of the route) and move_to path=true; tests navmesh.rs (stitching_turns_tiles_with_them_and_follows_open_sockets — E closed 4.0m, a_diagonal_reach_stops_where_a_side_column_is_switched_off — a diagonal past a cut-out column, move_to_path_follows_the_navmesh_beyond_the_local_planners_reach — provider and max), scenario npc_navmesh
6 connect the AI layer to the modules ✅ the modules of phases A and B — ✅ (the generator: regen, region_load, goto_tile, worldgen_report; levels and NPCs — tools and lines in observe). The save tools (C) — ✅ (save_game, load_game, save_check, save_list, save_registry, save_damage: crates/shards_save/src/tools.rs, tests tests/save/tools.rs). The host-and-clients stand (C) — ✅: --stand N (the host and the clients in one process, each with its own BRP port and port file, shared time: step on any of them drives all of them, pause/resume/speed are visible in ai/status; the stand ends with the host, and on exit it delivers the end of the session; the player's settings belong to the host, --settings-dir/--no-settings), an agent bound to a player, the net_* tools; tests net_lifecycle.rs, shards::run. For an agent: --stand N --stand-udp (the host over UDP, the clients as child processes; test stand_udp.rs with real processes), shards --peer c1 (the client's token — SHARDS_TOKEN_C1 or its file, at any path), wait --peer all (stops at once on anything that waiting does not fix), shards stand / stand stop, polling a deferred step through ai/step_poll, a client that did not join the session or crashed stops the stand over UDP (a client that left on its own, or one that the host disconnected with net_kick, does not; a farewell from a client that did not accept the world does not count), --stand N is checked against max_players before the processes start, stand scenarios (header stand, @c1; crates/sandbox/scenarios/stand/, tests scenario_files.rs; the CI step "Stand scenarios against a live stand"). The UI tree (D1) — ✅: ui_read, ui_open, ui_close, ui_navigate, ui_click, ui_set, the UI section in observe, the ui field in ai/status. The player agent — ✅: an agent with scope player, bound to a participant of the stand (session --scope player --player N, BRP ai/session), sees itself as the body of that player, whatever that body is, and acts only through its Intent, as a person would; the host runs its calls as calls of that player, and it has no developer tools. The stand scenario stand/agent_player.scenario, tests a_session_binds_an_agent_to_a_players_body (scenario_files.rs) and an_agent_bound_to_a_player_finds_its_body_after_a_respawn (shards_core)
7 scenario tests: a scenario file in CI without a window, and each module's own set ✅ for A–E shards_script, ai_core::scenario, shards scenario; the sandbox scenarios: obstacle_course (E2), combat_prototype, boss_fight, dodge, errors (E3), npc_director, npc_navmesh, npc_avoidance, npc_bodies (E6), sequence (F12), region (E5), snapshot, dev_menu (E11), saves, world_save, settings (E8), the stand scenarios stand/*.scenario (E7), ui, locale, audio (E9), the template scenarios smoke, valley, menus; the CI jobs test (in-process, forward and back) and headless-cli (against a live game, forward and back). The phase E modules: looks (E10.1), scatter (E10.2), effects (E10.3), budgets (E10.4), crash_report (E10.7) and display (E10.8, E10.9) in crates/sandbox/scenarios/ — the same two CI runs; the lobby search with a fake Steam (E10.5) — crates/shards_steam/scenarios/lobby_search.scenario, which tests/steam/scenarios.rs runs on a stand over FakeSteam in cargo test --workspace (the sandbox has no steam feature, so the file cannot be in its directory). shards package and quit have no scenario: the first is a build run by the CLI, not a game tool (--smoke and the shards_cli tests check it); the second ends the game that a scenario drives. Scenarios for future modules come as the modules appear
task 9 invariants: rules that stop the game ✅ ai_core::invariants: the engine's own rules in a separate category (add_engine_invariant, engine rule in assert_list, EngineConfig::engine_invariants, --no-engine-invariants, off with dist): ai.index_consistent, core.intent_sane, motion.finite, action.resources_in_range, action.running_sane, npc.state_known, npc.tokens_within_limit, each with a control test (tests/sandbox/engine_rules.rs, unit tests next to the rules); add_ai_invariant, assert_add/assert_list/assert_remove/assert_reset, shards assert, shards fuzz (inputs from the tool schemas, --chaos, --invalid, --alphabet, --weights; shards_script::fuzz in process, tests/sandbox/fuzz.rs; the sandbox's tool_contracts.rs calls every tool 30 times and checks panics, errors, and that the replay plays back), shards fuzz, exit code 3, the replay of the violation; the sandbox rules health_in_range and bodies_in_world; tests/sandbox/invariants.rs, tests ai_core::invariants, shards_cli (fuzz_inputs_come_from_the_seed), shards_script (an interrupted step)

| task 10 | details of a replay divergence | ✅ | Check.parts, --check-every, --check-detail; --verify names the entities and components and prints their values; tests/sandbox/replays.rs, tests ai_core::replay | | DX2 | the replay check content covers what the session read | ✅ | ai_core::scope (SimScope: open in the fixed tick, action calls, EngineState changes and the world builders; suspended for what only watches), parts checks (add_parts_check, check_parts in replays and snapshots, a divergence names kind/id), ContentDb read flags (atomics, ContentDef::SIMULATION, peek); the formats shards-replay/4 and shards-snapshot/2 (older files are read and checked whole). Tests: tests/sandbox/content_check.rs (9: also a definition added under an id looked for and not found, a press and a shown screen, other autosave numbers on the saves replay, a refused load in a session that hashes every definition), ai_core scope 2 and replay 3, shards_content db 4, shards_action status 1 (a status a hook gives an entity later in the tick), system_failures.rs (the scope after a panic), the GPU test content_reads_are_the_same_headless_and_drawn (offscreen.rs, #[ignore]: the counted sets headless and offscreen are equal; passed 18 October 2026 on Windows); every reference replay of the sandbox and the template was recorded again (only the content check values and hashes changed), verifies headless and with --heavy 30, and plays identically offscreen | | task 11 | tick time | ✅ | ai_core::perf (see E10, item 4); crates/sandbox/tests/perf.rs. Tracy: the feature trace_tracy in shards, sandbox and the template (docs/manual.md, "Tick time (E11)") | | testing spec P1.3d–e | minimisation, state coverage, the nightly fuzz campaign | ✅ | shards_script::{minimize, shrink, stop, regress} (ddmin, the same-stop rule, the scenario writer), shards::testing::fuzz_and_shrink (each attempt on a fresh game, heavy mode kept), ai_core::coverage with parts in shards_motion, shards_action, shards_npc (tools coverage, coverage_reset; --coverage), shards fuzz --steer --minimize, crates/sandbox/tests/fuzz_campaign.rs and the job fuzz of nightly.yml; scenarios/regress/ is run by scenario_files.rs. Tests: see the rows of the crates. The planted-bug demonstration (stamina below 0 after a dodge in a heavy windup) is on the branch claude/t6-stamina-demo, not merged. The first campaign runs found that the UI's journal lines were Events a heavy twin never had; they are Local now. The campaign of 19 October 2026 (issue #72) found the encounter umbrella's marker of its own NetAlways outside snapshots; its shrunk session is the first file in scenarios/regress/ (the reader now takes a call whose arguments are not an object, which it refused), and the campaign's log names what a heavy check found differs | | testing spec P1.1 | heavy mode, the state audit, save idempotence | ✅ | ai_core::heavy, shards::heavy: --heavy N --heavy-span K --heavy-offset O with --paused, --replay … --verify and --stand (the host); a failed check halts like an invariant (exit code 3, --verify 1) and saves the snapshots and the replay; testing::heavy_app, verify_heavy; snapshot::differences. tests/sandbox/heavy.rs (8: the combat prototype with --heavy 300, three planted bugs caught and fixed, the halt and assert_reset, real time refused, off is invisible), tests/sandbox/state_audit.rs (3: resources, and components on entities with an AiId in the replays and the yard's ring fight, with a planted one each), tests/sandbox/heavy_saves.rs (1), shards::run (a stand), ai_core::heavy (3), ai_core::snapshot (1), tests/log_capture.rs (2: lines of the asset threads are not compared and have their own limit). Every reference replay of the engine and the template passes --verify --heavy 30 (17 October 2026, Windows); nightly: the job heavy of nightly.yml (--heavy 10 --heavy-span 30) |

Done when Status
every item of the 32.8 GDD list is available both from the developer menu and from shards ✅ region seed (region_info), hundreds of regions (worldgen_200), reachability (region_check), the boss phase (boss_phase_2 of the sandbox), invulnerability and slowdown (god, slow), the network journal (net_overlay), the save check (save_check), hitboxes (combat_overlay), AI state (npc_overlay), lag (net_lag): test every_item_of_the_gdd_list_has_an_entry_whose_tool_exists, scenario dev_menu; from shards — the same tools and dev_menu run=<id>
all module scenarios run in CI ✅ the scenarios of the modules of phases A–D run (test, headless-cli). Phase E: looks, scatter, effects, budgets, crash_report and display in crates/sandbox/scenarios/ run in the same two jobs (scenario_files.rs: on a fresh game, one after another and back; headless-cli: against a live game, forward and back), the lobby search with a fake Steam (crates/shards_steam/scenarios/lobby_search.scenario) runs through crates/shards_steam/tests/steam/scenarios.rs in cargo test --workspace (the sandbox has no steam feature). There is no scenario for shards package (a build run by the CLI, not a game tool) or quit (it ends the game that a scenario drives); the ticks: line of step and the perf field of status are covered by the test perf.rs, not by a scenario: the test game does not print the line, and status is not a tool. crash_report writes to crashes/scenario.json and replaces the file on every run, so after cargo test one file stays in crates/sandbox/crashes/ (the folder is in .gitignore)

Port gaps

Work that is not in the E1-E11 spec: gaps found when porting a game, each done in lane-sized pull requests. The status is set from the code and the tests, as above.

№ What to do Status
G1 voxel terrain 🟡 crates/shards_voxel. A2e (navigation) ✅: the region's navmesh is baked in memory when it loads, one bake per chunk and body class on the compute pool, kept under a ChunkKey, stitched across the chunk edges (diagonals too) into the NavRegion a region of tiles has, on machines that simulate; nav_path, path_to, NPC routes and a chase work there. A2c (region kind) ✅: the voxel_region content kind behind the region API (RegionKind, Layout::Volume), the manifest's steps, the build (field, water, sea, Current), voxel.volume, the rebuild cache, hot reload, sea_current_at, voxel_info, in_water, in_current, near_grid_edge. A2b (core) ✅: VoxelVolume (chunked blocks, the chunk size a parameter, edits for generation, FNV hash), the content kind voxel_palette (*.voxel_palette.ron, validated with the file named), deterministic Noise, the registry of generation steps and checks with versions (add_voxel_step, add_voxel_check, generate), the stock steps noise_hills and fill_water, column_boxes and water_boxes against a brute-force reference; the module voxel in EnginePlugins (it may be left out); no sandbox content, so the reference replays are unchanged. Not yet: meshing (A2f), the rest of the AI layer (A2g)
G9 encounters (waves of enemies at a place, wipes, resets) 🟡 crates/shards_encounter: built and checked: the engine crate, the sandbox's yard region, the scenarios encounter and stand/encounter, and the reference replay encounter.json. Not built: the event director's caps (E67), summon auto-adoption (B4), the "or readied" start and the reward claim (G8), the generator's pack placement (M6)

Tests

Tests by crate, cargo test -p <crate>: all the rows, except the template's, are taken from one full run of cargo test --workspace on 15 October 2026 (after the merge of C7, 3b2d359, and the fixes from the sixth review round; the build of this tree: 0 failing). The rows for shards_script, shards_cli, shards_world and sandbox after C9, shards_ui and shards after D1, shards_locale after D2, shards_audio after D3, ai_core, shards_content, shards_world, shards_npc and shards_dev after D4, ai_core, shards, shards_cli, shards_core and sandbox after E1–E3 of phase E, ai_core after E10.6, shards, shards_cli, shards_save and shards_steam after E10.5, shards_save, shards and sandbox after the manifest in the save (the region section, v2), shards_save and shards after SaveSection::check (refusal before the first apply; an error from apply — the world may have changed), shards_npc after avoiding bodies (E6.2), the body classes of the navmesh (E6.1) and the fixes from their review (a run of cargo test -p shards_npc on 16 October 2026 on Windows) were recounted by the difference: tests were added and removed in these crates, and the C9 run ran on Windows, where there are fewer tests (some are for Unix only), and nine of them failed then (now none fails on Windows: the full cargo test --workspace run and the template's tests on 16 October, after the reference replays were recorded again, ran without failures; see "Known limitations"). The rows for shards_action, shards, sandbox and the template after F4 (the humanoid, clips, baking the offset, the swing sound) are taken from the full run of cargo test --workspace and the template's tests on 17 October 2026 on Windows, after the reference replays were recorded again (0 failing); the run leaves out tests that are for Unix only or need the steam feature (in shards 10 stand_udp and one plugins with steam, in sandbox 7 stand_udp and 2 shutdown), and their numbers are the same as before. The rows for shards_action and shards after the animation layers (D7) were recounted by the difference: 16 tests were added to shards_action (a run of cargo test -p shards_action --features render --lib, 127 tests) and 1 test action_render; the number of sandbox tests is the same as before. The rows for shards_motion (+4: the broad phase), shards_world (+1: tile_size) and sandbox (+1: reference96 without a window) after S1 (the broad phase of physics and the full-size scene) were recounted by the difference. The rows for shards_net (+15: cookie, knock, protocol 1, a character sent in parts), shards_content (+1: an edit waits while the content is held), shards_level (+1: nothing is placed from a file with a waiting edit) and sandbox (+9: net_guards.rs +5, net_coop.rs +4, one test replaced by two) after S2 (session protection) were recounted by the difference. The row for shards_content (+10: a definition that did not parse gets its own error, while the file's other definitions still load; the file's edit is held, and so is a definition that dropped out because its id was taken) after S4 was recounted by the difference. The rows for shards_world (+7) and shards_npc (+6) after the tests of the tile and navmesh overlays (S6) were recounted by the difference: a run of cargo test -p shards_world -p shards_npc on 17 October 2026 on Windows, 0 failing. The rows for ai_core (+2: the order of snapshot preparations, the playback hook), shards_world (+7: content edits and levels placed by id, in snapshots and replays) and sandbox (+4: snapshots.rs) after the tail of E11 (S6) were recounted by the difference and checked against the full run of cargo test --workspace on 17 October 2026 on Windows (0 failing). The rows for ai_core (+4), shards (+2) and sandbox (+14) after heavy mode (testing spec P1.1) were recounted by the difference. The template's count of #[test] and #[ignore] in template/tests/game, which runs on its own. There is no total number here or in the manual: it went out of step with the tables at every edit, and it can be checked only by a full run. Marked #[ignore]: recording the reference replays, the window check under Xvfb, network timings, the half-hour long game, the examples in the documentation; the template has 44 (and one #[ignore]: recording its reference replays). Run them from a normal shell: under nohup SIGHUP is ignored, and the test kill_and_hangup_remove_the_token_and_the_port_file fails with signal 1.

crate tests where
ai_core 132 crates/ai_core/src/* (the simulation's scope scope 2, parts checks in replay 3, state coverage coverage 5, the engine's default font display 1, snapshots 25 (of them the order of preparations 1, differences 1, an optional check both ways 1), heavy mode heavy 3, the playback hook replay 1, the pulse of the highlight ring highlight 1, the shot labels in picture pixels 1, the lines and items of the developer menu dev 2, the crash report crash 6, the bit-exact results of ops and glam on libm determinism 3; 1 more only on Windows)
shards_script 115 crates/shards_script/src/* (parsing, conditions, running scenarios 30, the long game soak 7, inputs 2, the argument generator schema 11, fuzz 18 (with --steer on a game that pays for one tool, and the half credit of the tool before), shrinking: minimize 9, shrink 7, stop 4, the scenario writer regress 7)
shards_cli 64 crates/shards_cli/src/* (the client of a peer game peer 26, scenarios 12, commands 17, the build package 9 — since E10.5 the Steamworks SDK library sits next to the program, and only it; on Linux the program has RUNPATH=$ORIGIN; 1 only on Unix)
shards_core 21 src/ (3) and tests/core.rs (18; since S3 the main menu: where it is shown, the time in it, new_game, restarting a recording — +6)
shards_content 39 src/ and tests/content.rs (what the simulation read, db 4; checks that another module adds to a content kind; an edit from disk waits while a module holds the content, ContentGuards; a broken definition is its own error, the file's other definitions are loaded, with the position as for parsing the whole file, and an edit to a file with it is refused as a whole)
shards_motion 526 (ladders +17: tests/motion/ladder.rs; F12 +11: control_lock/mod.rs 2, tests/motion/control_lock.rs 9; F13 +7: camera/grading.rs: the grade and its bad numbers, the blend on the clock and a cut, a blend that changes course, the volume the local player's body touches (the last one wins), and, with render, the cameras the grade reaches (third-person, first-person, one that appears later, the game's own grade given back), the blend moving a camera's grade with the clock, a camera with no content grade left as it is; F7 +22: controller/accel.rs 11 (the friction and the pushes against numbers worked out by hand, the friction against the original's per-frame rule, the tick-rate runs, a strafe's gain, the cap, the written form, the bad numbers) and tests/motion/air_move.rs 11; F5 +12: usable.rs 11 (the use ray: reach, glass, a button flush with its wall and one behind it, a crouched body's ray from its lower eye, a solid usable door, the nearest, a tie by collider, up and down, no collision, the middle of a use area) and params.rs 1 (use_range); F1b +35: camera/first_person/mod.rs 15, the maths and the numbers; tuning.rs 1, the mode and the first-person section; tests/motion/camera/first_person.rs 18: the look, the eye, the layers, the mode, the tool, the lock-on button's release, a first-person camera that is not the local player's or is switched off, forward before the first mouse move, a plain camera that becomes a first-person one, the crouch (F2) with the step ease; tests/motion/camera/shot.rs 1, the look input and the lock-on button during a shot; F2 +21: src/ 11 (controller/stance.rs 7: the depth against crouch_time, the air shift, a climb holds the stance, a rooted body keeps what it wanted, a body that cannot crouch stands, the floor under a jump holds a stand-up, a ceiling holds it; ai.rs 1: the stance in the body's line; params.rs 3: the written form, the height and the eye at a depth, the bad numbers) and tests/motion/crouch.rs 10; F6 +22: movers::run 7, tests/motion/movers.rs 15) src/, tests/motion/ and tests/readers.rs (K3 +3 in camera::shot (keys, eases, holds and cuts; a role turning its offset; the check), +5 in tests/motion/camera/shot.rs (render: a shot and its way back, a skip and a body that goes, the refusals, a shot shorter than its blend in, a role followed where it is drawn) and +1 in camera_content.rs (the headless refusal and the file's errors); K2 +1 in camera::math (the auto-centre step) and +3 in tests/motion/camera.rs (the view turned behind a walking body with the setting on and off, a lock framed the same, a short teleport and a stop from a run); K1 +1 in tests/motion/camera.rs: the same mouse turns the view by the free and the aiming speed; counted with cargo test -p shards_motion --features render -- --list on 20 October 2026 on Windows after R2 and R4, as the workspace builds it: src/ 113 with the 2 under #[ignore], tests/motion/ 253 with 1 under #[ignore] (226 without render: the camera tests need it), tests/readers.rs 2; R4 added the fit's maths test in camera::math 1, tests/motion/camera_big.rs 6 (a high point off the top without a fit, kept on the top margin with the player, the player kept when both cannot be, a target the frame holds framed exactly as without a fit, the view back after the lock, the feet and tilt_max holding the tilt on the very next frame) and its #[ignore] measurement, and camera_content.rs 1 (the fit read with its defaults, bad numbers refused); R2 added tests/motion/ground.rs (3: a slab laid in the middle of play, static or kinematic, landed on, walked along and climbed like a ledge, and the fall when it goes; a kinematic slab that slides away leaves the body behind); before them the table said 333; voxel fields 26 since A2a: physics/field.rs 6, physics/world.rs 5 and the timing; a ray and a sweep by a voxel region's sea read the wide list and their path's cells 1 since A2c; the snapshot hash 1, the seam differential test seams.rs 9, voxel.rs 2, the reader guard tests/readers.rs 2; controller 28, perception 29, input 30, physics 11, PhysicsWorld::subset for foliage 1, broad phase 4 — answers that match brute force over all colliders on random worlds, the grid after moves, removals and new ids, huge, long and distant colliders, part of a large world; …); 2 under #[ignore]: a timing of the broad phase against brute force (broad_phase_timing, release) and of a voxel field (field_timing, release). Since A2a (+26), counted after C1 and B1: on 18 October 2026 on Windows, 238 and 2 under #[ignore]; counted again after A2c (with C4), on 18 October 2026 on Windows: 265 and 2 under #[ignore] (src/ 61, tests/motion/ 202, tests/readers.rs 2). Since S1, counted by the difference (+4); the S3 run on 17 October 2026 on Windows: 181 and 1 under #[ignore] (since S3 — the input labels). Counted again after FU2 (the merged C3, N8a1 and B4), -- --list on 19 October 2026 on Windows: 333 and 2 under #[ignore] (src/ 110, tests/motion/ 221 — orders.rs 10: a sprint into a wall, a crawl, a corner, a replaced order, the count waiting while an action holds the body, a chase of a runner against a wall, a snapshot restored mid-stall, the tool descriptions naming the constants — tests/readers.rs 2)
shards_settings 62 src/ (18) and tests/settings/ (44: the store, the file and its corruption, editing the file by hand in a running game, a retry of the write and the write on exit, groups, tools, isolation from the snapshot, the hash and replication)
shards_ui 70 src/ (23: parsing of actions and colours, checks, parsing of Binding and the main menu, waiting for input, U2 +5 in flash.rs, U1 +4 in markup.rs, U3b +4 in map.rs) and tests/ui/ (47, U2 +5 in flash.rs, U1 +2 in fonts.rs, U3a +3 in compass.rs, U3b +4 in map.rs: screens, menus, keyboard, the d-pad and the stick, drawing and accessibility labels, the engine font with Russian, replay, edits and refusal of content; the key screen bindings.rs 7, the main menu and the loading picture main_menu.rs 7)
shards_locale 21 src/ (11: plural forms, a phrase inside a phrase, the fallback language, parsing files, the system language against the game's languages) and tests/locale/ (10: changing the language in the game, the menu, the content check, reloading a file; the system language on the first run — 4)
shards_audio 56 (a voice cut short +1: tests/audio/subtitles.rs; F1b +1: mixer.rs, the ears of a first-person body are at its eye; F10 +19: src/ +3 (the transmission's clamp, a world without physics, what is in the way said) and tests/audio/ambient.rs 16; D1.7 +1) src/ (17: the length of WAV and Ogg, counted from the pages, a broken page and the Ogg checksum, falloff, buses, voices, subtitle clocks and lines, a line two voices say going by each voice's own time and clock, a line said again moving up to the newest) and tests/audio/ (21, D1.7 +1: the voice limit and voice stealing, max_instances, distance and source, the clock, the player's volume, events, telegraphs and the menu, a clip cue at a bone (sounds from the bone's point at the cue's strength), the action effect Sound (sound from a body without a model; an unknown one only once), tools, layers, and hold — each layer has its own, music_set, local lines, a track removed from the content, the snapshot, the content check; subtitles: a played voice's line and its time, a taken voice's line, a voice cut short (stop: its fade and its line gone at once), the setting and the language, the check)
shards_look 35 src/ (12: the look's description and presets, a material from the source, transparency and glow, a flat copy and the outline shell, morph targets and data on the GPU) and tests/look/ (23: content checks and extends, tools and the developer menu, which mesh takes which look, materials, outlines and their RenderLayers, hot reload and presets, assets changed in place, for a co-op client — a body with a look in sandbox); 1 under #[ignore]: the picture on the GPU — bands and outline in pixels
shards_scatter 26 src/ (15: a voxel field near the tile is ground 1, the definition and each of its errors, spacing not less than a centimetre, the outline through extends, the limit of entities per tile; meshes; the layout — seed, spacing, graphics.foliage, the ground and the band of heights, free space above a slope and by walls, only static colliders near the tile, the limit for a tiny spacing) and tests/scatter/ (11: without a picture, tiles and repeats, walls and slope, only static colliders, batches and VisibilityRange, foliage, scatter_set, an edit of the content and the tile's tags, a definition that is too dense, a region change; one more #[ignore] — the picture on the GPU); a run on 16 October 2026 on Windows
shards_fx 69 (F9 +30, 39 counted with -- --list before it; D1.7 +1) src/ (13: the effect's description, typos in numbers, with no overflow and within the limits, flight by a formula versus steps, a cone and a sphere, the hit axis, the pool and evicting the oldest, decal shapes and the growth of the fill, bands from the zone rather than from the world's origin, colour packing, the shard mesh) and tests/fx/ (16, D1.7 +1: content checks, an effect with an error plays within the check's limits, tools, the menu and the status without a picture, pools from the content, start, the simulation clock, rate, event effects on the side of the hit, labels and PlayEffect, a cue at a bone and its strength (the point, fewer and smaller particles, what a rate emits later), decals of a circle and a sector, the ally's colour, turning decals off and DepthPrepass); 1 under #[ignore]: the picture on the GPU — a decal in the zone and particles in pixels; a run on 16 October 2026 on Windows, together with foliage; F9: src/ +14 (debris.rs 7: bounces, tunnelling, friction, walls and ceilings, an edge, late frames, the shown pose; mark.rs 5; marks_render.rs 2) and tests/fx/ +16 (gore.rs 12, content.rs +1, offscreen_gore.rs 3 under #[ignore] for a GPU: marks on a wall, a floor and a ceiling and kept off a pillar, chunks of a mesh with no UVs on the floor, a quad that wears a picture), counted with -- --list on 24 October 2026 on Windows
shards_hitstop 27 src/ (7: a rule for the local player's blows only, the rules in order — the first match gives the hold, ceiling and bad numbers, a rule the ones before it cover, typos refused) and tests/hitstop/ (20: the solo rule — a machine outside co-op takes it and a host or client passes it over, and the play tool names a rule held to solo play; the content check, the ladder for every event, a swing that lands — headless and nothing held, the tools and their errors, no table, the player's scale and local filter; alone in real time — no tick inside a hold, the speed masked, no burst after, 2 s of frames = ticks + held frames, merge by the later end, a speed set during a hold, a pause, a step and the gate, the cooldown; co-op host and client — pictures only, never the clock, the local filter); plus 4 in ai_core::hold, 1 in shards_action (a held body stands still) and in the sandbox hitstop.rs (a replay recorded while the clock was held verifies identical with hit stop off, headless and in a window; a blow between two others holds nothing; a manual hold keeps the table's ceiling; a real tick inside a hold breaks the rule), hitstop.scenario and stand/hitstop.scenario; live: --offscreen in real time (18 holds of 0.06-0.10 s in 8 s, 0 ticks inside, ticks 422 against 421 expected from the wall time less the held time) and a 1-client stand (picture holds only)
shards_light 25 src/ (8: the definitions read and written, their bad numbers named by field, colours from hex and from a temperature, a pattern stepping through its letters at its rate and looping, noise inside its depth and the same every time, what the player's flash setting makes of a flicker, the budget's nearest-first and its ties by key) and tests/light/ (17: the content check — clean, every bad field named with the file, a typo, a bad grading; the query and the flicker on the simulation's clock, the same in every run and in two steps as in one, calmed by accessibility.flashes, a moving noise light that keeps its wander and its reduced rate; the nearest lights that ask get a shadow, by settings, by moving the camera, by key; a light with no definition named; the status and no Bevy light headless; a game with no lights; and in a drawn game the Bevy light on a child without an AiId that follows the flicker and is not rewritten while steady, a spot's half angles and a kind that changes, the budget turning shadows on and off, a lost component or definition taking the picture away and a game's own light left alone)
shards_rules 37 src/ (24: C3.4a +1, a view needs a set in play and a class; def.rs one test per validation message, charges, min without a shift, a session row without a column and a prefab RuleClass that does not read included; read.rs the class of a body, a session row for 0 to 9 players, the session size with a corpse and a filter, token_limit, stamina_factor, incoming and outgoing; tools.rs the error texts of rules_set and rules, a change, cycle both ways, the answer of rules; guard.rs; the replay check, the journal line, the session line, the dev entry that says why it does nothing) and tests/rules/ (13: state.rs a new world plays start with no event, the main menu removes the rules alone and sets them neutral on a host, a client starts none and drops its copy at the main menu, the route and the tool refuse a client, the dev entry runs the next rule set, a region trip keeps them, refusals record nothing, a same-mode call changes nothing, cycle wraps both ways and cycle=2 is refused, a content edit adds to generation, a vanished mode falls back with a warning and one Content event, rules content that appears starts them, the session count with a filter that leaves a body out; snapshot.rs a snapshot with rules loads back equal with no rescale of a player or a brute, a snapshot without them removes them and a refused load puts them back, a host sets them neutral, neutral hashes as none)
shards_voxel 65 src/ (43: the volume — shape and chunk-count limits checked without allocating, edits clipped to the volume, the hash stable across runs and equal for -0.0, compaction; the palette and each of its errors; noise golden values; the registry, streams, retries, golden world, palette in the world hash; column_boxes and water_boxes against a brute-force reference) tests/voxel.rs (8: the content kind, errors naming the file, content_apply, no hash change from the kind alone, duplicate registration) and tests/region/ (14: the region kind — a region generated, built and answered for like one of tiles, the worldgen report with its totals and the fallback, a snapshot into a game without the region and a forged volume refused, the cache against a cold build in ColliderId order, a save and the refusal of another step version, hot reload, content errors, --check-content, the same API types on tiles and on a volume, a co-op client with another volume or none refused at the handoff, a replay with the cache on and off and in heavy mode, a forged manifest grid refused in a save, region_load and a snapshot, a mark off the volume, VoxelPlugin before WorldPlugin); a run on 18 October 2026 on Windows
shards_steam 70 src/ (31: the fake Steam 16 — lobbies and their type, lobby search (filters by data, lobby types, a full lobby, a slow and a refusing Steam), refusal to create a lobby, sessions and their closing, the server, achievements, cloud and quota, invitation, callbacks that fail; stopping of callbacks and the quota text 2; addresses and +connect_lobby 3; reconciling the cloud and file names 4; achievements 1; transport 1; lobby search — a filter by build, how lobbies differ, the size 3; the lobby's owner is the same account 1) and tests/steam/ (39: sessions 15, achievements 6, cloud 6, tools 4, lobby search 7, scenarios 1: a stand over the fake Steam)
shards_action 589 (F5 +15: tests/combat/using.rs, a press, glass, the dead and downed, AiId order against entity order, a hold and each way to cancel it, the revive that keeps its press, the tool and its refusals; F1b +2: view_model.rs, a definition with only its two names is complete, and what a view model names must exist wherever it is named; F2 +1: parts.rs, a part's at_crouched; F11 +1: shot.rs, the aim error by speed and distance, counted in a run on 23 October 2026 on Windows; F6 +1: tests/combat/crush.rs; F3 +15: shot.rs 5 (the defaults and the written form, falloff, bad numbers, the cone draw, the content check that names the file and the field), tests/combat/shots.rs 10, counted with -- --list on 23 October 2026 on Windows: 554 before it, the F1a merge having left this row as it was; F4 +25: def.rs 6 (the weapon and cost content checks, old content unchanged), arsenal.rs 3 (the switch rule, the prefab check), tests/combat/weapons.rs 16; D1.7 +4; ER-E +3, counted with -- --list on 22 October 2026 on Windows: 523 on main before it) src/ (199 with default features (F11 +1 in shot.rs; F3 +5 in shot.rs: 193 before it; F4 +9: 181 before it; D1.7 +4; ER-E +2 in draw.rs, the ring glyph and a telegraph that names it: 179 before it), 261 with render (F11 +1; F3 +5: 255 before it; F4 +9: 243 before it; ER-E +2: 241 before it; D1.7 +6; R1: parts.rs 4; R3: 1, lock points in content; D1.4: 9, the phase map and its looped phases' cues; D1.3: 5 in anim.rs (the heading, the facing clips and the backward gait, the backward cues, the carried stride, the checks), 4 in render/turn.rs and 4 in render/bridge.rs; D1.6: 2 in anim.rs (the envelope, the checks) and 6 in render/bridge.rs (an event overlay on the skeleton rig, an ignored hit)), of them a status a hook gives an entity later in the tick 1, including bake.rs 14 (D1.7 +2: a cue's bone is a node of the model, also on a clip from another file), clipfile.rs 8, anim.rs 43 (D1.7 +2: the cue defaults and JSON, the cue checks), anim/modes.rs 5 (D1.2: the body's mode and its mounting), render/bridge.rs 40 (D1.7 +2: a cue with a bone carries its world place and strength, on the body clip and on a layer), render/turn.rs 4 (D1.3: the model turned to a run's heading), render/modes.rs 13 (D1.2: a body's motion mode as the bridge reads it)) and tests/combat/ (371, F3 +10 in shots.rs: head and torso, a wall, pierce, allies and the dead looked through, falloff, the same pellets in two runs, an NPC's aim error, recoil held to the pitch limits, guard_damage, a Look spawn, the tool and the query; 361 before it; F4 +16 in weapons.rs: ammo, refusals, reloads, the arsenal, switches and the pickup calls; 345 before it, ER-E +1 in visuals.rs: an unblockable attack wears the ring on the ground and at the screen edge; C3.4a +5 in rules_costs.rs; 339 counted with -- --list on 20 October 2026 on Windows after R3 (lock_points.rs 5: a body taken only through its points, the locked point before a nearer part, turning to a point and a flick between points, a point going with its part and with its body, the prefab check); before it 334 after R1 (parts.rs 7: spawn order and placement, a hit through the nearest part with its factors, breaking, a capsule that takes nothing, on, off and tags, parts going with their body, the middle of the cone); before it 327, after FU2, B4, D1.1 (a golden test 1), B5, FU4, C3.2, D1.2, the merge of FU4 into B5 and its review (a status hook that kills the falling body leaves it dead, not down: lethal.rs 28); B5 added the lethal hook, the downed state, the bleed-out, the revive, a fallen attacker and a downed body refused the movement tools in lethal.rs 23 and a killing blow weighed by the lethal hook's answer 1; FU4 added 8 (the source of a status (+ nested hooks, + a combat object's owner), a binding the medium refuses, a paired run's aim (+ one started from a moveset input, which turns to the victim its select finds), a pair's angle origin, the journal word of a killed victim); the merge of the two added 5 where they meet (lethal.rs 4, 27 in all: a survived blow's statuses name the attacker and a downed body takes none, a finisher whose blow downs its victim ends lost and not killed, a revive turns to its downed ally and not to the lock, a revive lets go of an ally stood up another way; objects.rs 1: an aimed spawn passes over a downed lock and a downed AimTarget); FU2 added a dead body refused every movement tool and losing its orders, a held block's status line, a killing blow weighed without the break it never makes, also through a guard that lets the poise pass; C3.2 added rules_damage.rs (12): the incoming factor on a hit, a block and a guard break and not on poise, a parry, an evade or god mode, before the flat part of Armor, folded once by a hook that rebuilds from base; the outgoing factor on health and poise of a hit, a block and a guard break, times the session row, following a hook's credit and a combat object's owner; deal_damage against deal_ruled_damage)
shards_level 116 (ladders +1: tests/level/colliders.rs, the node, a turned node and the messages; F5 +6: markers.rs 5 (the use area from the node, a bare empty, the properties and their errors, a component named by hand, an interactable that is also a sensor refused) and spawn.rs 1 (bury order); F6 +9: tests/level/movers.rs, two of them with render) src/ (3) and tests/level/ (106: the file and its nodes, properties, colliders, markers, spawning, level in the content, replay, the picture, a real Blender export from_blender.rs 15, with the glTF Embedded variant)
shards_world 101 src/ (18, of them ground_below on a voxel field 1) and tests/world/ (83: generation, checks (with the tiles' navlink), dungeons, regions, a region change, a wall at the edge, level-tiles, their marker sockets, navlink and the errors of their files in content check, zones, the region's navmesh, a tile on cells of another size tile_size, the tile overlay overlay.rs 7 — with the render feature, content edits and levels placed by id, in snapshots and replays levels.rs 7)
shards_npc 286 (F12 +15: sequence/def.rs 1, tests/npc/sequence.rs 14; F11 +8: turret.rs 3, ranged.rs 1, threat.rs 1, tests/npc/ranged.rs 3, counted in a run on 23 October 2026 on Windows; F6 +1: navmesh.rs, a closed door carved) src/ (70, F11 +5 in turret.rs (the turn rate and the limits from the rest, the short way round, the checks), ranged.rs (a block names the ally or the wall) and threat.rs (marks stay sorted); N8d +2 in def.rs and planner.rs, the leash fix +1 in planner.rs, N8c +1 in memory.rs, N8a2 +8, recounted on 19 October 2026 after the merge of main with -- --list; the rows above were older: the nav seed on a voxel field 1, avoidance nav::avoid 8, the bounds of avoidance 1, leaving a straight line 1, choosing a body class over the whole body nav::region 3) and tests/npc/ (201, F11 +3 in ranged.rs (a hiding spot behind a pillar and none off the navmesh, a body seen firing is a threat whatever its team, a shot heard within its noise); N8d +5 in live.rs, the leash fix +1 in nav.rs, N8e +10 in audit.rs, N8c +5 in schedule.rs 4 and warden.rs 1, C3.4a +1 in rules.rs; one more from C3.1b, 13 from N8a2, the rest from N8b and later; B5 +2: a downed body that is no target for NPCs, a downed player the director counts as gone; FU4 +2: a brain's target for a spawned object, a body without the mirror; the merge of FU4 into B5 +1: an NPC whose target goes down lays nothing at it; A2e +13 in voxel_nav.rs: the voxel region's navmesh baked by chunk and stitched, routes and a chase on it, every diagonal stitch in the tile graph: behaviour, perception, the director, the navmesh and path_to/clearance over it, the navmesh body classes 9 (of them a tall NPC under a low bar 2), a straight line to the target under the bar, off the navmesh 1, avoiding bodies 5, replay, snapshot, tools and npc_overlay, the navmesh overlay overlay.rs 6 — with the render feature, the guard with data); counted again with -- --list on 19 October 2026 on Windows after B5, FU4 and their merge: 223 (src/ 61, tests/npc/ 162)
shards_dev 8 src/ (2: a game's entry, the common prefix of words) and tests/dev/ (6: the GDD 32.8 list and the order of sections, entries and lines through tools, the console and its history, the overlay keys wait for an open panel, Tab, a broken entry in the content)
shards_save 102 src/ (35: a section of another crate under the same name takes over the migrations of the one it replaces; a write asks the section through check_in, SaveSection::check) and tests/save/ (67, one #[ignore]; since S3 continue_game and the hint under "Continue" — 4; since E10.5 — SaveWritten; a section's refusal on load names what had already been applied, and counts the refusing section as having changed the world; a refusal in check applies nothing); a run on 16 October 2026 on Windows, together with the manifest in the save, and the check tests by the difference
shards_net 142 src/ (89 — the channel layer without Bevy: since S2 cookie 3, the knock and protocol 1 format 3, the reply to a stranger over UDP 1; 53 — the session: since S2 the knock, cookie, the previous build, the table of strangers with a cookie, a character sent in parts — 8)
shards 139 (F13 +1: tests/action_render/view_model.rs, the view model's camera takes the grade of a world camera that does not draw in HDR; F1b +3: tests/action_render/view_model.rs, the second camera and the rig, a weapon switch, the bridge driving a rig that is no fighter) src/ (82: bench 5, coop 3, encounter_wiring 1 (the marker of its own NetAlways in a snapshot and a load, issue #72), frames 8, modules 2, offscreen 2, plugins 4 — one that runs only with steam, render_scale 10, run 24 — one that runs only with steam, one for an engine rule off by default turned on by name (A2a), one with heavy mode on a stand, one for the components the checks leave out, save_sections 6 (two of them — reading the region section v2 and version 1; three more — check of position, vitals and region), stand_udp 14, tile_levels 1, ui_wiring 1, window_icon 1), tests/engine.rs (7, of them 4 with render), tests/failures.rs (1), tests/level_render.rs (2: the arena and the Blender export, .glb and glTF Embedded), tests/rules_save.rs (8: the registry, the null section, saved modes, an unknown or damaged mode, NetLeft, the guard, the UI sources, the net event), tests/run_to.rs (3), tests/action_render/ (32, one #[ignore]: the window; GltfModel +1 in headless.rs (one handle with the bridge, spawned once); modes.rs 9 since D1.2, sockets.rs 18, headless.rs 3)
sandbox 549 on Linux, 540 on Windows (F12 +10 in tests/sandbox/sequence.rs 8 and engine_rules.rs 2: the scene's room, scenario, replay, locks and snapshots, and the control tests of two rules; F7 +3 in tests/sandbox/air_move.rs; F13 +10, four of them ignored for a GPU, in tests/sandbox/lights.rs: the room's file, the level's six lights and its volume (no AiId), the lights query on the clock, a lamp prefab, the level check's errors by node, the grading volume's blend; and on a GPU the picture's six lights with no glTF lamp left, a flashing lamp at two moments, the grading volume's channel means, and the manual's picture; F9 +3 in tests/sandbox/gore.rs: shots in the room leave holes, blood and chunks, a game that draws nothing plays the same game, ten times the budget of every kind; F5 +7 in tests/sandbox/using.rs; F1b +2 and one ignored for a GPU, in tests/sandbox/first_person.rs: the click's latency, the mouse's, and the --offscreen shot) tests/sandbox/ (518 on Linux, 509 on Windows; F12 added 10 (sequence.rs 8: the room's file, the scenario, a game that unlocks on the end of the scene, the locks on the action machine and the controller, a snapshot at every step of the scene, the sound checks, the reference replay in heavy mode, an actions lock stops a use and a hold in progress (F5) and a movement lock does not; engine_rules.rs 2: the control tests of motion.control_lock_sane and npc.sequence_holds); F13 added 10 in lights.rs, four of them ignored for a GPU; F7 added 3 in air_move.rs; F9 added 3 in gore.rs; F5 added 7 in using.rs (the room's file, the scenario, interact target= through the room, a game observer that opens the used door, a hold in a snapshot, the HUD sources, the replay with --heavy 10); F2 added 7 in crouch.rs (the room's file, the duct, the crouch jump over the ledge, a crouched dummy's hurtbox, eye and head, a crouched body on a lift, a client crouching its own body with the host agreeing, the replay with --heavy 10) and a control for motion.finite's crouch depth in engine_rules.rs; F11 added 6 in npc_ranged.rs (bystanders hide and stay, one with nowhere to hide cowers, a gunner keeps its band and never fires through its ally, a strafing gunner hits less, the turret within its limits, on and off, the replay with --heavy 10): 482 in a run on Windows on 23 October 2026, 11 of them ignored; F6 added 5 (movers.rs 4: the room's file, the pictures in the loaded scene, the scenario, a client on a host's lift; engine_rules.rs 1); F3 added 5 in hitscan.rs (five torso shots against three head shots, pierce and a pillar, the scatter gun alike in two games, the noise, the replay with --heavy 10): 471 listed on Windows with -- --list on 23 October 2026, 11 of them ignored. Before it 464 on Linux, 455 on Windows, recounted with -- --list on 23 October 2026 after F10 and F1a: 466 listed on Windows, 11 of them ignored; F10 added 2 in ambient.rs: the audio room's level file places its emitters and its pane, and the sandbox's mixer has no occlusion; the 10 more since the F4 count came with the F1a merge, which left this row as it was. The F4 count: after F4: 454 listed on Windows, 11 of them ignored, so 443 (the older sum was one short); F4 added 6 in weapons.rs (the weapons the player is given, a reload cut by a switch, a second weapon that reloads itself, a snapshot through a waiting switch, the armed prefab, the rule action.arsenal_sane), which has no stand_udp.rs 7 and shutdown.rs 2: they are Unix only; N8c added 2 in encounter.rs (a wiped pack's plans reset, walking home and placed home at once); the B5 dev menu added 1 in actions.rs (down_me, heal, down); N8e added 1 in content.rs (the warden's plan audited); D1.4 added 1 in animation.rs (the tool seeks ahead by the overstep, as the bridge does); D1.6 added 1 in animation.rs (an event overlay previewed, a bad event named); counted with cargo test -p sandbox --test sandbox -- --list on 20 October 2026 after R2 and before N8c, the B5 dev menu, N8e, D1.4 and D1.6: 441 listed on Windows, 11 of them ignored: 430, so 436 with their 6; R2 added 2 (ground laid in the middle of play through a snapshot snapshots.rs and in co-op net.rs); R3 added none; R1 added 3 (the parts rule's controls engine_rules.rs, a body with parts through a snapshot snapshots.rs, parts in co-op net.rs); that count has the issue #72 tests (encounter.rs, state_audit.rs), D1.1 (+7: the animation tool and the props animation.rs 6, a replay 1), N8a2 (+1: the rule npc.plan_sequence), B5 (+3: a downed body and a revive through a snapshot, a zero-health body loaded dead, the downed and grace rules) FU4 (+1: a client finisher while locked on another foe, net_predict.rs), D1.2 (+2: a swimmer's sword animation.rs, a replay with a swim replays.rs) and A2e (+4 in voxel_arena.rs: the navmesh in the arena, its sixteen chunks baked in one piece, and two #[ignore] measurements of the bake and route times); the other test binaries add 31 and the lib 2, so the totals are 478 and 469), ignored tests left out: 11, below; of them the narrowed content check content_check.rs 9, coverage coverage.rs 7, a fuzz run that stops and is shrunk on fresh games fuzz_shrink.rs 4, the regression folder and its runner in scenario_files.rs 13, of them tool contracts tool_contracts.rs 8, in-process fuzz fuzz.rs 5, heavy mode heavy.rs 10, the engine's rules engine_rules.rs 28, state_audit.rs 3, heavy_saves.rs 1, saves saves.rs 13, co-op net*.rs 180: net.rs 21, net_coop.rs 39, net_sync.rs 31, net_guards.rs 35, net_lifecycle.rs 20, net_predict.rs 30, net_seams.rs 4; stand_udp.rs 7, snapshots.rs 43, replays.rs 27, invariants.rs 12, the long game soak.rs 1; 11 more #[ignore]: recording the reference replays, two network timings, the voxel bake and route times (voxel_arena.rs), the half-hour long game, a screenshot without a window, the 3D resolution render_scale, the draw commands on the GPU, the model that moves between ticks while the body stays on the tick, and the content read headless and drawn, all five in offscreen.rs), tests/agents_index.rs (2), tests/system_failures.rs (10), tests/perf.rs (8: tick time and the automatic test on reference scenes, reference and the full-size region reference96 with baking its tiles; 1 more #[ignore]: the automatic test with offscreen), tests/log_capture.rs (7), src/ (2), tests/fuzz_campaign.rs (2; 1 more #[ignore]: the nightly campaign)
the template 45 template/tests/game/ (content 8, co-op 4, determinism 3, replays 3 and the recording under #[ignore], scenarios and stand scenarios 4, region 4, screens 6, audio 3, manifest 3, main menu 6)

Port gaps

What a port onto the engine needs and the engine does not have yet (the port's gap audit). Each gap is closed by a lane of PRs; a row says what of it is in the engine now.

gap what status where and how it is checked
G1 voxel terrain: a voxel field in the physics, the shards_voxel volume and generator, a voxel region kind, navigation over chunks, meshing, the AI layer (PRs A2a–A2c, A2e–A2g) 🟡 A2a, A2b, A2c and A2e are in (below); A2f and A2g are not: no mesh, no overlay or voxel_* tools beyond voxel_info
G1 / A2e voxel navigation: bake_volume / prebake_volume (shards_npc::nav::region::volume): the chunks of a voxel region, one bake per chunk and body class from the field and the water alone (bake_chunk, Sampler with a Frame: the tile path keeps its literal columns), on the compute pool, in chunk order, kept in NavBakes::chunks under a ChunkKey and in a process cache (SHARDS_VOXEL_CACHE=off), stitched across every chunk edge (Edges::Open: all edges open, the diagonal moves too) into the NavRegion, the route corridor widened by the chunks around it; machines that do not simulate do not bake (NavFailed, not baked: this machine does not simulate); nav_info bake, nav_path / path_to / NPC routes / npc_state on a volume, nav_bake and --check-content leave it alone ✅ crates/shards_npc/tests/npc/voxel_nav.rs (9 tests: the chunks baked and stitched, against the grid in one piece node for node and move for move with a step, a tunnel mouth and a lake on the seams, 64 routes of equal length, the same bytes on every run, the cache keys, carving, a client, no ground), sandbox/tests/sandbox/voxel_arena.rs (the island's 16 chunks against one piece: nodes, moves, the spawn's area, 64 routes; an NPC plans on the navmesh; voxel_nav_bake_time, a measurement, ignored), shards_voxel/tests/region (the navmesh tools on a volume), voxel_nav.scenario and the reference replay voxel_nav.json (verified, and with --heavy 10). Bake time, dev profile on a loaded machine (8 workers, CPU 9-100% busy): 16 chunks of 64 m 327-466 ms, 0.65-0.85 s with stitching for one body class, 1.2-1.5 s for both, 2.7-3.0 s in one piece on one thread (170-190 ms a chunk; the design expected about 50 ms and 0.15-0.3 s: not met); a route on the island 52-55 ms corner to corner (voxel_nav_route_time); not yet measured idle in --release
G1 / A2c the voxel region kind: RegionKind and Layout::Volume with every Layout match site changed (checks::RegionGraph::build, rules_of, check_manifest, region::plan, install, request_files, tools::regen, region_load, goto_tile, region_info, the TILE line, the report's version, save_sections::generator_version, the nav's no-navmesh path); the voxel_region content kind, the manifest's steps, spawning (field, water, sea, Current, markers, POIs from marks), the refusal of another step version, voxel.volume in snapshots and replays, the rebuild cache, hot reload, --check-content generation, the report's totals, sea_current_at, voxel_info, in_water, in_current, near_grid_edge ✅ crates/shards_voxel/tests/region/ (14 tests: the build and every answer, the report and the fallback seed, snapshots, the cache's colliders, saves and the step-version refusal, hot reload, content errors, --check-content, the same region API on both kinds (types, Poi and Marker with TileId, path_to, nav_info and nav_path, the save section), co-op handoff, a replay with the cache on and off and in heavy mode, a forged manifest grid, a mark off the volume, the plugin order), shards_world manifest unit tests (the volume round trip, the exhaustive Layout match) and the volume overlay test, the state audit; the sandbox voxel arena (content/world/arena.voxel_region.ron, its steps in src/gameplay/terrain.rs), voxel_arena.scenario and the reference replay voxel_arena.json, tests/sandbox/voxel_arena.rs (an NPC there plans on the baked navmesh since A2e; a body below the sea floor past the edge falls, and bodies_in_world stops the game), --worldgen-report voxel_arena in CI (1000 seeds) and nightly (10000). A co-op client's volume is compared at the handoff (the snapshot check), not by the periodic desync hash, which covers the replicated view
G1 / A2a the physics voxel field: VoxelCollider, VoxelField, the field paths of every query (rays walk the cells, casts merge column runs, overlaps and closer_than per cell), the hooks extent_at, top_under, solid_span and every reader moved onto them, subset and the snapshot hash with fields, the rule voxel.body_in_solid (off by default, turned on by name: --engine-invariant; on by default since A2c's fuzz runs) 🟡 crates/shards_motion/tests/motion/seams.rs (the differential test: one cuboid per cell, merged boxes, the field with the merge on and off; with the merge off, to the bit), tests/motion/voxel.rs (ids, order, replace, despawn, a body on a field), physics/world.rs and physics/field.rs (a field against a cuboid per cell on random fields, seams, the merged-box rescue, the hooks in a tunnel under a plateau), tests/readers.rs (the reader guard), the field tests of shards_npc (nav seed), shards_world (ground_below) and shards_scatter (solids), engine_rules.rs of the sandbox (the rule and its carve-out). The reference replays verify byte for byte, heavy mode included. Not in A2a: the nav bake stores no field for carving (by decision, A2e), the collider overlay does not draw a field (A2g). Waiver pending (the lead's call, the design's risk 10): the design's section 15 asks the merged field to stay within 1e-4 m of the per-cell world over a free 600-tick walk of 16 bodies on the hills; it does not on 33 of 40 seeds (first parting at tick 115 to 572, by amplified rounding at edges). What holds instead: with the merge off, to the bit on all 40 seeds; one step from the same state within 1e-4 m on all 384 000 body-ticks but two (seed 6), on which the merged boxes went the field's way; the first 100 free ticks; and the merged boxes as colliders part sooner and for three times as many bodies (docs/manual.md, "Movement (E2)")
G9 encounters: anchors (EncounterAnchor), the encounter and encounter_rules content kinds with load-time budget/tag/limit/need checks, a pure state machine (Idle/Armed/Running/Between/Wiped/Resetting/Won, whole-tick timers set and counted down in one tick), level-based counting, wipes that rewind one wave (pulled_back for a placed wave), absence resets in every fighting state, spawn points (offsets, markers, POIs, rings; ground, navmesh, rear-cone filter on lock-on/aim/forward), DetRng keyed by seed/tick/run key/wave/group/purpose, the events, the encounter* tools and conditions, encounter_returning, the encounter.* rules, the snapshot resource and replay check encounters, the world save section encounters, add_encounter_out_rule, add_encounter_despawn_hook, the join gate (NetHooks::join_gates), NetAlways for net_always fights, the cue observers 🟡 crates/shards_encounter (src/machine.rs and its 22 unit tests, one per table row and review finding; tests/encounter/ 84 tests: content start waves deaths wipe reset spawn persist anchors invariants tools hot_reload), crates/shards/src/encounter_wiring.rs, save_sections.rs, crates/sandbox/tests/sandbox/encounter.rs (10: snapshots of a real fight, one inside the net_always ring that lets its member go as the original does (issue #72: the umbrella's marker of its own NetAlways is in snapshots now), cues, join gate, NetAlways, navmesh filter), the scenarios encounter and stand/encounter, the replay encounter.json (also --heavy 10). Gaps: the TDD's required role tags, forbidden combinations, an allow-list of combinations and min/max_threat are not in the definition (E67, M8 count scaling); the walkability filter judges for the default CharacterParams and only where the region has a navmesh

Known limitations and deferred work

What does not work the way you might expect, and what is deliberately deferred:

  • fuzz and soak do not kick a client and let it rejoin. net_kick ends a client's link, but a rejoin is something the client's own process does (--join, or a stand's stand_client in a test): no tool makes a client join again, so a run cannot follow a kick with a rejoin. Chaos is single-game only (shards fuzz); the stand soak stays as it was. A tool that lets a stand member rejoin would close this.

  • Outside the region, path_to is local. Outside the loaded region (and for a body that the navmesh does not serve), path_to and move_to path=true use a local grid A* (cell 0.5 m, search in a limited area, no farther than 80 m by default), and clearance uses only physics rays.

  • The navmesh is per body class. Tiles are baked for agent from nav (by default, the sandbox skeleton's body) and for each class bodies (in the sandbox, large is the guard's body); routes of any walker (an NPC and its direct line to the target in sight, move_to path=true, path_to, clearance, nav_path) follow the tightest class that serves all of its body (not narrower, not lower, a step, climbing over and a slope no worse, the same swimming depth), with its own body; a body that none of the classes serves plans on the local grid, so a tall NPC needs its own class in bodies with its height, otherwise its routes are longer and are searched in a limited area. Each class is one more bake of all tiles and one more navmesh of the region in memory and on load; nav_overlay draws only the agent navmesh. Bodies have no jump and no ladders: navlink is good for going down, and for going up within climbing over and a step. Cutting (solids, applied after baking) can only switch cells off, not add steps. Avoiding bodies is local (a fan of velocities over the horizon): it does not look for places around the target, so a pack that arrives in single file stands in a second row behind the first, not in a circle (the director hands out places by the roles of those waiting). The navmesh must be baked after a tile is edited (--bake-nav), otherwise the content names a stale file, and the region bakes the tile when it loads.

  • Physics uses a grid broad phase (was: a linear scan). From S1, a query checks only the colliders in its own cells of the grid over the ground (levels 2, 16, 128 and 1024 m), in ColliderId order and with the answers of the full scan (E2.1). What is left: the grid is flat (x, z), so colliders that stand one above another (the floors of a dungeon) share cells and are checked together; a ray that would have to read more cells than the scan costs (across half the region and beyond: 300 m on 8×8 tiles of 96 m — 1.1 times faster than the scan), and a world with fewer than 32 colliders uses the scan; a long ray of sight or a projectile across the whole region is still O(n). Measurement: with 2644 colliders, eight body queries take 16 µs instead of 50, with 212 they take the same as the scan; a full-size region loads in 0.6 s instead of 3.9, the tick takes 0.5 ms instead of 0.9 (broad_phase_timing, reference96).

  • Levels from Blender are checked on one export from one version. The pipeline is checked on a real export from Blender 5.2.2 LTS (tools/blender/outpost_level.py, files and tests in crates/shards_level/tests/level/); other versions of the exporter have not been tried. ruin.gltf of the sandbox and the template is now also a Blender export (glTF Embedded, tools/blender/ruin_tile.py). Compressed meshes (Draco, meshopt in both variants, EXT_ and KHR_, — all checked on a Blender export; quantisation, which Blender does not write) are not read, and Bevy does not draw them either. An edit to the tile file itself, made in a running game, is not checked again by the content (the file is not a content file): if it is broken on the fly, it shows in the journal when the loader reads it, a region change that uses it is refused, and shards content check reads the file again.

  • Navigation links in the reachability check are taken on the author's word. The generator takes navlinks from the tile's navlinks (it does not open level files), and content check only matches the names against the markers of the file. Which links group a navlink starts from and which group it leads to is not checked against the ground (as the links themselves are not), and the navmesh may not take a link that the body cannot make (a climb above climbing over, a jump: nav_info names the reason). There are no tiles with navlinks in the sandbox or the template yet: the regions and their reports stay as they were.

  • Only the tile pictures stream. The region's geometry for physics is built in full when the region loads; by distance, only the visual tile scenes are loaded and unloaded (stream.rs, only with a window). Streaming of geometry for physics is not needed now: a full-size region from the spec (reference96: 8×8 tiles of 96 m, about 1900 colliders, a navmesh of both body classes with 2.3 million nodes each) loads in release in 0.61 s against 10–15 s in the spec, the tick takes 0.46–0.63 ms against 16.7 ms, the colliders take less than a megabyte; it will be needed if there are an order of magnitude more colliders or if tiles start loading from disk during the game. Foliage does not stream either: it is scattered over all tiles when the region loads, and no more than 10 000 mesh entities of a definition per tile; the undergrowth density (0.4 bunches per m²) on 64 tiles of 96 m would give about 470 000 mesh entities, so expanse has grass twenty times sparser (about 31 600 mesh entities with all levels of detail). Dense grass on a full-size region waits for scattering by distance to the players, as the tile pictures do. The offset curve of the hero's actions is baked from a clip (--bake-motion, motion_bake), but only the forward movement of the root bone: vertical and sideways drift is not taken (the baking names the sideways drift in its report). The offset of enemy actions is still set by numbers in the content.

  • The region in a save. The region section (version 2) stores the manifest, and the world is built from it, but the tiles, rooms and prefabs that it names must always stay in the content: without them the load is refused (a region migration is needed that will replace them in the manifest). Saves of version 1 do not keep the manifest: they are generated again, and after a change to the generator they are refused until they are saved again on the old content. The RegionRef of the position section is an id and a seed, without a hash: a character from the world of an older generator, on a world generated again with the same seed, is placed at the old coordinates.

  • Animation. Layers (upper and lower body) exist, but the layer mask is built from the model's bones when the player is bound, and only by name rather than by the file's hierarchy: a layer bone that the model lacks leaves the action with the movement clip (a warning). The bridge picks up clips of the shared skeleton. The repository has one model: a low-poly humanoid from Blender (tools/blender/humanoid.py), which every character in the sandbox and the template uses; in the sandbox, drinking from the flask uses a hand on the upper layer (the drink clip is in the second file); the template has no flask; there is no leg IK.

  • Input. Rebinding is stored in the player's settings (E8.6); input.ron is only carried over. The gamepad has not been checked on a real device. Telegraph symbols wider than ASCII (⚠) are drawn with strokes or with a suitable font (ThreatHud::font); without a font, ASCII is used.

  • Attack zones are flat. hit_zones and the hint "step out to N m" count the zone's footprint on the ground (a sphere as a circle, a cone as a sector). For "leave the zone" this is enough; only the strike itself takes a jump over a low line into account.

  • A broken dictionary in a content file drops all its definitions. A definition that does not fit its type is its own error (file, line and column, kind, id), and the file's other definitions still load. But a syntax error, an empty id, a repeated id in the file, or an unusable id breaks the dictionary { "id": (…) } itself: such a file adds nothing to the database, and next come errors "unknown action …" from the files that refer to its definitions. The cause is the first line of the list. An edit to a file where at least one definition is broken is not applied as a whole: the previous version stays in force for all of its definitions.

  • Replays are tied to the build and the content. A change to a number in the content or in the gameplay makes a replay diverge at the next check (DIVERGED at tick 60); the references are recorded again (record_reference_replays). A replay can start from a snapshot: the region, content edits and levels placed by id go into the snapshot; a level that the game placed itself, not by id, and geometry that a content edit rebuilt outside entities with AiId do not (the load is refused at the static_colliders check). A snapshot taken before PlacedLevels, while a level placed by id was in place, now does not load (the level is removed, and the check levels refuses): take it again. A snapshot and a replay from another minor version of the engine are not accepted (force skips the check): after the version went up to 0.3, the reference tests/replays/snapshot.json is recorded again.

  • Screenshots without a window need a GPU (--offscreen) or software rendering: WARP is checked on Windows, Mesa lavapipe on Linux has not been checked. There are no screenshots in CI: the job is not added.

  • The CI job replays-window is optional (continue-on-error) until it proves stable on the runners. The other four jobs are required.

  • Tags are not set. The maintainer sets v0.1.0 (commit e90193d), v0.2.0 and v0.3.0; the version in Cargo.toml stays 0.2.0 until the maintainer releases 0.3.0 (the phase B entries are already in CHANGELOG.md under 0.3.0). While there are no tags, the game pins the engine to a commit (rev = "…").

  • Joining a session: there is a cookie, but no rate limit per address. From S2, a peer is admitted only by a datagram with a cookie that the host gave this address and this session for a knock no more than a minute ago (shards_net::cookie): a forged address does not take up a place in the table of strangers and costs the host nothing except the reply to the knock (no more than the knock itself, so the host does not become an amplifying reflector either). The earlier limits stay: Hello, Ready and Bye from an admitted peer in a row are not rate-limited (the limits that still hold: the budget for parsing per poll, the join window 6 × timeout_secs, the time to forget a peer that left — 10 s without confirmations, a ceiling of 5 minutes, and max_strangers); a peer that knocks again and again gets a cookie and is admitted again; a session on LAN runs without an identity check. Known limit, in narrow form: whoever owns many real addresses (or ports of one address: PeerId — a hash of the address with the port, there is no limit on IP) and knocks and sends without stopping from each one, can still delay, or even break, the join of a player whose Hello comes in parts, or who arrived in one datagram on the same tick as a batch of such datagrams; now this costs him a "knock — reply" round trip from each address. A game of the previous build (protocol 1) gets a refusal in its own protocol; a game of this build gets no reply to its knock from a host of the previous build, and after timeout_secs it says what that may mean.

  • Content does not change during a session (a ban, not a broadcast). The content hash is checked on join; during a session the content is not sent. From S2 a change that would split the machines is not allowed through: while the host has a client past Hello (or a client in the session), content_reload, content_apply and level_reload are refused with a reason (refused: a content reload during a co-op session would desync its 2 clients; do it once they have left, or after net_end), and a file that changed on disk waits and is applied by itself when no clients are left or the session has ended (the journal says so once). Earlier, the first half-hour shards soak ended this way: the region file was changed in the middle of the game, and the client could not take the regenerated world. There is no broadcast of changes: the host would have to send definitions, level files and baked navigation, and change them for everyone on one tick, and the world built around the old content would have to be built again. Content is edited between sessions, as before, but now without a desync; nav_bake (writing navigation files) is not covered by the ban.

  • Saves in co-op: what is not done. From S2 the client asks the host for its character itself (save_game what=character: the host takes the body that the player plays with on the host and sends it, the client writes the named slot), and a character up to 1 MB goes in parts after Hello. Still to do: the tool's answer on the client is "requested", not "saved" (the file is written when the host's answer arrives; they wait for it in the journal, step --until "journal:saved (save_game"); the host does not answer more often than once a second; a character over 1 MB no host will accept, and the client does not write one from the host; from the host to the client a character goes as one reliable message (the channel itself cuts it into 1 KB pieces, limit 16 MB). The default slot is slot1; on a client, it is named after the player. Branches with a replay being played (replay_playing) in the host's routing are not covered by tests.

  • UI: what is missing. The key-binding screen does not change the axes (stick, WASD); only settings_set does. The loading picture is not visible during a region change that ends inside one call (there is no frame between them). The sandbox has no main menu (it is in the template). Drawing is checked by a test without a GPU (nodes, theme, AccessKit labels) and by an --offscreen screenshot, not by a real screen reader; the menus have not been tested with a real gamepad.

  • The reference replays are recorded again; across OSes they are checked on one machine only. The earlier ones (recorded in fb78b42 on 14 October) diverged on any OS: the content hash of the sandbox and the template has changed since then (phases C and D, the E10.1 looks, the E10.2 foliage, the E10.3 effects), and the simulation moved to libm (E10.6). Now seven replays of the sandbox and two replays of the template are recorded at the tip of the chain of branches (with record_reference_replays, not by record-replays.yml) on Windows 11 and on Ubuntu 24.04 (glibc 2.39) under WSL1; the files matched byte for byte, and each OS passed every_reference_replay_verifies_headless (engine) and reference_replays_still_match (template) on the recordings of the other. The processor is the same on both sides, so other x86_64 processors, macOS, ARM and Steam Deck hardware are not checked. The animation layers (D7) added the flask on the upper layer to the sandbox set, and the content hash then also counted the animation sets, although those are only for the picture (since DX2 the replay check content covers only what a replay read, and leaves them out): seven sandbox replays were recorded again on Windows, and in them only content and the hashes it goes into (state_hash, the hash of checks and of the end) changed; the entities and components are the same (the set of diff lines from git diff -U0 tests/replays — only these fields). Ubuntu 24.04 under WSL1 checked this recording (every_reference_replay_verifies_headless); the template's replays are untouched. The last part of the UI work (S3) changed the content hash of both games again (the engine's font instead of themes made for the sake of a font, the keys on the controls page, the template's main menu): seven sandbox replays and two template replays were recorded again on Windows 11, the difference is in the same fields. Ubuntu 24.04 under WSL1 recorded the same nine files again in stage 8, byte for byte, and on 17 October CI on GitHub's Ubuntu runners verified the checked-in ones (jobs test, template and replays-window). The other failures on Windows were fixed in the Windows build (E10.6): the \\?\ paths of snapshot_save (three scenario_files tests), path separators (a_relative_root_makes_the_asset_folder_absolute), the Unix signals of shards stand stop (two peer tests) and the writing of the settings (two persist tests), because of which eight more engine tests used to fail. The game and the stand work on Windows: the half-hour shards soak runs listed in the phase C acceptance table ran there.

Port gaps

Gaps found by porting a larger game onto the engine (its port notes), closed one change at a time.

Gap What Status Where and how it was checked
G5 / B1 hit outcome: reaction tiers and their actions, reaction armour, protection timers, pushes, per-hit guard damage, perfect-guard cost, guard passthrough and the guard-broken action and push, line of sight, stamina overdraft, perfect evade, ActionEnded; the DamageCtx and event refactor the rest of lane B builds on ✅ crates/shards_action/src/{combat,fighter,def,machine}.rs; tests shards_action/tests/combat/{reactions,outcome,golden,actions}.rs (test-local content reactions.*.ron), def.rs unit tests, sandbox/tests/sandbox/engine_rules.rs; the sandbox scenario reactions.scenario and the reference replay reactions.json; the reference replays verified unchanged by engine commit 1, the seven older sandbox ones re-recorded in commit 2 and reactions.json added (only content and hash lines changed; the two that carry a start snapshot also took the default MoveModifiers blocks that recording at the base commit adds as well)
B2a the action timeline: charge by hold (charge, paying into's stamina difference, charge and cooldown), turn rates with the movement input as the last aim (turn), the attack assist and its limits (assist: (angle, close, sight), the player's controls.attack_assist as the held input assist_off), face: Keep, miss recovery (miss_recovery, checked after the tick's hits, ActionMissed, extend_recovery), cooldown keys and the interrupted share (cooldown_key, cooldown_if_interrupted), the press queue (CancelDef::queue) and the single-slot buffer (MovesetDef::buffer), while_held, BindMode::PressHold, the lazy RunExtras, client reconciliation by (instance, action) ✅ crates/shards_action/src/{machine,predict,def,tools,ai,invariants}.rs, crates/shards_motion/src/input/, crates/shards_settings/src/groups.rs; tests shards_action/tests/combat/timeline.rs (test-local content timeline.*.ron: charge and its costs, turning and steering, the assist's clamp, closing cap, sight and toggle, face: Keep, miss recovery and its order, cooldown keys and shares, the queue's press lives, the single slot, while_held, the tools' hold), shards_npc/tests/npc/director.rs (an_early_chain_press_waits_for_the_combo_window: an enemy chain through the queue, the token kept), golden.rs unchanged, shards_motion/tests/motion/input.rs (press_hold_bind_writes_press_and_held, press_hold_bind_replays, turning_the_attack_assist_off_holds_assist_off), sandbox/tests/sandbox/engine_rules.rs (action.extras_follow_run); the sandbox: spar_heavy, spar_lunge, spar_lunge_far, spar_channel, spar_roll_keep and the moveset timeline (combat/sparring.*.ron), the scenario timeline.scenario and the reference replay timeline.json, snapshots.rs (mid_charge_and_after_a_whiff), net_predict.rs (a charge predicted and confirmed on its ticks, its clock never set back, a turn the host refused reverted, the host's miss recovery adopted, a host cut dropping the shown run); the reference replays verified unchanged by the engine commits, the eight older sandbox ones re-recorded in the content commit (only content and hash lines changed, and state_hash in the two that carry a start snapshot; no entities line). Merged with C4: shards_action/tests/combat/parity.rs (a MoveOrBack backstep with face: Keep keeps the body's facing; turn spans turn the run, a stance rate the body), the unit test in stance.rs (a client's own body turns by the action it shows). Leaps, ghosts, walking spans, only_in and intangibility came with B2c (next row)
B2c body and motion: Launch and Ghost in the controller, ActionDef::leap with the landing search (LeapSearch, max_water_depth), Blocker::NoLanding, walk spans, MovesetDef::only_in and Blocker::Mode, intangible spans and ghost, FighterView::new ✅ crates/shards_motion/src/controller/, crates/shards_action/src/{def,leap,machine,predict,invariants}.rs; tests shards_motion/tests/motion/launch.rs, shards_action/tests/combat/body_motion.rs, net_predict.rs, snapshots.rs, engine_rules.rs, scenarios/body_motion.scenario
B3 context and paired actions: memories (MovesetDef::remember: on, seconds, forget), context bindings (MovesetDef::context: per input the first binding whose when holds, Remembers, Pair, StaminaAbove, Condition through add_context_condition; a bound input beats an open Combo window), the guard's fresh press (GuardDef::perfect_needs_press: (gap, entry, rearm), GuardArm, one gate gate_perfect), paired actions (ActionDef::pair: select with team, state, reach, height, angle, line of sight, the lock-on target first, a slack between players; victim_action, only_victim, exclusive, hold_break, ends_break, break_range, cancel_on_hurt, strike_reaction as a forced reaction; PairStarted, PairEnded with Finished/Lost/Cut, release_pair, RunHalted), ActionDef::weight, the lazy Memory, ContextInputs, GuardArm, Pairing, Paired, RunHalted ✅ crates/shards_action/src/{context,def,combat,machine,predict,orders,tools,ai,invariants,lib}.rs, crates/ai_core/src/{describe,lib}.rs (register_ai_world_describer), crates/shards/src/{net_wiring,ui_wiring}.rs (you.finisher); tests shards_action/tests/combat/context.rs (28, test-local content context.*.ron), the def.rs unit tests context_fields_keep_old_json and context_content_is_checked, sandbox/tests/sandbox/engine_rules.rs (action.pairs_match, action.memory_sane), snapshots.rs (mid_pair_and_with_a_guard_press_armed), net_predict.rs (client_finishers_are_confirmed_by_the_host, context_staleness_around_the_break_is_counted: a paired action is not predicted after the stand counted 10 of 10 late presses mispredicted; the_slack_handoff_between_two_players_is_counted; a_predicted_guard_shows_the_hosts_perfect_window: 0 of 122 ticks differ; a_client_parries_and_counters), state_audit.rs; the sandbox: combat/context.*.ron (the moveset contextual, net ids 150-155), the scenarios context.scenario and stand/finisher.scenario, the reference replay context.json; the nine older reference replays re-recorded and byte-identical. Not in B3: intangibility (B2c; the Downed pair state came with B5), Godot's guard press that cancels a queued attack and a guard cancel from recovery only on a fresh press (design 13.11: no ruling yet, only C26-C28 are built)
B2b body state: a barrier that takes damage before health (Barrier, grant_barrier, the Barrier action effect with of_max, BarrierGranted), named damage-taken multipliers (DamageTaken, set_damage_taken, extend_damage_taken for the later-end rule, DamageTakenExpired), deal_damage, the status proc rules (min_proc_interval and ProcGates, cool_while_active, refresh, reset_on_refuse, capped, MovesetDef::max_statuses, Statuses::add_with), dev tools barrier and damage_taken, engine rules action.barrier_sane and action.damage_taken_sane ✅ crates/shards_action/src/{body,combat,status}.rs; tests shards_action/tests/combat/body_state.rs, status.rs unit tests, snapshot test in sandbox/tests/sandbox/snapshots.rs, the control tests in engine_rules.rs, scenarios/body_state.scenario, replay tests/replays/body_state.json
B4 spawned combat objects: the action effect Spawn(SpawnDef) (index lists, at, aim, count, Fan/Line/Radial, delay, random_turn, ground, stay), CombatObject, Projectile and ProjectileFlight (flight, homing, walls, the swept segment, the first target along it, ActionDef::impact), zones with HitDef::repeat (Repeats), HitDef::max_targets for sweeps, ActionDef::then, owner credit (DamageCtx::credit, source), a dead or gone owner's objects despawned, despawn_objects_of, objects_of, live_tags_at, HitZone::owner/tags, the caps max_objects 256 and max_objects_per_owner 96 (content), the cycle check, PrefabCache, no tombstones for objects (NoTombstone) ✅ crates/shards_action/src/{objects,def,machine,combat,zone,invariants,lib}.rs, crates/shards_content/src/prefab.rs, crates/ai_core/src/id.rs, crates/shards/src/tile_levels.rs (RegionPart); tests shards_action/tests/combat/objects.rs (30, test-local content objects.*.ron), the objects.rs unit tests, sandbox/tests/sandbox/engine_rules.rs (action.objects_sane, action.objects_capped), state_audit.rs, snapshots.rs (mid_flight_and_with_a_puddle_ticking), net.rs (objects_hit_the_same_on_host_and_client: the client has the host's objects by id and its hits in order, modulo source); the sandbox: combat/objects.*.ron and combat/caster.moveset.ron (net ids 170-185), the scenarios objects.scenario and stand/objects.scenario, the reference replay tests/replays/objects.json (--heavy 10 passes). Not in B4: a fighter's then is not predicted in co-op (a client shows idle until the host's chained run arrives; the manual's co-op notes)
B5 the lethal hook and the downed state: add_lethal_hook (Lethal, LethalCause::{Hit, Damage, Health}, Fate::{Die, Survive, Down}, the first answer that is not Die wins), lethal, go_down, revive_downed, bleed_out, grant_grace, the lazy Downed { bleed, by } and Grace { left }, IgnoreReason::Downed and Grace, Blocker::Downed, the filter Standing, MovesetDef::downed, PairState::Downed, Effect::Revive, the events WentDown, Revived, Survived, resume_stagger (a fallen attacker gives its pair's victim the rest of its break), the encounter out rule downed, a downed body saved as dead, the tools interact and down (and heal stands a downed body up), the condition downed, engine rules action.downed_sane and action.grace_sane ✅ crates/shards_action/src/{combat,context,def,machine,predict,lock,orders,objects,tools,ai,invariants,status,lib}.rs (objects.rs: a homing projectile does not follow a downed target; tend_objects before tick_downed), crates/shards_npc/src/{perception,director,schedule,overlay,brain}.rs, crates/shards_encounter/src/lib.rs, crates/shards/src/{net_wiring,save_sections}.rs; tests shards_action/tests/combat/lethal.rs (23, test-local content lethal.*.ron), outcome.rs (the_kill_weight_follows_the_lethal_hooks_answer), shards_npc/tests/npc/{perception,director}.rs (downed_is_no_target_for_npcs, a_downed_player_counts_as_gone), shards_encounter/tests/encounter/wipe.rs (a_downed_body_is_out_and_a_wipe_counts_dead_and_down_alike), sandbox/tests/sandbox/engine_rules.rs (the two rules' controls), snapshots.rs (a_downed_body_and_a_revive_come_back), saves.rs (loaded_zero_health_body_stays_dead), state_audit.rs; the sandbox: the hook spare (src/gameplay/fate.rs), combat/downed.*.ron (the moveset partner, net ids 200-201), the scenarios downed.scenario and stand/downed.scenario (a client goes down, is revived, and bleeds out at 150 ms and 2 % loss, nothing mispredicted), the reference replay downed.json (also --heavy 10); the sixteen older reference replays (B4's objects.json and N8a2's boss_schedule.json among them) re-recorded and byte-identical. With FU2: a killing blow's weight follows the hook's answer (the hooks are asked before the blow's event), and a downed body loses its orders and is refused the movement tools as a dead one is. With FU4: a spawn aims only at a standing body (target_of passes over a dead or downed lock, AimTarget or flight target; the NPC drive mirrors only a standing brain target), a paired run's aim follows its victim only while the pair holds it (keeps_victim; a revive's run turns to its downed ally), a revive lets go of an ally that stood up another way (lost), a survived blow's statuses name the attacker while a downed body builds none up, and a victim the pair's blow lays down ends (lost), not (killed); tests in lethal.rs (4), objects.rs (1) and tests/npc/director.rs (1); downed.json re-recorded for it (the revive now turns its reviver to the downed ally: only the reviver's facing differs), the sixteen others verify unchanged. Dev menu (combat): down_me (the caller's own body, down until revived), down (down id= bleed=30, finished in the console); heal revives. Test: the sandbox's actions.rs (1)
R1 body parts: the content kind parts (PartsDef { parts, body_hurtbox }, PartDef { shape, at, turn, health, damage, to_body, poise, tags, enabled }, at most 16, checked), BodyParts on a body (the prefab check names a missing definition), part entities spawned on the body's first tick on the machine that simulates (Part, PartHealth, SpawnedParts, hurtbox-only kinematic colliders) and placed in its frame every tick (no bones), a hit through the part nearest the middle of the hit (one per body per swing; body_hurtbox: false takes hits only through parts), DamageCtx::part (PartHit: the factors already in damage and poise, the tags in ctx.tags), the body losing damage * to_body and the part damage, Damaged::part, PartBroken, part_of, parts_of, set_part, break_part, the dev tool part (without id: the body the caller is locked on), the engine rule action.parts_sane ✅ crates/shards_action/src/{parts,combat,ai,invariants,lib}.rs; tests shards_action/tests/combat/parts.rs (7, test-local content parts.parts.ron), the parts.rs unit tests (4), sandbox/tests/sandbox/engine_rules.rs (body_parts_that_do_not_add_up_stop_the_game), snapshots.rs (a_body_with_parts_comes_back_mid_swing), net.rs (parts_come_to_a_client_and_its_swings_land_through_them: the client has the host's parts by id and place, and the host's hits through them; a client spawns and despawns none); the sandbox: characters/colossus.prefab.ron, combat/colossus.parts.ron, the locomotion colossus, the scenario parts.scenario, the reference replay parts.json; snapshot.json, saves.json and encounter.json re-recorded (their saved snapshots now carry the NPCs' AimTarget that FU4b added: only those lines differ), the fifteen others byte-identical. Not in R1: parts follow the body's transform, not its animation; lock points on parts (R3, the next row), a part as ground (none: a lying body is made ground by colliders the game lays, R2 below), the camera for a big body (R4)
R3 lock points: PartDef::lock (a part that is a lock-on target of its own: LockOnTarget and motion's new LockPoint on its entity, taken away by a break) and PartsDef::lock_body: false (the body itself is never taken; the parts check refuses it with no lock point, the prefab check refuses it with LockOnTarget); the action's lockable (a point while not broken and its body stands, is not the locker and is not a fighter of its team), the pick, the switch and the check over points (aimed at their centre; lost with the body, let go of on a break; action.lock_on_valid through the body), lock_on point= and a lock_body: false body's best point, points named with their body in answers, observe (a world describer) and the journal, a swing through the attacker's locked point first, the camera, the legacy pick and the aim assist aiming at a point's centre, and the body behind a point for orders, pairs, leaps (host and prediction) and AtTarget spawns (body_of, body_takes_lock, lock_points_of, target_name, pick_point_of) ✅ crates/shards_action/src/{lock,parts,tools,orders,context,objects,machine,predict,combat}.rs, crates/shards_motion/src/camera/{mod,lock,systems}.rs; tests shards_action/tests/combat/lock_points.rs (5, test-local definition pointed), the parts.rs unit test of the new fields (1), sandbox/tests/sandbox/snapshots.rs (a_body_with_parts_comes_back_mid_swing: a lock on the core and the points' markers come back, the broken hand none), net.rs (parts_come_to_a_client_and_its_swings_land_through_them: c1's lock on the hand is held by the host and let go of on both when the hand breaks); the sandbox colossus's five parts are lock points with lock_body: false, parts.scenario locks on to points by name and flicks between them, parts.json re-recorded, the eighteen others byte-identical. Not in R3: points follow the body's transform, not its animation; a vertical flick (R4 adds none)
R2 temporary ground: no engine change. Static and kinematic WORLD colliders laid and lifted in the middle of play are ground for the controller from the next tick; with AiKind (which gives it an AiId) a snapshot keeps them and co-op sends them to the clients; the navmesh cuts them out at its next refresh and bakes nothing on top. Verified by tests and written down as the recipe for a toppled giant (the manual's "Ground laid in the middle of play (R2)" in "Movement (E2)"); the foliage section's ground rule is now marked as the scatter's ✅ tests shards_motion/tests/motion/ground.rs (3: a slab laid from a system, static or kinematic, landed on and walked along, climbed like a ledge, and the fall when it goes; a kinematic slab that slides away leaves the body behind), sandbox/tests/sandbox/snapshots.rs (ground_laid_mid_play_comes_back_and_holds_the_player), net.rs (ground_laid_mid_play_comes_to_a_client_and_holds_its_body). Not in R2: ground that carries what stands on it (a plain moving kinematic collider leaves the body behind; movers, F6, carry); a walkable navmesh surface on laid ground
F6 movers (doors, lifts, platforms): the content kind mover (MoverDef { keys, speed, turn_speed, wait, loop, blocked }, MoverKey { at, turn, time, wait }, MoverLoop::{Off, PingPong, Cycle}, Blocked::{Stop, Reverse, Crush { damage, every }}, checked with the file and the field), Mover, MoverPart, MoverState (snapshots, co-op, the replay hash); the step in SimSet::Move before the controller, in AiId order (carry by the mover's motion, yaw too; push out the shortest way; the blocked rule; static at rest, kinematic while moving; no momentum handed on; characters only), mover_go, mover_state, MoverStarted, MoverArrived, MoverBlocked; crushing through deal_damage on the machine that simulates (shards_action); the level property mover=<id> (the node's children move with it; the picture follows, blended); the dev tools mover_go and level_despawn, the describer, the condition mover_arrived, journal lines; the engine rule motion.mover_sane; a client predicts its body on a mover run on to its predicted tick (MoverSystems::Predict) ✅ crates/shards_motion/src/movers/{mod,def,run,step,ai}.rs, controller/mover.rs (the ground probe names the collider it met; excluding, inside, crate-internal), crates/shards_level/src/{props,spawn,render,tools}.rs, crates/shards_action/src/{combat,lib}.rs; tests movers::run (5), shards_motion/tests/motion/movers.rs (15: rides up and down, a jump on a rising lift, a turntable, a door's push, Stop, Reverse, Crush, loops, a snapshot mid-ride, the agent's side, bad definitions), shards_level/tests/level/movers.rs (7, one with render), shards_action/tests/combat/crush.rs, shards_npc/tests/npc/navmesh.rs (a_closed_door_is_carved_and_an_open_one_is_not), sandbox/tests/sandbox/movers.rs (the room's file, its scenario, a client riding the lift: no snap, no desync, the host's replay plays the same), engine_rules.rs; the sandbox's room levels/movers.gltf with world/movers.{level,mover}.ron, movers.scenario, the reference replay movers.json (verified, --heavy 10 --heavy-span 30: 130 checks); recording it left the nineteen others of the time byte-identical, and with F4's weapons.json, F1a's look.json and F3's hitscan.json all twenty-three verify. Not in F6: a lift as a navigation link (NPCs walk around a closed door and through an open one, but do not ride); momentum handed on to a body that leaves a mover; movers pushing props or other movers; a client's prediction of a mover's start before the host's state says so (mended by the correction)
F5 use by looking: the physics layer USE (a query layer that collides with nothing), the component Usable { name, prompt, hold_s, use_range }, the pure ray use_target / use_probe / use_point (from eye_of along look_dir against USE and WORLD: a wall or glass nearer blocks, the nearest in its reach wins, a tie goes to the lower ColliderId), the locomotion field use_range (2 m by default, out of the written form); ActionSystems::Use (before the machine, bodies in AiId order): an interact press that finds a target triggers Used { who, what, name } (journalled, not a net event), a hold_s makes UseProgress (reflected state: snapshots, the replay hash) that grows while held and ends in Used, letting go, looking away, going out of reach or down cancels it; a revive in reach keeps its press; the tool interact (target=eN turns the look first, every refusal says why and changes nothing), the USE line of observe, use_view, the UI sources you.use_target and you.use_progress; a level interactable gets Usable and a use area from its node, the properties hold_s, use_range, prompt and the layer word use, checked with the node named ✅ crates/shards_motion/src/usable.rs, physics/mod.rs, controller/params.rs, crates/shards_action/src/using.rs, look.rs, tools.rs, crates/shards_level/src/{props,spawn,tools}.rs, crates/shards/src/ui_wiring.rs; tests usable::tests (11), shards_action/tests/combat/using.rs (15: a press, glass, the dead and downed, AiId against entity order, a hold and each way to cancel it, the revive that keeps its press, the tool and its refusals), shards_level/tests/level/markers.rs (5 more), spawn.rs (the bury order), sandbox/tests/sandbox/using.rs (the room's file, the scenario, interact target= through the room, a game observer that opens the used door and the use area sliding with it, a hold in a snapshot, the replay in heavy mode: --heavy 10); the sandbox's room levels/use.gltf with world/use.level.ron, use.scenario, the reference replay use.json; recording it left the twenty-five others byte-identical, and all twenty-six verify. Not in F5: a use by an NPC, a sphere cast for small things, Used as a net event, a use progress told as events
F2 crouch: locomotion gains crouch_height (none: the body cannot crouch), crouch_speed (a cap on the crouched walk, none: no slowdown) and crouch_time (0: at once), all left out of the written form at their defaults and checked with the field named; the input crouch (input_names::CROUCH, held, in the standard map on X; hold_to_toggle turns it into a toggle) is read from Intent::held by the controller; the stance is the reflected component Crouch { depth, wanted, blocked } beside MotionState (a new field of MotionState or LocomotionInput would have changed every body's hash), put on a body when it first crouches, net_predicted (a predicting client leaves the collider's shape to the host's state), judged by motion.finite; on the ground the feet stay and the head comes down, in the air the head stays and the feet are pulled up (Crouch lift added to Transform), a stand-up is a shape cast of the standing capsule (up on the ground, down in the air) and waits while it is blocked; Crouched and Stood events with journal lines; CharacterParams::{can_crouch, height_at, eye_above_feet_at, at_depth} give every reader of a body's size the stance (the controller's casts and collider, the separation pass, the movers that carry it, clearance/path_to, eye_of); the hurtbox is the body's own collider, fitted each tick; PartDef::at_crouched moves a part with the stance; the tool crouch (hold=true or hold=false; answers say how far and over how long, and when there is no room to stand), the describer (ground 2.1m/s crouched, crouched, no room to stand), move_info, and stance= (standing, crouched or current) on clearance and path_to (a crouched route is planned on the local grid: the navmesh is baked for the standing body) ✅ crates/shards_motion/src/controller/{stance,params,mod,locomotion}.rs, eye.rs, ai.rs, tools.rs, invariants.rs, input/map.rs, perception/mod.rs, movers/step.rs, crates/shards_action/src/{parts,tools}.rs, crates/shards_core/src/intent.rs; tests controller::stance (7), params (3), ai (1), shards_motion/tests/motion/crouch.rs (10: the capsule and the eye over crouch_time, a body that cannot crouch, a duct passed crouched, a ceiling that holds a stand-up, the speed cap and no sprint, a crouch jump over a ledge a plain jump misses, the head kept in the air, clearance and path_to with stance=, the refusal), parts::a_part_with_a_crouched_place_... (1), sandbox/tests/sandbox/crouch.rs (7: the room's file, the duct, the ledge, a crouched dummy's hurtbox, eye and head and a crouched shooter's eye, a crouched body on the movers' lift, a co-op client crouching its own body, the replay in heavy mode), engine_rules.rs (the depth control); the sandbox's crouch_viewer locomotion, crouch_dummy prefab and parts, room levels/crouch.gltf with world/crouch.level.ron, crouch.scenario, the reference replay crouch.json (verified with --heavy 10); recording it left the twenty-four others byte-identical (git status tests/replays). Not in F2: NPC brains do not crouch (no hiding yet, F11), the attack assist's sight line and a leap's landing probe use the standing size, an NPC's own eye is its perception content's eye_height, a crouched route on the navmesh, and the first-person camera's own easing of the eye (F1b: it follows eye_of, so the crouch shows in first person)
F13 lights from content, flicker, the shadow budget and colour grading (the FPS spec): the module shards_light (shards::light, optional: --without light; the content kind light, LightDef { kind: Point | Spot(inner_deg, outer_deg), color | kelvin, intensity (lumens), range, radius, shadows, flicker: None | Pattern(pattern, rate) | Noise(rate, depth) }, checked with the field named; the reflected component ContentLight { id }, placed by a level node's light=<id>, a prefab or code, and replay_ignored; flicker::level, pure in the simulation's clock and a seed of the light's own, never SimRng; budget::casters, pure, the nearest lights that ask for a shadow get one; LightState, refreshed every frame and by the query; the player query lights and light in ai/status; with render a Bevy PointLight or SpotLight on a child entity without an AiId, LightPicture); the setting graphics.shadow_lights (u32, default 4, 0 to 64, none under shadows = "off", GraphicsSettings::shadow_light_budget); shards_level: the properties light and grading (checked against the content and the node: an unknown or empty id with a "did you mean", grading off a trigger marker) and the glTF loader's own lamp under a light= node taken out of the picture (render.rs, lamps); shards_motion::camera::grading: picture.grading: Option<Grading> (exposure, temperature, tint, hue_deg, saturation, contrast, lift, gamma, gain; left out of the written form), the content kind grading (GradingDef { blend_s, grading }), GradingVolume { id } (a level node's grading=<id> on a trigger marker), the resource GradingBlend (tracked in FixedLast from MotionState::volumes, or the camera's place with no local player, evaluated on Time<Fixed>), apply_grading onto the third-person and first-person cameras, the view model's camera taking the grade of a world camera that does not draw in HDR (shards_action::render::view_model) ✅ crates/shards_light/src/ (def.rs, flicker.rs, budget.rs, render.rs, tools.rs), crates/shards_motion/src/camera/grading.rs, crates/shards_level/src/{props,spawn,render}.rs, crates/shards_settings/src/groups.rs; tests shards_light 25 (src/ 8, tests/light/ 17: the content check, the query and the clock, the flash setting, the budget, the Bevy lights of a drawn game), grading.rs 7, tests/action_render/view_model.rs +1, tests/sandbox/lights.rs (6, and 4 #[ignore]d for a GPU), lights.scenario; the sandbox's content/light/, levels/lit_room.gltf, docs/media/lights.png; measured on a GPU with --offscreen: the flasher on against off moved the brightest block of the room's picture by 91 of 255, and rust moved the mean colour from (85, 88, 78) to (98, 59, 56); cargo run -p sandbox --release -- --perf reference --offscreen passes every budget, three runs each back to back with the main it was cut from (tick average 0.87-1.14 ms against 0.85-0.98 ms, frame average 3.32-3.94 ms against 3.35-3.59 ms: run to run noise is about 10 percent, and the scene has no lights; the module adds two resources, which Bevy 0.20 keeps as entities (16484 entities against 16482), and a few systems that find nothing to do); no reference replay changed. Not in F13: directional lights as content, an emissive bulb that follows a flicker, hysteresis in the shadow budget, per-channel lift/gamma/gain wheels and a LUT (not in Bevy's built-in path), grading of a view model under an HDR camera
R4 the camera next to a big body: measured first (tests/motion/camera_big.rs, measure, #[ignore]: at the defaults the feet sit at y -0.37 of the frame and a point 6 m up at 2 m, 9 m up at 8 m and 12 m up at any distance reach the top edge or pass it), then FramingTuning::fit (FitTuning { margin, tilt_max, rate }, default None: no change): a locked camera's view turns up from the focus (ThirdPersonCamera::tilt, fit_tilt, measured in the camera's own frame) just far enough to put the target on the top margin and never so far that the feet leave the bottom one (the player is kept when both cannot be; fit_room holds the tilt to the feet and tilt_max on every frame); a lower camera is the existing framing.pitch_clamp; the far plane needed nothing ✅ crates/shards_motion/src/camera/{tuning,math,mod,systems}.rs; tests camera::math (the_fit_turns_up_to_a_high_target_and_never_loses_the_feet), tests/motion/camera_big.rs (6 and the measurement), camera_content.rs (a_fit_is_read_with_its_defaults_and_bad_numbers_are_errors); the sandbox's combat/camera.camera.ron turns the fit on (content: 214 definitions in 64 files). Not in R4: an arm that grows for a big body (a game sets ThirdPersonCamera::distance); framing a threat other than the lock (a swinging hand while locked on a leg); a vertical flick
K1 a separate aim sensitivity: controls.aim_sensitivity (0.05 to 5) to CameraSettings::aim_sensitivity, used by free look while the game sets CameraOffsets::aiming; the sandbox's "Aim speed" slider ✅ crates/shards_settings/src/groups.rs, crates/shards_motion/src/camera/{mod,tuning,systems}.rs; tests tests/motion/camera.rs (1), input.rs, tests/settings/{persist,tools}.rs
K2 camera auto-centre: controls.camera_auto_centre (off by default) to CameraSettings::auto_centre; CameraTuning::auto_centre (delay_s, rate, min_speed, max_turn_deg, pitch); free look turns behind a walking body after the look is left alone (ThirdPersonCamera::look_idle_s, camera::math::auto_centre); the sandbox's toggle ✅ crates/shards_motion/src/camera/{math,tuning,mod,systems}.rs, crates/shards_settings/src/groups.rs; tests camera::math (1), tests/motion/camera.rs (3), input.rs, tests/settings/{persist,tools}.rs
K3 scene cameras: the content kind shot (ShotDef: keys with eye, look, fov_deg, ease, cut; points At and On { role, offset, local }; blend_in_s, blend_out_s, skippable); camera::shot::{play, stop, cancel} over the orbit camera, which stands still meanwhile; ShotStarted, ShotEnded, Shots, journal and observe lines; the tools play_shot, stop_shot; refused headless ✅ crates/shards_motion/src/camera/{shot,mod,systems}.rs; tests camera::shot (3), tests/motion/camera/shot.rs (5), camera_content.rs (1)
G7 / C1 locomotion modifiers: speed factors, caps, root, sprint cost, wading, fast swim, two-tier climb-out, landing tiers (the motion half) ✅ crates/shards_motion/src/modifiers.rs, controller/; tests tests/motion/modifiers.rs, shards_action/tests/combat/modifiers.rs, scenarios/modifiers.scenario. C1b adds the options an exact port needs (surface-relative jump climb-out, analog caps and sprint, stance speeds, per-axis and per-stance acceleration, air braking, the wading reference point (standing and airborne), the climb-out reach, sprint decided in the air, sprint resume rules, a per-body exemption from status slows): tests tests/motion/modifiers_parity.rs, fighter.rs (a_dry_sprint_opens_by_its_rule). A ledge exactly at a climb-out limit climbs: climb_out_auto_height is compared with the same 1 mm of float slack as mantle_height (MANTLE_SLACK; test the_auto_climb_out_height_takes_the_mantle_slack in tests/motion/modifiers.rs). Not in C1: the sea current, hit stop (per-span move speed in actions and the afloat-only start gate are B2c)
G7 / C4 controller parity, round two: backstep (Steer::MoveOrBack), turning speed per source (free, locked, guard, swim), closed-form water entry (brake and spring), stamina regeneration holds per source (free sprint, guard), climb-out facing test and its own duration, crawl lock check ✅ crates/shards_motion/src/controller/{params,locomotion,mod}.rs, modifiers.rs, crates/shards_action/src/{def,fighter,machine,stance}.rs; tests shards_motion/tests/motion/controller_parity.rs, shards_action/tests/combat/parity.rs, scenarios/player_controller_parity.scenario. All off by default; the reference replays are unchanged. Not built, by the port's design ledger: explicit Euler integration, a swim leave margin, a side search for the climb-out, per-axis stepping
G3 / C2 hit stop: a brief hold of the picture, and of the real-time clock when playing alone, when a blow lands; never slow motion and never the simulation's (no tick lost or added) ✅ crates/shards_hitstop (the hitstop content kind: an ordered list of rules over the combat events, first match gives a hold, max_seconds and cooldown; HitStopped; the hitstop: journal line as Local; settings accessibility.hit_stop and hit_stop_local_only; tools hitstop and hitstop_play), ai_core::hold (ClockHold: virtual speed 0 for real time, sim::speed masks it, sim::step ends it; PresentationHolds by AiId), shards_action::render::bridge::drive (pauses the held body's player); tests shards_hitstop/tests/hitstop/ (solo in real time: no tick inside a hold, the speed masked, merge by the later end, cooldown, pause, step and gate; co-op host and client: pictures only, never the clock; headless: nothing held and why; content check), ai_core::hold (4), bridge.rs (a held body stands still), sandbox/tests/sandbox/hitstop.rs (a replay recorded with the clock held verifies identical with hit stop off, headless and in a window that plays it), scenarios/hitstop.scenario. Not in C2: the finisher and counter weights are set by a game's hook (the engine never sets them, rules over HitWeight are ready); a hold is checked at the start of a frame, so it lasts its time plus up to about two frames
G10 / C3.1a rule modifiers and difficulty, slice 1a: the crate, the content, the resource, the tools (no hook site reads the rules yet) 🟡 crates/shards_rules (shards::rules, a module every game runs): the content kinds rule_set (RuleSetDef, one per mode: by class incoming_damage, outgoing_damage, max_health, max_poise, stamina_cost, perfect_bonus, charges; attack_tokens, attack_rest) and rules (RulesDef, the one definition default: modes, start, classes, session, blocked, host_only) with the whole validation (charges included) and the prefab check rule_class; ActiveRules (a snapshot resource, the prepare rules after content, the optional replay check rules: absent while neutral or without rules), RuleClass, RuleScaled, SessionFilter, RulesGuards (empty); start_rules (in the public set RulesSystems::Start), end_rules (a host sets the rules neutral; alone, and on a client, they are removed), rules_content_applied; count_session in RulesSystems::Apply (in SimSet::Input before WorldSystems::Zones and CoreSystems::FollowOrders, with a query state of its own); the read API; the tools rules (with playing) and rules_set (host only by the route and by the tool, out of combat, cycle, a refusal of its own while a region loads), the condition rules_changeable, ai/status → rules, the dev entry "Next rule set" (DevCommand::Live: it says why it does nothing in a game without rules or on a client), RulesChanged, the engine rule rules.mode_known; tests src/ (23) and tests/rules/ (13), the sandbox's control test of rules.mode_known; the fourteen reference replays of the sandbox and the two of the template verify identical. Not in C3.1a: the hook sites (C3.2-C3.5), the npc_engaged guard, the rules save section, the rules.* UI sources, the net event and the net SessionFilter, RuleClass in the prelude (C3.1b); the bodies brought to the rules and the neutral pass (shards_action::rules_apply, C3.3a), the pure charge arithmetic of 7.7 and its tests (C3.3b), a check of a RuleClass a level file gives (C3.3a)
G10 / C3.1b rule modifiers and difficulty, slice 1b: the engine's guard, the world section, the umbrella's wiring 🟡 shards_npc: the rules guard npc_engaged (add_rules_guard; engaged_npc factored out of the condition, both use it; the reason names the first fighting NPC in AiId order); shards::save_sections::RulesSave (world section rules, version 1, after region, written in every game, {"mode": null} without rules; a null mode or a missing section is a strict no-op; shards_rules::load_mode sets another mode with generation + 1 and RulesChanged { cause: Load }, warns and keeps the mode in play for one the content lacks, and the check refuses a mode that is not a name); the UI sources rules.mode, rules.name[:mode], rules.summary[:mode], rules.blocked; net_event::<RulesChanged>() and the net SessionFilter (NetLeft bodies leave the session count); RuleClass in the prelude; saves.rs lists the rules section; crates/shards/tests/rules_save.rs; the reference replays verify identical. --difficulty is the game's flag (11.4 of the design builds nothing in the engine). Not in C3.1b: the rules_body section and the hook sites (C3.2-C3.5), the scenario, the replay and the stand (C3.6)
G10 / C3.2 rule modifiers and difficulty, slice 2: damage 🟡 shards_action::combat: DamageCtx::rules (the target class's incoming_damage, set and multiplied in modifiers after DamageTaken and before Armor; hit, block and guard break; not poise, not a block's stamina cost, not a parry, evade or god mode), the outgoing step in resolve after the hooks (the credit's outgoing_damage times the session row's, on health and poise of a hit, a block and a guard break: it follows a combat object's owner and a hook's credit), deal_ruled_damage next to deal_damage (which says it is never scaled); ActionPlugin adds RulesPlugin when it is missing; a factor of 1 is never multiplied in, so the reference replays do not change; tests shards_action/tests/combat/rules_damage.rs (12, the combat-object case included). Not in C3.2: the bodies' maxima, stamina, the perfect window, charges, tokens and rest (C3.3-C3.5)
G10 / C3.4a rule modifiers and difficulty, slice 4a: stamina cost 🟡 shards_action::machine: stamina_cost(def, id, rules) (cost.stamina times the class's matching stamina_cost rules), read by the start check (Blocker::Stamina reports the ruled need), the start's pay and a charge's pay_branch (the difference of the two ruled costs); FighterView::rules and the sixth argument of FighterView::new, filled by the machine, follow_attack_orders, predict_actions, the NPC npc_view (director, planner, chains, strike notes; Fighting::class, FightCx::rules) and FighterView::of; shards_rules::RulesView::{of, of_entity}. A body without a class, a game without rules and an action that costs nothing pay cost.stamina exactly, so the reference replays do not change. Tests shards_action/tests/combat/rules_costs.rs (5: the start's cost by mode, the class, the wait, a charge's turn, an agent's order), shards_npc/tests/npc/rules.rs (1: an NPC asks for no attack it cannot pay for), shards_rules read.rs (1). Not in C3.4a: the perfect-window bonus (C3.4b), the maxima (C3.3), charges, tokens and rest
N1-N6 NPC rules for duels: director strike spacing with exempt tags and a noting-only mode (ignores_spacing) (N1), conditional plan options and a state's rest clamp (N2), rest semantics rest_interrupted / first_rest (N3), combo continuation chain and ChainDef::gate_at_start (N4), decision cadence think and press_on_decision (N5; between decisions the NPC keeps closing in, N1b), perception keep_range (N6) ✅ crates/shards_npc/src/{strike,chain,def,planner,director,brain,perception}.rs; tests shards_npc/tests/npc/duel.rs (tick-exact: spacing 42 ticks, rest, cadence, chains), perception.rs, unit tests in def.rs, strike.rs, invariants.rs (the engine rule npc.strike_spacing with its control test); scenarios/npc_duel.scenario. Not in N1: telling encounters apart by distance (all NPCs of a director are one encounter), N7 (co-op token cap) and U1
N8 boss scheduler over the attack planner: option gates (angle, players, repeats, forbid_after, live-zone tags), a tokenless mode, a plan's own waiting role, plan memory control, the afloat fallback, the npc_schedule and plan_audit queries 🟡 N8a1 is built: whether an option may be chosen now is one function for the director's grant and the planner (crates/shards_npc/src/schedule.rs: Refusal, Inputs and their one builder inputs(), plan_notes(), Players and living_players for the director and npc.tokens_within_limit; planner.rs: refusal(), with feasible() as its is_none()). No content field and no component; every reference replay verifies unchanged. The action machine is asked where the old conjunction asked it, so a session reads the same definitions (the replay's content check). Tests in planner.rs: refusal_passes_exactly_what_the_old_rules_passed (20 000 seeded random options and states judged by refusal() and by the old conjunction, which the test keeps word for word: the same answer and the same definitions read), each_rule_refuses_by_its_name_and_the_first_in_order_is_named (each rule alone and every pair), the_machine_refuses_only_what_waiting_does_not_start, a_closed_option_reads_what_the_old_rules_read; in schedule.rs: inputs_reads_the_plan_the_attacks_in_flight_and_the_strike_notes. N8a2 is built: the option gates angle, players, max_repeats, forbid_after (content fields with neutral defaults, skipped when serialized; AttackPlanDef::memory() counts the repeat limits; validation with the tag typo check), target_angle, four new Refusal variants in their places, the npc_schedule query with both views (the dev view's pick reproduces the next draw), npc_state plan.repeats, and the engine rule npc.plan_sequence (PlanAudit, audit_presses; 28 engine rules). Tests: unit tests in def.rs, planner.rs (the rule table over twelve rules, repeats, forbid_after, players and angle windows), schedule.rs (target_angle), invariants.rs (the audit's control test); tests/npc/schedule.rs (repeats, angle, phase swap, the press-not-start rule, the draw over 50 seeds, report against planner, content reads); scenarios/boss_schedule.scenario with the reference replay tests/replays/boss_schedule.json, scenarios/stand/boss_schedule.scenario. schedule::Players and living_players count the standing players only (B5: neither Dead nor Downed), so a downed player neither raises the token limit nor passes a players gate. N8b is built: AttackPlanDef::tokenless (the NPC's grant is outside the director's count, limit, lowering, patience and token events; its own choice and press skip the target's budget and combinations; its strikes still space the others and its attacks in flight still count against them) and AttackPlanDef::wait (a waiting role of its own, no slot, kept while it holds a grant with nothing chosen, cleared by a press; the planner calls wait_in_role), the books of direct steps 1-4 (tokenless() read from the plan each time, no new state on any hashed component), audit_tokens leaving tokenless grants out, npc_state plan.tokenless and token.counted, npc_schedule tokenless and the chooses wording for grants (between decisions: waits in its role, no grant yet: tokenless, ..., tokens in use without tokenless grants). Tests: tests/npc/schedule.rs (a boss and two adds, both adds holding tokens while it attacks, the control without the mode, the books: no unused return, a lowered limit, a hot reload flipping the mode; no slot and the orbit moving by the role with and without a grant, a press clearing the role, the budget, a snapshot every 30 ticks, the tool texts), def.rs (round trip, wait validation); the scenario boss_schedule.scenario (the boss on tokenless plans among two skeletons) and its reference replay recorded again, stand/boss_schedule.scenario (the host holds the grant of an attack under way, a client sees token: null; the tokenless half is left open). N8c is built: shards_npc::memory (reset_plan, set_plan_cooldown, CooldownSet, the events PlanReset and PlanCooldownSet with their journal lines), the dev tools npc_plan_reset and npc_plan_cooldown in the developer menu's ai group. Tests: tests/npc/schedule.rs (a reset and its line, a reset letting the plan choose again what its history refused, at least and exactly, the errors and the client's refusal, the content reads with the dev tools called), tests/npc/warden.rs (a game's observer resets the warden home again after a leash), tests/sandbox/encounter.rs (the yard's pack wiped: walkers reset once on arrival, members placed home at once reset on the wipe), memory.rs (the counts as words); the scenario boss_schedule.scenario sets and clears a cooldown and resets the plan, and its reference replay is recorded again. N8e is built: shards_npc::audit (may_follow, follow_pairs with rest_scale and the chain judged both ways, plan_hits with times through chains, then and spawned objects, unreachable_options; an attack's danger includes what it spawns: a zone's windows, a projectile's flight and impact) and the dev query plan_audit (min_gap, short with a why, the movesets of the prefabs that fight by the plan when moveset is missing). Tests: tests/npc/audit.rs (8: the sequence rules, gaps counted by hand, a chain's smaller gap, the rest scale, hits through chains and a then loop, the query and its errors, the danger and the hits of bolts, pools and a summon, with the test content audit.*.ron), the sandbox's content.rs (1: the warden's plan). N8d is built: AttackOption::forbid_while and solo_forbid_while, AttackPlanDef::zone_margin (neutral defaults, validated: the tag typo check over the three tag lists, empty tags, the margin), Refusal::Live and LiveSolo after Players (fourteen rules), the system parameter LiveZones (own combat objects anywhere, any owner's zone near the target within the margin, what the other NPCs' attacks in flight lay at the target through Spawn with aim: AtTarget; read only for a plan that forbids a tag) in direct step 3, plan_attacks (its running list of attacks in flight carries the pressed input) and npc_schedule (live=[...] what-if, live in the answer); and npc.strike_spacing holds the later of two same-tick starts in AiId order to the rule. Tests: def.rs (1), planner.rs (1, the rule table over fourteen rules), invariants.rs (extended), tests/npc/live.rs (5); boss_schedule.scenario extended with a chilling puddle at the player's feet, its reference replay recorded again. Not built yet: the npc_state hint of design 8.2, the afloat fallback (N8f)
F7 air movement in the style of Half-Life: the locomotion option accel (AccelModel): Step (the default, left out of the written form, the controller's old code) or Projected(ground_accel, air_accel, air_speed_cap, friction, stop_speed, max_air_speed) with Half-Life's numbers in metres as the defaults; ground friction in closed form (exact exponential above the stop speed, a line below it, a crossing inside a tick split) then a push along the wished direction up to the wish speed; in the air no friction and a push toward the wish speed held to air_speed_cap with the step taken from the whole wish speed (strafing turns the body and adds speed, a bunny hop keeps it); max_air_speed is open question 3 (none: a strafe may pass the run speed; Some(m): the air pushes no higher, a faster take-off is kept); replaces the steering of the ground and of the air with input only, no new state in MotionState or LocomotionInput; move_info gives accel and speed; checked with the field named ✅ crates/shards_motion/src/controller/{accel,params,locomotion,mod}.rs, tools.rs, lib.rs; tests controller::accel (11), shards_motion/tests/motion/air_move.rs (11: the modifiers' rate overrides steer nothing under the model, the run-up and the stop by friction at 60, 120 and 240 ticks a second, a scripted strafe run at 30 to 240 within 3 cm and 2 cm/s, a turn that keeps its speed, a strafe with and without max_air_speed, a bunny hop against a landing that pays the friction, crouch, a slope, a lift, the tool and the content); the sandbox's air_viewer locomotion, air_runner prefab and air_move.scenario. Not in F7: the strafe's gain depends on the tick rate (the originals' frame-rate effect: stated in the manual with numbers, tuned at the game's rate); NPC brains and the navmesh planner do not know the model (they steer through Intent as always)
Ladders a climbable ladder as a level volume: VolumeKind::Ladder { face } (a level node's "volume": "ladder" with "face": [x, y, z], the side it is climbed from, in the node's space; checked with the property named), the locomotion options ladder_speed (0: the body does not climb), ladder_jump_speed (2.5) and ladder_by_look (off; Half-Life's pitch rule), all left out of the written form at their defaults, and MotionMode::Ladder: taking hold against something solid from the ground, a fall or the water and off an edge inside the volume, the climb with no gravity (in is up, away is down, the rest sideways), the walk off onto the floor at the top, the stand at the foot, the jump that lets go; the mode name and locomotion state ladder for animation sets, the describer's ladder ↑3.5m/s, the overlay colour ✅ crates/shards_motion/src/controller/locomotion.rs ("ladder"), mover.rs (ladder, floor_under), physics/world.rs (ladders_touching), shards_level/src/props.rs (read_ladder). The ladder is found again each tick from what the capsule touches, and a jump off one is remembered by the reflected marker LadderLetGo (registered, net_predicted, on a body that jumped off a ladder only) until the body stops pushing into the ladder: no resource or MotionState field was added, so no replay was recorded again and a body with no ladder_speed moves as it did to the bit (test a_body_with_no_ladder_speed_is_not_affected_by_a_ladder). Tests tests/motion/ladder.rs (17) and shards_level's a_ladder_is_a_volume_with_the_face_it_is_climbed_from. Not built: turning a face: Move body to the ladder, ladders in path_to and clearance, NPCs on ladders; no sandbox scenario or reference replay uses a ladder yet.
FU4a the source of a status buildup: StatusApplied.source: Option<AiId>, add_status_buildup_from, the resource StatusSource for on_apply ✅ The hit path passes the credited attacker. Test a_status_knows_who_built_it_up (event, hook, no source, explicit source), a_nested_status_hook_leaves_the_outer_source_alone, a_status_built_up_by_an_object_names_its_owner. No replay changes (a new event field and a new fn).
FU4b the target of a brain-driven NPC for spawned objects: AimTarget(Option<AiId>) in shards_action, read by target_of after Intent::target, mirrored by shards_npc's drive from the brain's target ✅ Test a_cast_with_an_at_target_spawn_lays_its_object_at_the_npcs_target (an NPC plan presses lay, a zone lands at its target, no lock_on, no Intent.target). The component is replay_ignored, so no replay changes.
FU4c a binding the medium refuses does not bind: context::resolve and FighterView::bound leave out a binding whose action the moveset's only_in refuses in the current motion mode ✅ Test a_binding_the_medium_refuses_falls_to_the_movesets_action (on the ground the light binds the finisher; in water nothing binds, the context shows no victim, the light starts the stroke). No reference replay changes.
FU4d a paired action aims at its victim, lock or not: run_machines and the prediction take the pair's victim (the binding's at the start, Pairing::victim while it runs) in place of the lock-on target for track, the assist and the sight check ✅ Test a_paired_run_aims_at_its_victim_not_at_the_lock (a lock on another foe: the blow lands on the victim, the body faces it; a plain swing still follows the lock). Changes gameplay only for a pair run with a lock on a foe that is not its victim; no reference replay does that.
FU4e the angle origin of a pair's candidate: PairSelect::angle_from: Facing | Intent (PairAngle, default Facing, unserialized at the default) ✅ Test a_pairs_angle_can_be_measured_from_what_the_fighter_means (facing away: the default and Intent with no lock or stick say no; the stick toward the foe, a lock on it, say yes; a lock the other way beats the stick). Content c_finisher_intent. No replay changes (the default is the old rule).
FU4f the journal word for a pair victim that dies of the pair's blow: (killed) (PairEnded::killed, PairEnded::describe), (lost) for a victim lost otherwise ✅ Tests a_victim_killed_by_something_else_during_the_pair_is_lost_not_killed, a_finisher_that_kills_its_victim_does_not_cleave_the_next_foe. The damage line of a killing blow keeps the nominal damage (-140 (hp 0)): see the CHANGELOG. No replay changes (PairKilled is replay_ignored).