Compare commits

..

66 Commits

Author SHA1 Message Date
chexit 6616d58a3e Resolution Scale: 100% is DLAA (1:1), monotonic; docs + test-dlss.bat
build / mod (push) Failing after 33s
Point horizon at b4c68a78b (the slider is monotonic: 100% renders 1:1 DLAA,
80% no longer renders larger than 100%). Update the scale docs and pin
test-dlss.bat to HORIZON_HD_SCALE=0.67 for the upscaling A/B (empty would now
be DLAA at the slider's 100%).

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-22 12:24:27 +03:00
chexit b8049674bb engine: the Resolution Scale slider drives HD render scale (DLSS included)
build / mod (push) Failing after 33s
Pin horizon to 4e441de6a (agent/resolution-scale): hd::scale_override used
to pin the HD world at 2/3 whenever DLSS was enabled and its SDK open, so
the Resolution Scale slider (50-200%) was ignored — pixel-identical image
and unchanged FPS at every step. Now the slider drives the world target and
the DLSS render size live, no restart: film quality, then HORIZON_HD_SCALE,
then the slider; with DLSS the render scale caps at the output (100% keeps
the 2/3 auto ratio, above 100% renders at the output — supersampling is
native TAAU's with DLSS off), without DLSS the slider applies as-is
including above 1. The jitter and motion globals match the new size on the
very frame it changes; the NGX context is kept while the render size fits
its dynamic-resolution range, and the histories reset on every scale
change. The #143 motion/jitter contract (MVJittered, render-pixel jitter,
MV scale [1,1]) is intact.

Verified on Mac (M5/Metal, no DLSS device): lib suite 1243 passed, new GPU
test the_world_target_follows_the_resolution_slider (50/100/200% target
sizes + live resize + hd_scale precedence), taau_gpu_smoke_still_surface_ab,
non-dlss build, and a Windows-gnu cross-check of the dlss-gated code against
the NGX v310.9.1 headers. DLSS evaluation awaits RTX.

Docs: DLSS-TESTING.md documents the scale semantic, the live-update
mechanism and the RTX verification checklist (slider changes the DLSS
render size + FPS, no shaking regression, context reuse, fallback logs);
HD-RENDERER.md's scale references follow the slider.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-22 12:05:45 +03:00
chexit 24f3485ebb save: assemble the air section with write! instead of += &format!
build / mod (push) Failing after 30s
Sim::air_text built the save text with `head += &format!(...)` per contact
and `line += &format!(...)` per relief run, and Drone::air_line did the same
for a route point. Each of those allocated a temporary String and re-copied
the whole growing buffer, so the cost was quadratic in the section's size.
The head is not covered by the fits check (only the drone/queue body is): up
to 8 relief grids of 40k run-length tokens each plus 4096 contact lines. On a
heavy raid the autosave's tick therefore exhausted its 300M fuel while
formatting — the crash was in Sim::air_text.

Format directly into the buffer now (std::fmt::Write, push_str, push), which
grows it amortized with no per-token temporary. Nothing else changes: the
format, every MAX_* bound and the byte-budget logic are untouched.

The output is byte-identical: the same air_text over a relief-heavy raid
state and over the 600-drone byte-bound state hashes and measures the same
before and after (64a1787d37047447, 894 and 747942 bytes).
2026-11-21 18:46:19 +03:00
chexit 5737b47dc5 record: thin track points on the caller's grid; extreme-load test; re-pin the stale budget stats
build / mod (push) Failing after 59s
The points budget first gated on (recording tick - first) % step, but a strike
carrier's samples fall on its flight-age grid, offset from the recording's
ticks — the gate skipped them (physical_strike_track_keeps_muzzle... failed).
Count the sampling calls per track instead (Track::due): at STEP it pushes
every call exactly as before, and the thinning doubles the interval without
touching the track's phase. Track::points_len exposes the count for diagnostics.

tests/ground_oom.rs gains the continuous extreme load (eight overlapping
40-Oreshnik waves, 1118 objects airborne at once — well past the crash's >200):
peak 26.3 MiB steady + 5.5 MiB rehash transient, the flight tracks thin to
step 16 (91k points, 2.3 MiB) under their 2 MiB budget, the journal and poses
stay within theirs, and the fight still resolves (157 intercepts). The radar
picture itself (11.5 MiB at 1118 airborne) scales with the sky — it is the
simulation's state, not a cache, and is ~3 MiB at the crash's >200 load.

The WASM budget fixture's final /airdef stats pin was stale at the base commit
already: it was measured on engine 8e711f969, and the base pins acfb379aa,
whose host answers shift the two late Smart raids (417/2463, 7 in the air).
Verified identical on the pristine base and on this branch — the memory bounds
do not move that fight; the tick-2102 checkpoint (184/325/2011) is unchanged.
Re-pinned to the measured string and updated BUDGET_ASSERTED_SHA256 so the
raid/snapshot assertions stay active. test-budgets: 283 steps ok, tick fuel
max 184.7M/300M, 0 failures.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 17:57:51 +03:00
chexit dc87c0b98a sim: bound the ground cache and the recording under the 64 MiB WASM budget
The fullscreen-map OOM (rust_oom in hashbrown reserve_rehash under
Ground::answer during a large raid): the mod's whole state shares one
64 MiB linear memory, and three consumers grew without an effective bound.

Measured on a native replica of the crash load (tests/ground_oom.rs: 64
complexes, six all-sides Oreshnik raids plus a smart raid over 10000 ticks,
304 objects airborne at once, a wide map query walk; render answers exactly
as the WASM host gives them): peak 45.5 MiB steady + 21.9 MiB rehash
transient = 67 MiB, over the cap. The bulk: kept replays 23.2 MiB (the scene
journal 4.6 MiB each, filled with per-radar track transitions), Ground.known
10.9 MiB (277k columns; the old sweep only ran above 300k and kept everything
younger than 2000 ticks, so a wide query pattern grew it without bound and
the next rehash doubled the table), the live recording 7.5 MiB, radar tracks
3.2 MiB.

Bounds, derived from the 64 MiB budget (Sim::memory reports each consumer):
- Ground.known: KNOWN_MAX 100_000 columns (~2.7 MiB steady, ~8.2 MiB through
  a rehash at 24 B + control byte per entry, 7/8 load). Over the cap the
  oldest answers go down to three quarters (a sweep is not every tick),
  ordered by (age, column) so the sweep is deterministic; heights past
  SWEEP_AGE go with them. Evicted columns are asked again when next needed —
  the cache is reconstructible, no target, frequency or precision is cut.
- Scene journal: MAX_SCENE_EVENTS 65_536 -> 24_576 (~1.7 MiB), and the track
  transitions (acquire/handoff/lock/lost — they grow with systems x contacts,
  the journal's bulk under a large raid) get their own 8_192 budget; beyond
  it the later ones are not recorded. Launches, fires and outcomes keep the
  rest of the journal; chains() already tolerates missing steps.
- Flight track points: MAX_TRACK_POINTS 2 MiB per recording; over it every
  other point is kept and the ticks between points double (Track::step, the
  #142 decimation pattern for the systems' poses). Replay readers use the
  track's own step.

Replica peak after: 24.5 MiB steady + 5.5 MiB transient = 30 MiB, under the
48 MiB headroom target; the fight resolves (376 intercepts, sky clears) and
the same seed replays the same ordered trace. The saturation checkpoint is
untouched (314 / 2022 / 184): its cache stays under the cap.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 17:55:54 +03:00
chexit 4dbe103f5b sim: account where the mod's memory goes (Sim::memory, per-cache bytes)
The fullscreen-map OOM (Ground::answer rehash under a large raid) needs a
measured breakdown, not a guess: Sim::memory estimates each consumer's
allocated capacity (hashbrown tables with their control bytes, vec capacities,
BTreeMap nodes) — Ground.known, WorldCache.secs and rays, the sim vectors and
radar tracks, the recording and kept replays, Intel/recon, routes, sites,
strikes, the raid plan. MemoryReport::rehash_headroom names the transient a
rehash adds (old + new table of the biggest map). Ground::known_len exposes the
column count the budget tests guard.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 17:55:54 +03:00
chexit dca35dc9a2 Point horizon at the 512 MiB mod-memory cap; re-baseline the budget final stats
build / mod (push) Failing after 30s
The larger memory cap shifts the heavy scenario's final stats slightly
(417/2463, fewer pending sections); deterministic across runs, fuel
failures still 0. The tick-2102 checkpoint is unchanged.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 17:53:20 +03:00
chexit 3a992e7369 Point horizon at the DLSS temporal-stability fix; document the RTX checks
build / mod (push) Failing after 31s
Engine agent/dlss-temporal-stability (a791e8439 -> acfb379aa):
- f536fa958 DLSS: declare the jittered motion vectors (MVJittered). The create flags left
  MVJittered unset, so NGX applied the jitter offset on top of the already-jittered motion
  buffer — the camera jitter counted twice, the severe shaking. Contract verified against the
  DLSS Programming Guide (31 March 2026) §3.6.1-3.6.3/§3.7.3/§3.8.1, nvsdk_ngx_defs.h and
  Streamline's dlssEntry.cpp (pixel-space vectors take MV.Scale 1.0; the {1/w,1/h} advice is
  Streamline's own constant, scaled back by its plugin).
- 26ee82398 Native TAA: a reactive mask for water (its own depth, binding 7; less history where
  the waves/glint animate fastest, faded to 96 blocks) + the wind-motion contract test.
- acfb379aa Wind-blown leaves and plants carry their own motion vectors (previous frame's wind
  time/strength in Globals.hd_motion.zw, terrain.wgsl wind_offset_at).

Verified on Mac (no RTX): horizon-client --lib 1242 passed / 0 failed; taau_gpu_smoke on Metal
(fixed decode at the spatial filter's error floor, phase spread 0.0029 vs legacy 0.0156); naga
validation + HLSL translation of every HD shader and terrain/entity; frame/global layouts;
deterministic jitter/reprojection fixtures; non-dlss binary build; clippy clean on the touched
files. NGX evaluation itself awaits RTX — docs/DLSS-TESTING.md has the verification steps and
three fallback variants (jitter sign/axes, Streamline-style scale, non-jittered conversion pass).

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 16:56:38 +03:00
chexit f7ec0a3373 Docs: battery variants deploy by remote or command, not the removed N-menu page
build / mod (push) Failing after 30s
Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 16:48:01 +03:00
chexit 4d7815834d Give each battery variant its own placeable remote
build / mod (push) Failing after 28s
Every catalog variant now has a `airdef:deploy_<id>` remote in `give` and
in the hotbar: deploy_radar_search, deploy_radar_track, deploy_radar_height,
deploy_s400_launcher and deploy_s500_launcher. The variant rows carry their
remote item in the generated catalog, and the inventory appends them after
the existing remotes so no ordinary remote changes slot.

Placing a remote now resolves the item back to its (kind, mode, role)
configuration and settles the system, the same path `/airdef deploy <key>`
already used. The base remotes keep deploying the ordinary integrated,
multifunction system; the radar remotes place Search/Engagement/Height
profiles, so radar_track gets fire authority and the others do not.

The N menu's battery-deploy page is removed entirely (button, page and its
handlers); variants remain available through `/airdef deploy` and now the
remotes. Items, icons (aliased to the unit silhouettes), lang entries and
generated assets are regenerated from the content catalog.

Checks: gen_catalog.py --check, gen_models.py --check, test_gen_assets (11),
airdef-mod lib 115 + integration suites, airdef-core 327, cargo build.
2026-11-21 16:44:23 +03:00
chexit b735458dd8 Point horizon at the DLSS colour filterable-texture fix (#124)
build / mod (push) Failing after 29s
Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 16:08:53 +03:00
chexit 74baf8b4e2 Document the libclang auto-install
build / mod (push) Failing after 29s
The zero-step Windows+RTX toolchain now also covers libclang: LLVM is no
longer a build prerequisite, the detected or downloaded directory is
passed as LIBCLANG_PATH, and the cache layout gains
.horizon-cache/libclang/<version>/. Manual override (winget install
LLVM.LLVM + LIBCLANG_PATH) and the Unable to find libclang troubleshooting
note remain.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 15:55:14 +03:00
chexit 67e8a19e2b Auto-install libclang for bindgen on Windows + NVIDIA RTX
The DLSS build failed on Windows at dlss_wgpu's bindgen step: libclang.dll
is neither in the DLSS SDK nor in the Vulkan headers. It is now part of the
same zero-manual toolchain.

Detection first, download last: an explicit LIBCLANG_PATH (directory with
libclang.dll or clang.dll) wins and disables auto-install; otherwise PATH,
Program Files\LLVM\bin (both Program Files roots) and LLVM shipped with
Visual Studio (vswhere -find VC\Tools\Llvm\x64\bin\libclang.dll) are
checked, then the cache.

When nothing is found, the NuGet package libclang.runtime.win-x64 is
downloaded (~34 MB, version from the flat-container index with pinned
23.1.5 fallback) and only runtimes/win-x64/native/libclang.dll (~89 MB) is
extracted to .horizon-cache/libclang/<version>/ behind the existing
staging + airdef-install.json marker pattern. The resolved directory is
passed to cargo as LIBCLANG_PATH.

libclang is resolved only when the DLSS SDK and Vulkan headers are already
available, so a missing SDK never triggers a useless download. Any
detection/download/extract failure warns and degrades to mods/TAAU, and
non-Windows/non-RTX still returns before any network access.

Tests cover PATH/Program Files/vswhere detection, explicit precedence,
numeric NuGet version choice and fallback, selective extraction and marker,
cache hit, damaged cache reinstall, package without the DLL, plan env
wiring and failure to mods-only.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 15:55:12 +03:00
chexit e61b2e8f64 Cover mixed explicit-env and auto-download DLSS resolution
build / mod (push) Failing after 29s
A valid DLSS_SDK must not block the Vulkan header auto-download, and vice
versa; assert that only the missing component is fetched.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 15:44:12 +03:00
chexit 97d97eb37c Keep a broken DLSS cache directory from failing the build
Scanning .horizon-cache/dlss-sdk is best-effort: a permissions error or a
missing directory now means "nothing cached" and the normal install path
runs, instead of an exception escaping before the mods fallback.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 15:43:48 +03:00
chexit 84e9d6ab60 Document the zero-step DLSS toolchain install
The quick-start build section no longer asks for an NVIDIA DLSS SDK or a
LunarG Vulkan SDK: `airdef.py all` downloads only the headers, static libs
and nvngx_dlss.dll it needs, caches them under .horizon-cache with a
version marker, and copies the fresh DLL beside horizon-client.exe. Keeps
the explicit DLSS_SDK/VULKAN_SDK override, the offline/failure fallback to
mods with native TAAU, and the remaining LLVM/clang build prerequisite.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 15:40:00 +03:00
chexit 88757d05f8 Auto-install the DLSS toolchain on Windows + NVIDIA RTX
`airdef.py game` no longer needs manual SDK setup. On Windows with an RTX
adapter, when neither DLSS_SDK nor VULKAN_SDK is set, it downloads only the
files dlss_wgpu reads:

- NVIDIA/DLSS at the newest stable v310.9.x tag (GitHub API; pinned v310.9.1
  when the API fails): include/*.h, both x64 static libs and the runtime
  rel/nvngx_dlss.dll (~67 MB once), laid out under
  .horizon-cache/dlss-sdk/<tag>/ exactly as valid_dlss_sdk expects.
- KhronosGroup/Vulkan-Headers include/ under
  .horizon-cache/vulkan-headers/<tag>/Include/, since build.rs uses headers
  only and links no Vulkan library.

The resolved roots are passed to cargo as DLSS_SDK/VULKAN_SDK, and after a
successful dlss build the fresh nvngx_dlss.dll is copied beside the built
horizon-client.exe. Explicit DLSS_SDK/VULKAN_SDK (and the sdk argument)
keep priority and disable auto-download for that component. Any network or
layout failure warns and falls back to --features mods/native TAAU instead
of failing the build; non-Windows and non-RTX take the old mods path with
no network access.

valid_dlss_sdk now looks for the real nvsdk_ngx*.h names instead of the
nonexistent nvngx*.h glob, so a genuine SDK (and the downloaded cache) is
recognised at all.

Tests cover tag selection and fallback, selective layout + marker cache
hit, damaged/partial caches, streamed download and truncation, Vulkan
Include layout, plan env wiring, explicit-env precedence, failure to mods,
and DLL placement beside the client.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 15:39:56 +03:00
chexit 8d716eccaf Point the DLSS build hint at the mod settings toggle
build / mod (push) Failing after 30s
The build auto-detect hint still said HORIZON_DLSS=1 enables the backend;
the player-facing control is now the mod settings toggle (default on),
with HORIZON_DLSS=1|0 as an override.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 15:08:03 +03:00
chexit e85e7a18d0 DLSS on/off toggle in the mod settings, persisted per world
The More page (N → Огонь, ремонт, эффекты…) gains a DLSS row next to
Акустика. Default on: a world without a saved choice leaves the engine's
own default (on where supported). The row reads render.dlss-status (API
level 33): with a DLSS device it toggles live; without one it says
«недоступен», and an on-request is kept and applied at the next launch —
a graceful no-op, never an error. The request is saved in the world's
layout (`dlss true|false`, older saves load unchanged) and re-applied on
world load; the engine persists it in horizon-graphics.txt for the next
start's device opening. /airdef capabilities reports the DLSS state too.

Graphics-only: no resolution control (the player's own Horizon settings
stay in charge) and no sim changes. Engine gitlink → b2cc11c45
(agent/dlss-toggle): the dlss graphics setting, the live evaluation gate,
the dlss control command and the level-33 SDK imports.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 15:06:25 +03:00
chexit 11238c4a03 Add dlss to the game build on Windows + NVIDIA RTX with the SDK
build / mod (push) Failing after 29s
tools/airdef.py game always built with --features mods, so an RTX user had
to run the manual cargo line from docs/DLSS-TESTING.md. The feature string
now comes from dlss_build_features(): dlss is added only when the OS is
Windows, a Win32_VideoController name has both NVIDIA and RTX, the DLSS SDK
has include/nvngx*.h and lib/Windows_x86_64/x64 (DLSS_SDK, a repo DLSS/ dir
or %ProgramFiles%\NVIDIA\DLSS), and VULKAN_SDK has Include/vulkan/vulkan.h
(dlss_wgpu's build script needs both SDKs). Otherwise the build stays
mods-only; on Windows + RTX without the SDK it prints how to get v310.9.1
instead of failing. GPU/SDK probe errors mean "no DLSS" and never abort the
build; the HORIZON_DLSS runtime switch is untouched.

Tests: tools/test_airdef_build.py covers non-Windows, no RTX, missing DLSS
SDK, missing Vulkan SDK, the full toolchain, a failed GPU probe, the SDK
layout check and the feature string reaching cargo. python3 tools/airdef.py
game still builds mods-only on macOS (fresh target dir: 3m11s, exit 0).

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 14:21:20 +03:00
chexit d8d9913770 Issue #126 point 4: same-tick A/B parity and timing record
build / mod (push) Failing after 29s
The temporary in-session shader switch (harness build, reverted) renders the
same frozen tick with both effects.wgsl versions: old-vs-new differs by at
most 1-2/255, no pixel over 5/255, and no more than two frames of the same
shader differ. Frame time is below the in-game noise floor on M5 (32
screen-filling late-life fireballs: +0.37 ms median, sigma 3.6). Includes
the hd_bench polygon_noon run and test counts.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 13:51:13 +03:00
chexit 8fb849f195 Skip the fireball raymarch when its fade is zero (#126 point 4)
In the HD smoke path fade = 1 - smoothstep(0.08, 0.28, k) is exactly 0
from k = 0.28: every step's density is zero, absorb is 0, so the march
adds no light and leaves transmittance alone while still sampling fbm
and shading the volume. Wrap the loop in an `if fade > 0.0` guard; the
glow after it is untouched (heat is still live there) and is itself
skipped once its heat is spent. Density, steps, sampling and lighting
are unchanged.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 13:51:13 +03:00
chexit 1a82742744 CPU timeline profile of the battle frame (#147 step 3.1, #126 D/E)
build / mod (push) Failing after 28s
Measure-first profile naming the culprit with data; no worker implemented
(step 3.2 is out of scope). docs/measurements/issue-147-cpu-profile/: README +
report-server.json (default server-thread path) + report-inframe.json
(--in-frame control), M5/Metal 2560x1440 HD, same-recording battle with
overlapping raids + explosions + dense smoke, each run serialized under the
shared flock /tmp/airdef-bench.lock (earlier concurrent runs discarded).

Instrumentation: host per-tick tick_mods spans (ground/world/snapshot/wasm/
models/output/total, HORIZON_MOD_CPU_PROFILE=1, attributed by tick+frame),
mod Sim::step phase timing via an adapter-injected monotonic clock
(game.monotonic-nanos, API level 32; airdef-core stays SDK-free), raid_bench
--scheduler + per-frame span/frame correlation + mod phase delta.

Findings: on the default path the battle frame is GPU-bound (GPU avg 73.7ms ~
frame p95 88ms; 127/128 frames >33ms); the mod path is ~2.5ms/tick, per-frame
p99 7.7ms, 0 frames >25ms, host world answers <0.1ms, model prep ~0.05ms; the
872ms CPU spike is a render/GPU hitch (mod 2.15ms). In-frame is CPU-bound
(CPU p99 175ms); the mod path reaches >25ms in 27 frames, and step_drones
dominates Sim::step (52%, max 47ms/tick), A* only 15%. The schedulers' mod
peaks do not coincide; only the render-dominated catch-up spike is common.

Recommendation: a pure A* route worker and a world-snapshot worker are NOT
justified (A* leads only the tiny default-path mod; world answers never lead).
Default-path peaks are GPU -> steps 1-2 (GPU/geometry) apply, a CPU worker
would not help. If targeting in-frame CPU, the unit is the whole Sim::step
(Wasmtime on its own thread), not a route worker — still not implemented.

Harness fix (engine gitlink 48eff0fcb): control-socket chat/chat-log now reach
the client mod on the server-thread path (chat-box parity), enabling the
required default-path battle measurement; sim rules untouched.

Tests: airdef-core 326 passed/0 failed/8 ignored; airdef-mod 113+1+2+5 passed
incl. same_seed_same_result and combat_trace_is_deterministic;
tools/test_raid_bench.py 11 passed; horizon-mods suite + wasm ABI test ok.

Engine: d073783f5 (spans + clock) + 48eff0fcb (chat harness) on
agent/126-cpu-profile. Parent: 92c058f60 (profiler + driver) + this commit.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 13:35:32 +03:00
chexit 92c058f606 Sim::step phase timing and the CPU-profile bench driver (#147 step 3.1)
Mod side: Sim::step times plan_step, adapt, step_drones, step_moves,
update_sight, step_sams and record, plus the whole step and its untimed
remainder, through sim::profile. The simulation stays SDK-independent (also
built as airdef-core): the adapter installs the host monotonic clock
(game.monotonic-nanos) in init, native tests use std::time::Instant. The
counters are fixed-size, per-thread, read no randomness and change no
decision; /airdef stats reports them as PROFILE chat lines, reset per world.

Driver: raid_bench gains --scheduler in-frame|server-thread (the two
single-player paths, measured separately), HORIZON_MOD_CPU_PROFILE=1, the
per-tick mod-path spans joined to the frame trace (per-frame totals, >25/33 ms
counts, what the worst CPU frames carry), and the mod phase profile read at
idle and battle end with the battle delta. report.json carries mod_cpu,
mod_cpu_ticks, mod_phases_* and the derived correlation. Tests for the new
helpers.

Engine gitlink: mod-path CPU spans + game.monotonic-nanos (API level 32).

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 12:29:22 +03:00
chexit c08b737296 Reproducible raid/replay render bench and #147 instancing measurements
build / mod (push) Failing after 32s
tools/raid_bench.py (+ tests): the #147 step-0 driver replaces the #126
scratch script. One battle at fixed ticks (waves inside resident terrain —
far waves stall at the unknown-chunk edge and no fight happens), fingerprint
chat lines at control ticks, then the raid's own recording replayed. Both
render paths are benched on the SAME recording in ONE process via the
engine's diagnostic `model-instancing off|on` toggle (cross-process battles
diverge in event timing: 16 vs 32 kills at one control tick), pairs in
alternating order; idle cold/warm, mid-battle window, reload (F3+T), replay
seek, away-camera checks, and static off/on stills for pixel parity
(hd_bench motion-mask methodology). report.json carries gitlinks, device,
mod_models counters, CPU/GPU p50/p95/p99/max, raw frame times, >25/33 ms
frame counts, guest fuel and streaming queues.

Engine gitlink: one mass mod-model group GPU-instanced (retained mesh per
pack generation, current/previous pose/id/light instance stream shared by
main, motion and shadow passes, per-vertex fallback to parity, runtime
diagnostic toggle, stats raw + guest fuel reporting).

Measurements: docs/measurements/issue-147-instancing/ (M5/Metal, 2560x1440;
RTX 3060 pending). docs/REPO-MAP.md and docs/ENGINE.md pin updated.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 11:39:43 +03:00
chexit 32748b116c Smart v2 on top of #146: one public picture, mark prices, bounded refresh, bearing window (#149)
build / mod (push) Failing after 30s
Re-applied the genuinely new #149 features onto kimi-work, REUSING the already-integrated
#146 infrastructure (KnowledgeSnapshot { tick, contacts, marks }, knowledge_now(),
Plan.knowledge, RouteJob.known, versioned price_grid_known and restore). No #146 scaffolding
is duplicated: one snapshot per order, prices over known.tick, versioned restore are kept
exactly as they were. The only additive change to KnowledgeSnapshot is observations().

New #149 layer:
- observe::Observation + observe::merge: Contact and Mark become one public hint, matched by
  public features only (area overlap + exact category); coarse Unknown/contradicting marks stay
  separate, the contact's kind/fix are never rewritten, recon.truth and real ids are not used.
  One Observation::rank scale replaces the two ranks in radar_strikes, choose_target and the
  adaptive picks (kimi-work's slice signatures kept).
- price_grid_known prices marks: a trusted launcher/gun/jammer mark prices its published
  category envelope weighted by confidence (Confirmed x1, Probable x0.5); a radar mark feeds
  the network belief; a mark matched to a contact is priced once through the contact; a
  doubtful mark prices nothing.
- Bounded refresh of the unreleased portion: ew::Refresh with absolute deadline
  REFRESH_WINDOW=600; step_refresh re-aims queued Plan/Sead drones once on a report (typed
  Intent::Refresh, SEAD priority) within SWITCH_CAP and assignment budgets; no report never
  delays a launch.
- Bearing window: Intel.outcomes bounded VecDeque (48 entries, 12000-tick window); best_bearing
  adapts exploration share by typed BearingReason (few/stale/conditions-changed/exploiting);
  conditions are a fingerprint of the public picture, never hidden state. bearing_report() and
  bearing/refresh_*/observations fields in EnemyPictureReport. Legacy fixed share kept.
- examples/smart_bench runner (simple/current/candidate, seeds 1/7/42, open/hills/config-change/
  recon-lost, JSON+lines); Sim::smart_legacy reproduces current Smart; harness::run_with_hook.
  Light modes and bounded jobs unchanged; policy reads no health/charges/hidden switches/positions.

Tests: smart_tests + observe::tests (metamorphic hidden-layout, public dedup, marks in prices,
one version per order in both modes, bounded refresh fires-once/never-pauses, bearing window and
reasons, durable window + Intent::Refresh). The relief-version regression fixture's wall is
widened in z so it crosses any east-west route after the candidate's assignment-order change.
cargo test passes: airdef-core 326 lib + 8 scenarios; airdef-mod 113 lib + core_boundary + 5 scenarios.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 10:57:04 +03:00
chexit b796a439df Restore the saturated intercept count by uncueing the embedded radar (#145)
build / mod (push) Failing after 31s
The heavy WASM scenario (wasm_flat_budget, 64 integrated complexes vs two
`airdef wave oreshnik 40 2600`) lost intercepts at the tick-2102 checkpoint:
522 (main) -> 302 (#133) -> 243 (#134). Decomposed by A/B on one fixture, one
host (2bcce64), one SDK, each slice built from its own commit:

- 522 -> 302 (#133): Track.vel became an estimate from noisy measured places
  (it was the target's true velocity); the forecast, the aim lead and the
  interceptor's launch Fix all read it. Forcing the class estimate to Unknown
  leaves the count unchanged (native 296 ~= 294), so class/roles is not the
  cause. The pre-#133 522 used the target's true velocity, which the #133
  contract "class and speed only from measurements" forbids; this portion is
  the intentional cost of honest measurement-only tracks and is kept.

- 302 -> 243 (#134): the network cue was extended from the separate engagement
  radar to every fire-quality radar, including each weapon's embedded radar.
  Cueing every relayed contact each tick flooded the embedded fire control with
  one-tick plots whose noisy velocity degraded guidance. Restricting the cue
  back to separate radars recovers the whole drop: 243 -> 325.

- own_fire_within / FIRE_QUALITY / channels are NOT causes here: relaxing the
  own-fire gate or the channel limit each changed nothing (243 -> 243). Embedded
  radars always measure Fire plots of quality >= 64 and have no channel limit.

- #140 does not affect this loadout, by fact: the fixture deploys no separate
  radar, so every profile is embedded with channels = 0; the channel-age bug
  binds only where a profile has channels, and the channels-off A/B was flat.

Fix: the cue looks only through a separate fire-quality radar
(sam.kind == SamKind::Radar); the embedded radar keeps its beam/revisit/lock
acquisition as before #134. All radar profiles, channel limits, own-fire
authority and the measurement-only class/speed contract are preserved; no
target truth is injected.

Measured after the fix (WASM, fuel budget 300M/tick): checkpoint 325 intercepts
/ 2011 hits, fuel max 118M; final (tick 3302, two late Smart raids) 385 / 2472,
fuel max 176M; zero fuel failures. The first late raid reports the #135 recon
flight ("Разведка противника: впереди налёта высланы разведчики"); the second
is silent (recon budget spent) — the fixture now expects exactly that instead
of the stale empty chat that stopped the scenario.

Tests:
- airdef-mod/tests/saturation.rs: deterministic native replica of the checkpoint
  (same sim, host block tracer) asserting the restored count and a regression
  threshold, plus the #140 loadout fact (no separate radar, channels = 0).
- Sim::launch_audit (why.rs): on-demand tolerance diagnostic counting why each
  (system, drone) pair holds fire — no track / stale / no authority / role /
  doctrine / reach / claimed / not ready / not aimed / terrain / ready.
- sensor_tests: a network plot cues a separate fire radar but not the embedded one.
- wasm_flat_budget baselines re-measured with provenance comments; the asserted
  fixture SHA in tools/airdef.py updated.

Verification: `python3 tools/airdef.py test-budgets` passes both stages and the
two late raids (283 steps, fuel failures = 0). airdef-core 292 + 8, mod lib 104,
mod scenarios 5, saturation 2 — all green. A/B record:
docs/measurements/issue-145-intercept-regression.json.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>

Integration note (shipped engine 8e711f969): the tick-2102 checkpoint baseline is
unchanged and passes on the shipped engine (325 intercepts / 2011 hits). The final
stats baseline was re-measured on the shipped engine with #146 integrated (one
knowledge snapshot per Smart order changes the two late raids): 414 / 2463, world
8885 sections / 420671 rays / 3442845 cells. The asserted fixture SHA in
tools/airdef.py was updated to match. python3 tools/airdef.py test-budgets passes
all 283 steps with zero fuel failures (tick max 184608537 / 300000000).
2026-11-21 10:32:11 +03:00
chexit c76f620642 Point horizon at the TAAU motion-buffer jitter fix (#143)
build / mod (push) Failing after 28s
Engine a3045b61b: the motion buffer's coordinate contract is explicit and
decoded per history grid — native TAAU's stable history no longer receives
the two frames' jitter difference (a still surface reads the same output
pixel on every phase), 1:1 TAA keeps the correction its jittered history
needs, and the NGX input and flags are untouched for separate verification
on the DLSS path (#137). Numerical reprojection tests on all jitter phases
plus an ignored GPU A/B smoke on the real fs_taau.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 10:09:12 +03:00
chexit 63ebd4ac6c Plan one Smart order on one knowledge snapshot (#146)
build / mod (push) Failing after 25s
order_raid read one picture and one list of recon marks for the whole
order, but the Plan kept neither: plan_step priced each kind's first
route on whatever picture_of_defences() held at the tick the budget
reached that kind, so one raid could hold several versions of the map
at once. A retarget job carried its version's contacts, yet
price_grid_known aged them at self.tick, so two jobs of one version
reached on different ticks could disagree about a contact's own sensor.

KnowledgeSnapshot fixes the observation tick together with the contacts
and marks read at it. The plan stores the order's snapshot and passes it
explicitly to price_grid_on/price_grid_known; radar_strikes takes the
order's marks instead of re-reading the recon memory. A retarget job
shares its adaptive tick's snapshot and prices age at the snapshot's
tick, never at the current one: current time still cancels a stale job
(prune_air, job_live), separately from the version's own arithmetic, and
an explicitly new retarget gets a new snapshot and may use a fresh
report. The save rebuilds each version's snapshot from the contacts and
the marks reported by it; the section format is unchanged. Nothing here
reads the force: only published kinds and the contacts' own observations.

SDK-free regressions: a Smart order of two kinds whose land answers
starve while a visible contact is disclosed mid-wait keeps every kind's
targets and routes on the order's snapshot (and differs from an order
that knew the contact from the start); two jobs of one version worked
out across the emission-belief boundary price the same world, a new
version with a fresh report believes again, and a new version without
one does not.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:54:47 +03:00
chexit f2bc8550f5 Tie a radar's refine/fire channel to its own plot's freshness (#140)
build / mod (push) Failing after 28s
A station counted any own plot, however old, as a busy refine/fire
channel: a network heartbeat kept a stale contact's track fresh, so two
long-expired own fire plots still held both channels of the engagement
radar and a new contact nearby got only a coarse search plot, even with
the search radar running.

Channel occupancy now follows the station's own tracking.
Track::holds_channel requires an own (never relayed) refine/fire plot no
older than the station's track_ttl — three missed turns, the same value
that already bounds a contact without a fresh measurement. The planner
counts channels with the same Sam::own_channels_used(now) the panel,
monitor, map and "why" views read, so the UI and the allocation cannot
disagree about a stale channel. A stale channel frees for a new contact
without the network's survey track being removed; the hard per-profile
limit and the own measurement's provenance are unchanged, and a relayed
plot still never holds a channel.

Test: two contacts take both channels at the station, then leave its
reach while the search radar beside them keeps relaying them; a third
contact arrives nearby and gets its own fire channel (the test fails on
the old counting), and the relayed survey tracks of the old contacts
stay.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:53:43 +03:00
chexit 5f00a2a16b Read replay events by their time ranges, not the whole journal (#150)
The replay's sounds, the raid map's counts and the struck objects now read
the recording's event and scene journals by time instead of every pass over
the whole journal: partition points over the journals (with a stable time
index built at close only when a journal is out of order), the map's kill
and hit prefix indices, each object's first hit, and marker/time-line paths
that stop at the map's shape cap. Blasts, smoke, debris and the fire replay
read bounded windows back from the moment.

The sets, order and names stay exactly as they were: tests compare every
reader against the full journal filter, including tied times, out-of-order
journals and arbitrary forward and back seeks. The replay_bench example
measures a 10-minute raid with nearly full journals (playback, reverse seek,
pause, MP4); its result is docs/measurements/issue-150-replay-ranges.json.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:52:20 +03:00
chexit 7f52c40d99 Bump horizon to the DLSS command-order and history fix (#137)
build / mod (push) Failing after 21s
Engine 1cadd6338: the DLSS frame now submits world+linearize -> NGX ->
delinearize -> film/tonemap/UI/capture/present in one queue.submit with no
CPU sync, so the final frame, screenshot and export read the current
resolved frame instead of the previous one. Native TAA history readiness
is tracked separately from NGX, so the first fallback frame after DLSS
does not blend a stale or empty native history; a cut/resize clears both.

HD-RENDERER.md records the corrected order and the history separation.

Real-RTX acceptance (docs/DLSS-TESTING.md) is still pending: no RTX is
available here, so this is verified by the ordering/history unit tests and
the native horizon-client + horizon-mods suites, not a DLSS GPU capture.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:45:20 +03:00
chexit 8afe691301 Add typed battle reasons and short engagement chains (#148)
build / mod (push) Failing after 32s
A battery's "why" now starts with one typed reason shared by the monitor,
the HUD and the chat: only observation, waiting for a track, busy channels,
no ammunition, or ready. It carries the age and the station of the mark it
is about, and `/airdef why <n> source` moves the monitor to that station.
The reason is computed from the same predicates the launch decision uses,
and the detailed decision settles it, so a headline cannot promise or deny
a shot the simulation does not take.

The after-action review builds 4-5 measured steps per contact from the
recording's scene journal and events: mark, handoff, lock, launch, outcome.
The menu lists them per battery with a filter and opens a replay frame on
a click (the outcome clip, else the map held at the launch or mark);
`/airdef chains [battery]` prints the same list. Missing transitions stay
missing and marked as no launch, never guessed, and the normal HUD still
shows only the battery's own picture.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:42:10 +03:00
chexit bd2d8f4fed Release an unreachable optical contact and serve ready posts fairly (#138)
build / mod (push) Failing after 22s
An automatic optical contact is kept only within the optics' own reach and let go after a few failed probes. It stays out of the next picks for a while, so a visible alternative can be tried without constant switching; unknown world geometry gets a longer, still bounded wait. A player's command still waits for its contact and says so in the status line.

Ready posts are now served oldest-probe first through a simulation-wide probe sequence, so posts whose phases coincide all advance under the unchanged CHECKS_PER_TICK budget.

Tests: an out-of-range contact with a visible alternative, a blocked contact with a visible alternative, five same-phase posts, the bounded unknown-geometry wait, and the manual pin's status and out-of-reach behaviour.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:27:02 +03:00
chexit 41ab52e802 Keep replay transitions through the SAM pose decimation (#142)
build / mod (push) Failing after 36s
Sampling slowed by the pose budget skipped whole short stages: the six-tick
tube cover opening, the ejection and the radar switch fell between samples,
and thinning then halved already recorded transitions along with poses.

Poses still share the adaptive sam_step grid and the unchanged 32768-key
budget, but the recording is now sampled every tick for facts: a discrete
change (spent_cells, cap_cell, radar_on, mode, role) and every frame of the
cover's own movement are kept on the tick they happen, with the stage's start
backdated one tick so the opening still spans exactly OPEN_TICKS. These keys
carry an event mark and decimation halves poses only, keeping events, the
first and the last key.

Events get their own explicit 4096-key budget instead of raising the pose
budget: when it runs out the oldest stop being critical and thin as poses
while the newest stay exact.

Test: 64 turning radars plus an S-400 at sam_step 16, ejection on tick 4103
(cover 0.8333333 a tick before, spent cell on the ejection tick), a cancelled
opening and a radar switch off the pose grid, all surviving further thinning;
a 64-radar chattering recording stays exactly at the event budget with the
newest switch exact.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:23:41 +03:00
chexit 433e1500e2 Do not treat a cooling jammer as an active emitter (#139)
build / mod (push) Failing after 37s
Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:20:46 +03:00
chexit 01765027b1 Fix the recon picture's wrecks and its emission sources (#139)
build / mod (push) Failing after 29s
A look no longer reports a wreck as a lead: a first look at one makes no
mark, and one the picture already held is radioed home as destroyed and
takes its mark out of the picture. A hidden kill still never rewrites a
mark, so the old assessment stands until its age runs out.

The channel now follows actual work, not a switch: a radar emits only
while radar_up, a jammer only while its transmitter is on the air. A
silent, packed, failed or destroyed station is just a unit the flyby saw.

A pending wreck observation is durable; older saves without its flag read
as before, every look being of a unit alive when it was seen.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 09:12:35 +03:00
chexit 24b8cce11b Update the WASM contract for radars configured at deployment (#144)
build / mod (push) Failing after 1m21s
The real-.hmod scenario still expected the pre-#134 role switch to
retune radar 4 and return its role as feedback. After #134 the profile
is chosen at deployment and dispatch refuses the old syntax, so step 14
failed with no feedback.

Both stale checks now expect the intended refusal, naming
deploy radar_search|radar_track|radar_height and on/off. The deployed
station is not transformed back for the test.

Verified with python3 tools/airdef.py test-wasm on the pinned host
2bcce64236 and the real airdef.hmod: 30 steps pass.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 08:57:53 +03:00
chexit 502d94c528 Spend the world overlay's marker budget on targets in frame (#141)
The overlay clipped the network's tracks to the nearest 64 by distance
before projecting them, and the truth and interceptor layers the same way.
A crowd behind the camera filled the budget, so a raid could show nothing
even with a target right in front of the player; the native reproduction
(one contact ahead, 64 behind) came out with zero markers and a header
saying all 65 were out of frame.

Now visibility comes before the draw budget. Each layer orders its
candidates nearest first, projects at most MAX_SCAN = 4 x MAX_MARKERS of
them (bounded work, no sort of the whole picture beyond that prefix), skips
those the frame does not hold without spending a marker, and draws the
nearest MAX_MARKERS visible ones. Each layer keeps its own draw budget, so
the interceptors and the truth markers cannot crowd out the network's.

The header separates the two ways a target stays unmarked: "за кадром"
(behind the camera or past an edge) and "сверх бюджета" (past the scan or
draw budget), alongside "в кадре".

Regression tests: 64 behind plus one ahead for the network, truth and
interceptor layers; a mixed crowd proving the nearest visible keep the
markers and the farthest is budget-capped, not offscreen; the projection
count bounded by MAX_SCAN; every case stays inside the HUD's 1024 shapes.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 08:57:53 +03:00
chexit a983177d34 Draw a held-key world overlay of targets through the drawn camera (#132)
build / mod (push) Failing after 59s
Holding C draws square markers over the targets the player can see, each
with the class the radars estimated and the distance; an unidentified
track stays a "?", never the target's type. Stale forecast tracks fade
orange and say their age, the player's own interceptors wear small yellow
squares, and the sandbox truth mode adds white markers of the real drones
apart from the network's estimates. Letting the key go clears the HUD.

The markers project through the camera of the last drawn frame
(render.project, API 31), so they sit on the world as it is drawn and
follow the view frame by frame; the overlay stays off under a replay, the
grid J, the monitor K and the map M, which own the screen themselves. A
full raid stays inside the HUD's 1024-shape budget, keeping the nearest
markers and counting the rest behind the camera or past the edges.

Bump the engine pin to 2bcce6423 (API 31, render.project) and name API 31
in the capabilities diagnostic to match.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 00:39:17 +03:00
chexit 795b1b2fcf Merge recon flights and partial reports into the classified radar picture (#135)
build / mod (push) Failing after 1m5s
Co-Authored-By: Kimi Code <noreply@moonshot.ai>

# Conflicts:
#	airdef-mod/src/sim/mod.rs
2026-11-21 00:07:39 +03:00
chexit c4e002ed8b Add the recon UI and diagnostic layer to the smart enemy (#135)
The core recon flights and partial reports (9d8f3da57) had no player-facing
or diagnostic consumer: enemy_picture().recon/recon_sorties were read only by
core tests. This adds the missing layer on top, without touching the mechanics,
models or textures.

- Map: a tracked recon aircraft is a recognisable yellow hollow diamond with a
  "разведчик" label, a role line in the selection panel and a filter legend; in
  the sandbox truth mode it gets an amber marker of its own.
- Battle UI: the summary panel and the map show the flight's coarse phase
  (разведка → донесение → завершение) only while the player's network actually
  holds a recon aircraft — what the visible aircraft are doing, not what the
  enemy learned. The truth mode adds a recon count line.
- Diagnostics and after-action review: /airdef recon and the menu page
  "Разведка противника (разбор)" (from Main and Replays) list the enemy's marks
  best-first with the reason each outranks the rest — priority = freshness×4 +
  quality×3 + observed role (recon::priority_parts, cross-checked against
  Mark::priority by a test) — plus the sortie phases and the drones aimed at a
  mark. The omniscient enemy picture is never shown in the normal HUD; it is
  explicit debug/review only.

recon_view reads only the current report types (EnemyPictureReport, ReconReport,
ReconSortieReport); the sim side only widens visibility and adds priority_parts
and the is_recon_drone/recon_status read helpers. Tests: recon_view, panel,
command tree, priority_parts cross-check. README and IMPLEMENTATION-STATUS updated.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 23:59:45 +03:00
chexit 12a706fb67 Refine the network track's class from the optical look (#136)
build / mod (push) Failing after 1m25s
- ClassEst::step_optical: the shared estimate's rule for one passive look —
  an unsure look (over OPTICAL_CLASS_MAX_UNCERTAINTY) names nothing, a sure
  one names a class, firms an agreeing probable, replaces a contrary guess
- Track::refine_class_optical: the minimal common method — class only; the
  plot, age, source, quality and own fire rights stay untouched
- Sim::apply_optical_classes: the explicit adapter, fed by each observation
  made this tick through OpticalObservation::estimate; a relay of the
  refined track carries the class as it was and gains nothing from it
- the post still holds no track, emits nothing and authorizes no shot;
  the refined class reaches the existing #133 track UI through the picture
- tests: network refinement, unsure look, relay/stale look add no
  confidence, equal observables refine equal classes, the step rules

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 23:55:28 +03:00
chexit 8550de16f8 Finish the optical post's network cue and edge cases (#136)
- a radar's fresh track reaches a post as a cue only: it points the head
  but never enters the post's tracks, seen or own set
- a searching post's sector follows the turning head, not the fixed base
  heading; switching contacts drops the old contact's picture
- dead and blinded posts spend no probe budget and never observe
- the icon alias is part of the generator, so the placeholder item uses
  the radar texture without a duplicate PNG or a hand-written asset
- part diagnostics read "Опт" for a passive post's sensor
- tests: cue wiring, turning sector, contact switch, dead post, graphics
  preset; generator alias

Cherry-picked from 3697a1764aec7a7bdc6311918453dd51e26ecabf onto the
#132/#133/#134 base: the cue-wiring test's track literal now carries the
shared class/source/product/quality contract instead of a DroneKind.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 23:38:32 +03:00
chexit 245aceb434 Add recon flights and partial reports to the smart enemy (#135)
A smart raid may send a small, bounded flight of unarmed Gerbera aircraft
ahead of its strike. They fly physically through zones round the marked
objectives (and revisit a doubtful mark when nothing is unchecked), look
at units inside a zone, and radio home an area, a public category, the
channel, age and quality only after a delay and only while the aircraft
is alive. A sortie lost before its report sends nothing; marks already
delivered stay, and the picture remembers them across raids.

The planner now reads recon marks as well as disclosure contacts. A mark
carries a synthetic id, an area, a category and a radar role only once a
second independent look refines it -- never a real id, SamKind, exact
point, health, magazine or link. Aims are chosen by observed role,
freshness and quality; a fresh modest mark can outrank a stale doubtful
big one, and a hidden unit is in neither list. In-flight recon aims keep
their old area: hidden moves, re-roles and damage do not rewrite a mark.

Bounded assignments, the route-job queue, the original wave objectives
and the no-eternal-pause rule are preserved. Recon aircraft take ids from
their own range, do not spend the strike's combat RNG and are not part of
the strike's replay. Save/load keeps marks, sorties, pending reports and
checked zones. No new models, textures or weapons.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 23:36:00 +03:00
chexit e5ee15a2ca Add passive optical observation post (#136)
- new Optical unit kind with its own catalog row and deploy item
- bounded one-contact line-of-sight checks against land and blocks
- day/night reach and hold timing; obstacle and unknown geometry block sight
- independent class observation with source, time and uncertainty, never DroneKind
- map/monitor/panel statuses and a line to the selected contact
- tests: day/night, wall/unknown, ageing, no kind leak, bounded work, passivity

Cherry-picked from 3ae21123964a9d3234bb2b3efc9ff926d64fc77d onto the
#132/#133/#134 base: the cue test's track literal now carries the shared
class/source/product/quality contract instead of a DroneKind.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 23:33:32 +03:00
chexit 53fbeced22 Cover radar profiles over a ridge (#134)
build / mod (push) Failing after 28s
Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 23:13:38 +03:00
chexit e1b09f696f Give the two-raid scenario room for the last contact (#134)
The maximum menu raid keeps a supersonic contact in the air past 5000 ticks under the new fire-authority rules; the recording closes only when the sky is clear. Run the scenario to 8000 ticks, still well inside its 20-minute cap, and keep the replay assertion.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 23:13:32 +03:00
chexit 858735a4c6 Implement the first full radar-profile slice (#134)
Give the separate radar three real profiles over SamKind::Radar and the
typed catalog variants:

- radar_search: coarse, slow, long-range search plots; no fire authority.
- radar_height: raised mast, local refinement of low plots; no fire authority.
- radar_track: local search, fast revisit, two refined/fire channels.
- radar_multi remains the compatible universal profile, not best everywhere.

Tracks now carry the measuring station, product (search/refine/fire), and
quality (separate from identification), and keep the station's own plot when a
fresher network relay replaces the published position. A relay never refreshes
the measurement or authorizes a launch. Ordinary launches need the battery's
own confirmed fire plot; launcher-only batteries use a supporting radar's own
plot, and the existing heavy far shot keeps its cue-radar exception.

Per-tick refinement/fire work is bounded by profile channels and local search
radius. Off, damage, network and save/replay behavior are preserved: new saves
write the stable profile ID, old role-only lines migrate, and embedded SAM
radars keep their own fire authority. The deploy menu, status lines, map,
monitor, radar scope and /airdef why explain the profile, source, age, quality,
channels and refusal reason.

Models/textures are untouched: all profiles reuse the existing radar
silhouette (the separate art zone remains for its owner).

Tests: profile single/pair/full scenarios and duplicate station, channels,
relay source/age/quality, Off/damage, save migration, replay, embedded and
Multifunction radars, catalog/generator checks, airdef-mod suites, core lib
(non-balance on one thread; the four active balance tests in release) and core
scenarios.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 23:11:12 +03:00
chexit ac7521936d Estimate a track's class from its measurements, not from the target (#133)
build / mod (push) Failing after 1m18s
A radar track is what the network measured, and it never carried the
target's own answers: the tactical Track loses `kind: DroneKind` and the
true velocity, and gains what the measurements say instead.

- Track now holds a ClassEst (unknown / probable / firm) plus an observed
  velocity: none from the first blip, then the change of the measured
  places between real measurements, smoothed so one noisy pair does not
  flap the class. The classifier's bands sit between the game's speed
  clusters (Class::of_speed); a new contrary measurement replaces the
  hypothesis, an agreeing one firms it.
- The class estimate is separate from track confirmation (Track::ident):
  a track can be confirmed with its type still unknown. The estimate
  grows only on real measurements — a forecast and a relayed copy add
  nothing — and it travels with the measurement it grew from, ageing
  with the track and gone when the track drops.
- Roles, last chance, the reserve and the interceptor count read the
  estimate, never the target's class. Explicit policy for the unknown:
  an unidentified track stays a candidate under the general rules (and
  the system with no roles holds its fire at everything); the map, the
  monitor, the summary panel and /airdef why read the same estimate and
  name the reason — «Трек подтверждён · тип не определён», «вероятно
  крылатая ракета». The exact model stays in the sandbox's truth mode.
- A gun or a launcher lets go of a target that classified out of the
  roles since it was taken; a first blip no longer rules a contact out
  as a threat to guarded objects (it has no measured course yet).

Old saves and replays are untouched (tracks are derived, not persisted);
the simulation stays deterministic (the classifier is pure arithmetic on
the measurement noise). The doctrine/first-blip/last-chance tests gained
classified tracks where the contract provably changed; new tests cover
the classifier's steps, kind-independent estimates, first-blip blindness,
and relays and forecasts adding no confidence.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 22:55:36 +03:00
chexit 95739c95b1 Finish radar truth HUD layout and document target modes (#132)
build / mod (push) Failing after 33s
Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 22:08:46 +03:00
chexit d302204649 Make map and radar targets legible with an honest hover (#132)
- mini radar: class-shaped blips that merge into one with a count
- map: larger track markers and trails, hover card with distance, type,
  status, target and interception
- explicit network vs sandbox truth: true drones, routes and aims drawn
  apart from the network tracks, with their own trails

Co-Authored-By: Kimi Code <noreply@kimi.com>
2026-11-20 22:08:46 +03:00
chexit 1e2d5dd0c0 Record #126 first stage: retained mod-model meshes, measured
build / mod (push) Failing after 55s
Engine a861c1ed2 (kimi-work-124), based on ed751714e: mod-model faces resolved once per pack generation, frames only transform and light them; motion #124 from the same faces; counters and span; reload/unload invalidate the cache. HD-RENDERER status + section, and docs/measurements/issue-126-first-stage with the A/B method and numbers (M5/Metal, Polygon raid: entity_geometry CPU 5.71 -> 1.57 ms avg, prepare 23.5 -> 7.05 ms; static scene pixel-identical; reload/unload smoke). Not GPU instancing; 5600X/3060 acceptance pending. Issue #126 stays open.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 21:46:46 +03:00
chexit 80d0cc9c43 Add native wgpu ray-query capability probe (#125)
build / mod (push) Failing after 1m21s
Stage 1 of #125: prove or disprove real hardware ray-tracing support without
touching the client renderer. The probe pins the same wgpu 30.0.1 stack as the
engine, including its vendored third_party/wgpu-hal patch, builds one BLAS/TLAS
and traces a 16x16 ray-query compute frame, checking every ray against a CPU
point-in-triangle expectation.

Verified on macOS aarch64, Apple M5 / Metal: BLAS/TLAS and the ray-query
pipeline build, 32 hits and 224 misses all match, exit 0. RT_PROBE_BACKEND=gl
reports no RT adapter and exits 2; RT_PROBE_NO_OPTIN=1 shows request_device
rejects EXPERIMENTAL_RAY_QUERY without the experimental opt-in and exits 2.

tools/rt-probe/target/ is ignored; the probe is a standalone workspace and is
not wired into the game build.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 21:34:07 +03:00
chexit c59bfe9e54 Catalog typed battery variants (#91)
The battery deploy pieces (s400_launcher, s500_launcher, radar_search/
track/height) were described three times: the menu table and the
configuration match in lib.rs, and a chained id list in commands.rs. One
catalog decision instead: catalog/content.json gains a variants section
(mode/role reuse the existing SamMode/RadarRole save keys), gen_catalog.py
generates catalog::UnitVariant rows, and the loader rejects duplicates,
unknown kinds/modes and id collisions with kinds or items. The battery
menu, its click handler and the deploy completion read the generated
table; the historical row order and labels are unchanged.

No variant carries its own balance: per-variant ammo profiles stay open
pending a confirmed profile and an explicitly labelled game abstraction
(PAC-3 note on #91), so no new specs, no new matches and no save/replay
change - a variant is only a deploy key over the same kind.

Checks: gen_catalog.py --check and gen_models.py --check clean, the
python catalog/asset and sound tests pass, airdef-core 234 unit + 8
scenarios, airdef-mod 69 unit + 1 boundary + 5 scenarios (save/load and
state round trips included), zero failures.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 21:34:07 +03:00
chexit 306af49744 Move battery status text to the presentation adapter
Sam::status, Comps::describe/worst and Sam::parts_text formatted
player-facing Russian in the simulation. The adapter now owns that
text: battery_view::sam_status for the panel and map, why_view::parts
and why_view::worst for the monitor and the status line. The core keeps
the data and gains only the accessors the adapter needs
(preparing_cell, public cells/reload_time/magazine/gun facts).

Texts are unchanged; the adapter tests pin the existing strings.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-20 21:34:07 +03:00
chexit 60f1bf0fd8 Record the Windows DLSS acceptance build and remaining runtime check
Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-16 13:00:39 +03:00
chexit e194971867 Document Visual C++ runtime needed by the DLSS test build
Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-16 12:56:32 +03:00
chexit 7ae0c5bbba Add Windows DLSS A/B test launchers and acceptance guide (#124)
Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-16 12:55:10 +03:00
chexit 217e3ac886 Add feature-gated DLSS SR proof of concept (#124)
Advance to engine ed751714e. Document the optional SDK build, ordered color conversion/submission, native fallback and the remaining MSVC-link and RTX-runtime acceptance.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-14 22:10:32 +03:00
chexit f33b799551 Record previous-frame motion for mod models (#124)
Advance to engine 7a73e8d26: separate previous-position streams and a depth-read-only motion pass for mod models, with matching alpha cutouts and a debug view.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-14 21:06:02 +03:00
chexit d8cb98a964 Keep radar target blips above the player arrow
Draw the player marker before network tracks so a close blip is not hidden. Add a shape-order regression and verify a live raid with truth disabled.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-14 18:25:33 +03:00
chexit e59c49e3bf Blend HD shadow cascade filters at the near boundary
Advance to engine 17382445a and document the six-block near/far transition verified on the forest aerial view.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-14 18:04:24 +03:00
chexit 9664783b17 Add dense motion foundation for temporal upscaling (#124)
Advance to engine c962cd472. Document the render-pixel current-to-previous contract, native TAA/TAAU consumer and the remaining DLSS/object-motion/linear-HDR work.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-14 17:49:23 +03:00
chexit 3db1b73d64 Reuse oversized renderer staging buffers (#130)
Advance the engine to 94b572cd2, backporting upstream f7b77fbc8 with its GPU growth/readback regression. Keep API30 unchanged.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-14 17:27:17 +03:00
chexit 367c7f4ac3 Bound recorded SAM poses under the WASM memory cap (#122)
Thin old SAM keyframes in place, reduce allocation capacity and adapt later sampling when a recording exceeds its fixed pose budget. Preserve recent poses and cover the full ten-minute window in native and real WASM stress tests.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-14 17:21:48 +03:00
116 changed files with 65467 additions and 792 deletions
+1
View File
@@ -2,6 +2,7 @@ run-home/
.horizon-cache/ .horizon-cache/
airdef-mod/target/ airdef-mod/target/
airdef-core/target/ airdef-core/target/
tools/rt-probe/target/
__pycache__/ __pycache__/
/out/ /out/
.DS_Store .DS_Store
+55 -7
View File
@@ -96,7 +96,7 @@ CI: `.gitea/workflows/build.yml` на каждый пуш собирает то
**Сеть ПВО.** Единицы обмениваются измеренными треками в пределах игровой связи; повреждение связи **Сеть ПВО.** Единицы обмениваются измеренными треками в пределах игровой связи; повреждение связи
сокращает её дальность. Можно поставить несколько С-400/С-500 без собственной РЛС и общие радары сокращает её дальность. Можно поставить несколько С-400/С-500 без собственной РЛС и общие радары
поиска, сопровождения и мачтового обзора: N → «Разместить элементы батареи…». поиска, сопровождения и мачтового обзора — отдельными пультами (`/airdef give` выдаёт `deploy_radar_search`, `deploy_radar_track`, `deploy_radar_height`) или командой `/airdef deploy radar_search|radar_track|radar_height`.
Поисковый радар даёт подсказку; огневой должен сам измерить цель, прежде чем разрешить пуск. Поисковый радар даёт подсказку; огневой должен сам измерить цель, прежде чем разрешить пуск.
Старая сборная конфигурация сохранена. [Команды, источники и ограничения](docs/BATTERIES-AND-COLD-LAUNCH.md). Старая сборная конфигурация сохранена. [Команды, источники и ограничения](docs/BATTERIES-AND-COLD-LAUNCH.md).
P1-SUN также использует чужие данные. Пушкам (Гепард, P1-SUN также использует чужие данные. Пушкам (Гепард,
@@ -182,6 +182,22 @@ API мода `render.set-lights` (до 512, плавно интерполиру
самые занятые (стреляют, держат захват, сопровождают, горят), раз в 2 секунды; комплекс с монитора K — всегда. самые занятые (стреляют, держат захват, сопровождают, горят), раз в 2 секунды; комплекс с монитора K — всегда.
Повторное J закрывает. Повторное J закрывает.
**Тактическая карта:** клавиша **M** открывает общую карту. Цели обозначены крупными отметками с классом,
курсом и измеренной траекторией; наведение мыши показывает дистанцию, тип, состояние трека и перехват.
По умолчанию доступны только данные сети РЛС. **T** переключает явно подписанный режим «Истина» для
песочницы: в нём белые рамки показывают даже незамеченные аппараты, а жёлтый пунктир — их цель и будущий
маршрут. Этот режим не меняет боевую логику.
**Обзор целей поверх мира:** удерживай **C** — вокруг видимых целей появляются квадратные метки с краткой
строкой: класс, который оценили РЛС (неопознанная цель — «?», без утечки типа), и дистанция; устаревший
трек-прогноз оранжевый и помечен возрастом. Свои перехватчики — маленькие жёлтые квадраты. Это данные сети
РЛС, как на радаре и карте; в режиме «Истина» (`/airdef truth on`, T на карте) добавляются белые рамки
реальных дронов с их настоящим типом — отдельно от сетевых оценок, чтобы видеть расхождение. Отпустил
клавишу — метки исчезли. Метки достаются ближайшим из видимых целей: цель за камерой или за краем
экрана бюджет кадра не тратит, а заголовок показывает, сколько целей в кадре, сколько за кадром и сколько
не поместилось в бюджет. Метки проектируются через камеру последнего отрисованного кадра (`render.project`,
API 31 форка) и следуют за взглядом покадрово; поверх повтора, сетки J, монитора K и карты M обзор не рисуется.
**Повторы.** Каждый налёт записывается сам: с первой цели в небе до момента, когда небо 5 с чисто **Повторы.** Каждый налёт записывается сам: с первой цели в небе до момента, когда небо 5 с чисто
(хранятся 3 последних). Меню N → «Повторы…» или клавиша **R**: (хранятся 3 последних). Меню N → «Повторы…» или клавиша **R**:
- **карта налёта** — вид сверху: комплексы и их зоны, объекты, треки целей (красные), ложных целей (серые) и - **карта налёта** — вид сверху: комплексы и их зоны, объекты, треки целей (красные), ложных целей (серые) и
@@ -190,7 +206,12 @@ API мода `render.set-lights` (до 512, плавно интерполиру
целью, потом за перехватчиком (или смотрит из пушки, со стороны на прилёт), в момент сбития время замедляется; целью, потом за перехватчиком (или смотрит из пушки, со стороны на прилёт), в момент сбития время замедляется;
- **полный повтор** — весь налёт, камера-режиссёр сама выбирает, за чем следить; колесо — перемотка, стрелки — скорость; - **полный повтор** — весь налёт, камера-режиссёр сама выбирает, за чем следить; колесо — перемотка, стрелки — скорость;
- **лучшие моменты** — нарезка до 8 самых интересных событий (перехват баллистики и гиперзвука, поражения - **лучшие моменты** — нарезка до 8 самых интересных событий (перехват баллистики и гиперзвука, поражения
объектов, потерянные комплексы, разделение «Орешника») с титрами и замедлением; колесо листает моменты. объектов, потерянные комплексы, разделение «Орешника») с титрами и замедлением; колесо листает моменты;
- **цепочки боя** — меню N → «Повторы…» → «Цепочки боя»: по каждому контакту короткая строка
«отметка → передача → захват → пуск → исход» из 4–5 измеренных переходов записи, без домыслов. Видны
время каждого шага, батарея и контакт, у пропущенных контактов — «без пуска». Фильтр по батарее
переключает список; клик открывает кадр повтора (клип исхода, а если исхода нет — карту налёта на
моменте пуска или отметки). То же списком: `/airdef chains [номер батареи]`.
Повтор идёт на весь экран с леттербоксом; звук слышен так, как его слышала бы камера. Управление (подсказка Повтор идёт на весь экран с леттербоксом; звук слышен так, как его слышала бы камера. Управление (подсказка
показывается в начале, после нажатия и на паузе): **← →** — перемотка на 5 с (в нарезке — соседний момент), показывается в начале, после нажатия и на паузе): **← →** — перемотка на 5 с (в нарезке — соседний момент),
@@ -200,7 +221,7 @@ API мода `render.set-lights` (до 512, плавно интерполиру
Чтобы в повторах и камерах комплексов была видна земля далеко от игрока, мод включает дальний ландшафт Чтобы в повторах и камерах комплексов была видна земля далеко от игрока, мод включает дальний ландшафт
(48 чанков, упрощённый); выключается в меню N → «Огонь, ремонт, эффекты…» → «Дальний ландшафт». (48 чанков, упрощённый); выключается в меню N → «Огонь, ремонт, эффекты…» → «Дальний ландшафт».
Клавиши N, K, J, R и U можно переназначить в «Настройки → Моды». Клавиши N, K, J, R, U и C (обзор целей, удержание) можно переназначить в «Настройки → Моды».
Команды: Команды:
- `/airdef wave <тип> [кол-во] [дальность]` — налёт на ближайшую цель. Дальность старта — от 60 до 4000 блоков (в меню: 200–4000); землю для площадок, которой нет в загруженных чанках, игра подгружает сама (API 22, `render.load-chunks`, пока идёт поиск), а где подгрузить нельзя (сервер) или нет пригодного места, дроны всё равно стартуют: «за картой», с высоты полёта на заказанной дальности, без площадки. Типы: `shahed`, `geran3`, `lancet`, `gerbera`, `kh101`, `kalibr`, `kh22`, `zircon`, `iskander`, `kinzhal`, `oreshnik` и `mix` (комбинированный удар двумя секторами: «Герберы», шахеды, Герани-3, Х-101, «Калибры», Х-22, Циркон, «Искандер», «Кинжал», при 30+ — «Орешник»); - `/airdef wave <тип> [кол-во] [дальность]` — налёт на ближайшую цель. Дальность старта — от 60 до 4000 блоков (в меню: 200–4000); землю для площадок, которой нет в загруженных чанках, игра подгружает сама (API 22, `render.load-chunks`, пока идёт поиск), а где подгрузить нельзя (сервер) или нет пригодного места, дроны всё равно стартуют: «за картой», с высоты полёта на заказанной дальности, без площадки. Типы: `shahed`, `geran3`, `lancet`, `gerbera`, `kh101`, `kalibr`, `kh22`, `zircon`, `iskander`, `kinzhal`, `oreshnik` и `mix` (комбинированный удар двумя секторами: «Герберы», шахеды, Герани-3, Х-101, «Калибры», Х-22, Циркон, «Искандер», «Кинжал», при 30+ — «Орешник»);
@@ -213,9 +234,21 @@ API мода `render.set-lights` (до 512, плавно интерполиру
- `/airdef sites` — известные пусковые площадки (ПУ). РЛС с прямой видимостью может заметить сам пуск и получить неточную позицию; несколько наблюдённых пусков уточняют её. Обнаруженный позже дрон даёт только слабое предположение об обратном курсе: скрытые координаты площадки и время невидимого старта не используются. Повторные треки одного полёта не создают ложную точность. - `/airdef sites` — известные пусковые площадки (ПУ). РЛС с прямой видимостью может заметить сам пуск и получить неточную позицию; несколько наблюдённых пусков уточняют её. Обнаруженный позже дрон даёт только слабое предположение об обратном курсе: скрытые координаты площадки и время невидимого старта не используются. Повторные треки одного полёта не создают ложную точность.
- `/airdef strike <номер ПУ>` — ручной удар по разведанной площадке из готового физического С-400 с отдельно загруженной RM48U (игровой профиль, #118). Четыре ячейки делятся с боезапасом ПВО; приказ резервирует носитель и ячейку, открывает крышку и списывает одну ударную ракету при выбросе. Выбирается готовый комплекс с наибольшим остатком RM48U, затем ближайший к цели. Есть открытие ТПК, выброс, отложенное включение двигателя и разгон, ограниченная игровая траектория, столкновения и запись пуска. Несуществующее «ПВО площадки» не перехватывает ракету по броску вероятности. - `/airdef strike <номер ПУ>` — ручной удар по разведанной площадке из готового физического С-400 с отдельно загруженной RM48U (игровой профиль, #118). Четыре ячейки делятся с боезапасом ПВО; приказ резервирует носитель и ячейку, открывает крышку и списывает одну ударную ракету при выбросе. Выбирается готовый комплекс с наибольшим остатком RM48U, затем ближайший к цели. Есть открытие ТПК, выброс, отложенное включение двигателя и разгон, ограниченная игровая траектория, столкновения и запись пуска. Несуществующее «ПВО площадки» не перехватывает ракету по броску вероятности.
- `/airdef ground-stock <номер склада> <количество>` — задать остаток RM48U для sandbox-сценария (по умолчанию 0). `/airdef ground-load <номер С-400>` загружает одну ракету у склада либо заказывает ТЗМ; `ground-unload` возвращает её у склада либо заказывает вывоз; `ground-cancel` отменяет ожидающую заявку. Доставка и обратный вывоз через ТЗМ реализованы, запас и груз сохраняются. [Пошаговый пример](docs/GROUND-STRIKES.md). Совместимость профиля основана на [публикации ГУР](https://gur.gov.ua/content/warsanctions-hur-mo-rozkryvaie-budovu-komponentnu-bazu-ta-pidpryiemstva-kooperatsii-z-vyrobnytstva-udarnykh-raket-rm48u.html); это сообщение ведомства, не независимая сертификация. Дальность, форма полёта и оформление условны для Minecraft. - `/airdef ground-stock <номер склада> <количество>` — задать остаток RM48U для sandbox-сценария (по умолчанию 0). `/airdef ground-load <номер С-400>` загружает одну ракету у склада либо заказывает ТЗМ; `ground-unload` возвращает её у склада либо заказывает вывоз; `ground-cancel` отменяет ожидающую заявку. Доставка и обратный вывоз через ТЗМ реализованы, запас и груз сохраняются. [Пошаговый пример](docs/GROUND-STRIKES.md). Совместимость профиля основана на [публикации ГУР](https://gur.gov.ua/content/warsanctions-hur-mo-rozkryvaie-budovu-komponentnu-bazu-ta-pidpryiemstva-kooperatsii-z-vyrobnytstva-udarnykh-raket-rm48u.html); это сообщение ведомства, не независимая сертификация. Дальность, форма полёта и оформление условны для Minecraft.
- `/airdef deploy s400_launcher` и `s500_launcher` — отдельные пусковые без своей РЛС; `radar_search`, `radar_track`, `radar_height` — обзорная, сопровождающая и мачтовая игровые РЛС. Они также доступны через меню N → «Разместить элементы батареи…». `/airdef battery` показывает состав и связь; `/airdef battery <номер> integrated|launcher` меняет конфигурацию, `/airdef radar <номер> multi|search|engagement|height` — роль отдельной РЛС. Обзорная РЛС передаёт подсказки; станция сопровождения должна сама получить свежее измерение, чтобы разрешить пуск. Старые С-400/С-500 сохраняют упрощённую сборную конфигурацию. [Устройство игровой батареи и пуска](docs/BATTERIES-AND-COLD-LAUNCH.md). - `/airdef deploy s400_launcher` и `s500_launcher` — отдельные пусковые без своей РЛС; `radar_search`, `radar_track`, `radar_height` — три разные игровые РЛС с устойчивыми профилями в каталоге. Они также выдаются отдельными пультами (`/airdef give`) и ставятся на блок как обычные пульты. `/airdef battery` показывает состав, профиль, цикл, продукты измерения и связь; `/airdef battery <номер> integrated|launcher` меняет конфигурацию. Профиль РЛС задаётся при размещении и не переключается на ходу: `radar <номер> on|off` сохраняется. Обзорная станция даёт редкие грубые отметки и область поиска; мачтовая уточняет низкие контакты над рельефом; сопровождения ищет локально, ведёт ограниченное число точных треков и только её собственное подтверждённое измерение разрешает пуск. Сеть передаёт источник, возраст и качество, но повторная пересылка не освежает измерение. Старые С-400/С-500 сохраняют сборную конфигурацию, старые роли РЛС при загрузке сопоставляются с профилями. [Устройство игровой батареи и пуска](docs/BATTERIES-AND-COLD-LAUNCH.md).
- `/airdef roles` — показать, по каким классам целей работает каждый комплекс; `/airdef roles <patriot|gepard|pantsir|s400|s500|all> <классы|default>` — задать (классы через запятую: `drone`, `jet`, `cruise`, `supersonic`, `ballistic` или `all`), например `/airdef roles s400 cruise,ballistic`; - `/airdef roles` — показать, по каким классам целей работает каждый комплекс; `/airdef roles <patriot|gepard|pantsir|s400|s500|all> <классы|default>` — задать (классы через запятую: `drone`, `jet`, `cruise`, `supersonic`, `ballistic` или `all`), например `/airdef roles s400 cruise,ballistic`;
- `/airdef doctrine` — доктрины комплексов (#47; в меню N: «Доктрины…»): `/airdef doctrine <номер|all> reserve <K>` — держать K ракет для срочных целей (баллистика или до удара меньше 12 с); `salvo eco|normal|heavy` — сколько перехватчиков на цель (только базовые / как обычно / на один больше); `sector <центр°> <полуширина°>` или `sector off` — сектор ответственности (0° — север); `guard <объект№>[,<№>]` или `guard off` — стрелять только по тому, что идёт на охраняемые объекты (отметка: `/airdef target here`). По умолчанию ограничений нет; последний шанс сильнее доктрины; `/airdef why <номер>` называет, какая настройка остановила или разрешила пуск; сохраняется с миром и сценариями. Карта охраны и пробелов в ней — вместе с картой (#48). - `/airdef doctrine` — доктрины комплексов (#47; в меню N: «Доктрины…»): `/airdef doctrine <номер|all> reserve <K>` — держать K ракет для срочных целей (баллистика или до удара меньше 12 с); `salvo eco|normal|heavy` — сколько перехватчиков на цель (только базовые / как обычно / на один больше); `sector <центр°> <полуширина°>` или `sector off` — сектор ответственности (0° — север); `guard <объект№>[,<№>]` или `guard off` — стрелять только по тому, что идёт на охраняемые объекты (отметка: `/airdef target here`). По умолчанию ограничений нет; последний шанс сильнее доктрины; `/airdef why <номер>` называет, какая настройка остановила или разрешила пуск; сохраняется с миром и сценариями. Карта охраны и пробелов в ней — вместе с картой (#48).
- `/airdef why <номер>` — почему комплекс стреляет или нет. Сразу под строкой состояния — одна typed-причина:
«есть только обзор», «ждёт сопровождения», «каналы заняты», «нет боезапаса» или «готов к пуску», вместе с возрастом и
источником отметки (своя РЛС или сеть, РЛС №N). «Есть только обзор» — на картине лишь поисковая или
сетевая отметка, своё подтверждённое измерение пуск не разрешает; «ждёт сопровождения» — своя РЛС ещё
уточняет контакт или пусковая ждёт огневой трек поддерживающей РЛС; «каналы заняты» — все каналы
сопровождения заняты другими контактами; «нет боезапаса» — нет ракет и снарядов или идёт перезарядка.
`/airdef why <номер> source` переводит монитор K на станцию, которая поставила отметку. Подробные
проверки (роли, доктрина, дальность, наведение) идут ниже и не расходятся с этой причиной. В обычном
HUD — только картина самой батареи: класс по оценке, без истинного типа и скрытых данных.
- `/airdef chains [номер батареи]` — короткие цепочки последнего налёта: «отметка → передача → захват →
пуск → исход» с временем шагов; без номера — все батареи. Строка кликабельна в меню N → «Повторы…» →
«Цепочки боя» и открывает кадр повтора.
- `/airdef deploy <patriot|gepard|pantsir|s400|s500>` — поставить комплекс в 8 блоках перед собой; - `/airdef deploy <patriot|gepard|pantsir|s400|s500>` — поставить комплекс в 8 блоках перед собой;
- `/airdef hold on|off` — запретить или разрешить ПВО огонь, удобно для съёмки ударов; - `/airdef hold on|off` — запретить или разрешить ПВО огонь, удобно для съёмки ударов;
- `/airdef damage on|off` — разрушать ли ландшафт взрывами (через TNT, нужны читы); - `/airdef damage on|off` — разрушать ли ландшафт взрывами (через TNT, нужны читы);
@@ -223,10 +256,23 @@ API мода `render.set-lights` (до 512, плавно интерполиру
- `/airdef clear` — убрать дроны и ракеты; - `/airdef clear` — убрать дроны и ракеты;
- `/airdef targets clear` — снять все цели; - `/airdef targets clear` — снять все цели;
- `/airdef stats` — сводка. - `/airdef stats` — сводка.
- `/airdef recon` — debug/послебоевой разбор разведки противника (#135): отметки его картины best-first с причиной приоритета (`свежесть×4 + качество×3 + наблюдаемая роль`), фазы вылетов и дроны, нацеленные на отметку. То же — страница «Разведка противника (разбор)» в меню N. Всеведущая картина противника в обычный HUD не выводится.
Интерфейс: Интерфейс:
- **сверху справа — сводка:** тревога, цели по типам, ближайшая угроза (дальность, высота, скорость), перехватчики в воздухе, по каждому комплексу боезапас или перезарядка, его текущая цель и число сбитых, итоговый счёт; - **сверху справа — сводка:** тревога, цели по типам, ближайшая угроза (дальность, высота, скорость), перехватчики в воздухе, по каждому комплексу боезапас или перезарядка, его текущая цель и число сбитых, итоговый счёт; если сеть держит разведчиков противника — их число и фаза вылета (разведка/донесение/завершение);
- **снизу справа — радар на 500 м** со сканирующим лучом. Отметки гаснут после прохода луча. Красное — цели (с хвостом по курсу), жёлтое — ракеты, синее — ПВО с кругами дальности, крест — цели удара. - **снизу справа — радар на 500 м** со сканирующим лучом. Отметки гаснут после прохода луча. Красное — цели: форма значка различает дрон, самолёт, крылатую, сверхзвуковую и баллистическую ракету, хвост показывает курс, а близкие отметки объединяются с числом; жёлтое — ракеты, синее — ПВО с кругами дальности, крест — цели удара. Разведчик противника в картине сети — жёлтый полый ромб с подписью «разведчик».
**Разведка противника (#135).** Налёт с целью «умный противник» перед ударом высылает небольшой бюджет
невооружённых разведчиков: они физически проходят игровые зоны вокруг отмеченных целей и передают домой
только область, грубую категорию, канал (пролёт/излучение/РЭБ/пуск) и возраст — не точную точку, тип,
прочность и боезапас. Сбитый до донесения разведчик ничего не передаёт; уже переданное противник помнит
между налётами, а скрытый переезд или выключение не переписывают старую отметку. На карте сети разведчик —
узнаваемый жёлтый ромб с подписью «разведчик» (в sandbox-режиме `/airdef truth on` — янтарная метка и
счётчик отметок), в сводке и на карте видна фаза вылета: разведка → донесение → завершение. Что противник
запомнил и почему выбирает цель, показывает `/airdef recon` и страница «Разведка противника (разбор)» в меню
N (есть и в «Повторы…»): отметки best-first с разбором приоритета (свежесть, качество, наблюдаемая роль) и
дроны, нацеленные на отметку. Это явный debug/послебоевой разбор — всеведущая картина противника в обычный
HUD не выводится. Простые пресеты налёта фазу разведки не получают.
Комплексы ПВО и цели сохраняются между сессиями. Комплексы ПВО и цели сохраняются между сессиями.
@@ -265,7 +311,9 @@ API мода `render.set-lights` (до 512, плавно интерполиру
Обслуживающая техника (тоже пультами или `/airdef deploy <ключ>`): **РЛС дальнего обнаружения** (`radar`, Обслуживающая техника (тоже пультами или `/airdef deploy <ключ>`): **РЛС дальнего обнаружения** (`radar`,
видит на 2,5 км с высокой мачты, хуже прячутся за рельефом), **склад боеприпасов** (`depot`), **ТЗМ** (`tzm`), видит на 2,5 км с высокой мачты, хуже прячутся за рельефом), **склад боеприпасов** (`depot`), **ТЗМ** (`tzm`),
**станция РЭБ** (`ew`), **прожектор** (`light`). Новые комплексы: `irist`, `nasams`, `buk`, `tor`, `p1sun`. **станция РЭБ** (`ew`), **прожектор** (`light`), **оптический пост** (`optical`: пассивно уточняет широкий класс
контакта по прямой видимости и передаёт уточнение в класс уже известного сетевого трека — без своего трека,
свежести и права на пуск; не излучает и не ведёт огневой трек). Новые комплексы: `irist`, `nasams`, `buk`, `tor`, `p1sun`.
**Согласование огня.** Комплексы делят цели между собой: на обычную цель идёт одна ракета, на баллистическую две; чем ближе цель к своей точке попадания, **Согласование огня.** Комплексы делят цели между собой: на обычную цель идёт одна ракета, на баллистическую две; чем ближе цель к своей точке попадания,
тем больше перехватчиков разрешено на неё сразу (за ~12 с до удара ещё один, за ~5 с — ещё один). Комплекс, у которого кончились ракеты тем больше перехватчиков разрешено на неё сразу (за ~12 с до удара ещё один, за ~5 с — ещё один). Комплекс, у которого кончились ракеты
+2
View File
@@ -9,5 +9,7 @@ glam = "0.30"
[features] [features]
test-fixtures = [] test-fixtures = []
# Counts the events the by-time journal readers hand out (the `replay_bench` example).
bench-counters = []
[workspace] [workspace]
+3 -1
View File
@@ -144,7 +144,9 @@ fn two_maximum_menu_raids_with_answered_flat_terrain() {
let mut second = false; let mut second = false;
let mut overlap = false; let mut overlap = false;
let mut peak = 0; let mut peak = 0;
for now in 1..=5000 { // Two maximum menu raids can keep the last supersonic contact in the air past
// 5000 ticks under the radar profiles; the recording closes once the sky is clear.
for now in 1..=8000 {
if !second && !sim.planning() { if !second && !sim.planning() {
overlap = !sim.queue.is_empty() || sim.drones.iter().any(|d| d.alive()); overlap = !sim.queue.is_empty() || sim.drones.iter().any(|d| d.alive());
assert_eq!(sim.order_raid(&order, &targets, &mut out), expected); assert_eq!(sim.order_raid(&order, &targets, &mut out), expected);
+173
View File
@@ -2,6 +2,12 @@
# It is not intended for manual editing. # It is not intended for manual editing.
version = 4 version = 4
[[package]]
name = "adler2"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
[[package]] [[package]]
name = "airdef" name = "airdef"
version = "0.2.0" version = "0.2.0"
@@ -9,6 +15,7 @@ dependencies = [
"airdef-core", "airdef-core",
"glam", "glam",
"horizon-mod-sdk", "horizon-mod-sdk",
"horizon-mods",
] ]
[[package]] [[package]]
@@ -24,18 +31,75 @@ version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "arbitrary"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3bc62ac97cc33321f50863d514c3bc38a453947a8f9e781137e47c7401020aed"
dependencies = [
"derive_arbitrary",
]
[[package]] [[package]]
name = "bitflags" name = "bitflags"
version = "2.13.2" version = "2.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
[[package]]
name = "bumpalo"
version = "3.20.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87a0cf66fd1eb2fb7b822cb78370d82303750809bc6ba855f3f58e517d3238db"
[[package]]
name = "cfg-if"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
[[package]]
name = "crc32fast"
version = "1.5.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b929dd2a135771f40afabd1073f85eed59c800b7c61901e5c254270497dad64"
dependencies = [
"cfg-if",
]
[[package]]
name = "crossbeam-utils"
version = "0.8.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
[[package]]
name = "derive_arbitrary"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
]
[[package]] [[package]]
name = "equivalent" name = "equivalent"
version = "1.0.3" version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826" checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
[[package]]
name = "flate2"
version = "1.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "626d4928326b646e70f65ed36fc7cf9f206bdb68a0019ee7c6b4709da4e084c4"
dependencies = [
"crc32fast",
"miniz_oxide",
]
[[package]] [[package]]
name = "foldhash" name = "foldhash"
version = "0.2.0" version = "0.2.0"
@@ -70,6 +134,17 @@ dependencies = [
"wit-bindgen", "wit-bindgen",
] ]
[[package]]
name = "horizon-mods"
version = "0.1.0"
dependencies = [
"log",
"serde",
"serde_json",
"toml",
"zip",
]
[[package]] [[package]]
name = "id-arena" name = "id-arena"
version = "2.3.0" version = "2.3.0"
@@ -112,6 +187,16 @@ version = "2.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
[[package]]
name = "miniz_oxide"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
dependencies = [
"adler2",
"simd-adler32",
]
[[package]] [[package]]
name = "prettyplease" name = "prettyplease"
version = "0.2.37" version = "0.2.37"
@@ -153,6 +238,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
dependencies = [ dependencies = [
"serde_core", "serde_core",
"serde_derive",
] ]
[[package]] [[package]]
@@ -188,6 +274,21 @@ dependencies = [
"zmij", "zmij",
] ]
[[package]]
name = "serde_spanned"
version = "1.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c187e0a369471c550af028cba56d4f4fa2a489ad28151ae95a4d340a2a8b782"
dependencies = [
"serde_core",
]
[[package]]
name = "simd-adler32"
version = "0.3.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
[[package]] [[package]]
name = "syn" name = "syn"
version = "2.0.119" version = "2.0.119"
@@ -210,6 +311,45 @@ dependencies = [
"unicode-ident", "unicode-ident",
] ]
[[package]]
name = "toml"
version = "1.2.2+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5426cb1b964690d913f6c5c1a1ae0b42f428ec506bb4d452876d7a209c9bca3b"
dependencies = [
"indexmap",
"serde_core",
"serde_spanned",
"toml_datetime",
"toml_parser",
"toml_writer",
"winnow",
]
[[package]]
name = "toml_datetime"
version = "1.1.3+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "173f25c883cd2176a2d8212155638c0a60d484a9d84546d270866f40f56b6e49"
dependencies = [
"serde_core",
]
[[package]]
name = "toml_parser"
version = "1.1.6+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6769c452d71ba30696c6b37770c439a9cc9110f47f7d5cdbeda79840ef5ea31"
dependencies = [
"winnow",
]
[[package]]
name = "toml_writer"
version = "1.2.0+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "009dbb7700f11c55ef83aebbe4c0e9cf1f1ac0844bd8d6f00dc38f302026e13a"
[[package]] [[package]]
name = "unicode-ident" name = "unicode-ident"
version = "1.0.27" version = "1.0.27"
@@ -250,6 +390,12 @@ dependencies = [
"semver", "semver",
] ]
[[package]]
name = "winnow"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c3b93199df0ab874cdf0c6a94f0a0dc3423fe41f1cafb62b8bd7b1deb277aef"
[[package]] [[package]]
name = "wit-bindgen" name = "wit-bindgen"
version = "0.60.0" version = "0.60.0"
@@ -339,8 +485,35 @@ dependencies = [
"wasmparser", "wasmparser",
] ]
[[package]]
name = "zip"
version = "2.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1dcb24d0152526ae49b9b96c1dcf71850ca1e0b882e4e28ed898a93c41334744"
dependencies = [
"arbitrary",
"crc32fast",
"crossbeam-utils",
"flate2",
"indexmap",
"memchr",
"zopfli",
]
[[package]] [[package]]
name = "zmij" name = "zmij"
version = "1.0.23" version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
[[package]]
name = "zopfli"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aaf7fc5d30c28483d93805c4a5e12b05bbb52407fa67c5f8bd552374cd01fb11"
dependencies = [
"bumpalo",
"crc32fast",
"log",
"simd-adler32",
]
+7
View File
@@ -8,6 +8,10 @@ description = "AirDef: long-range drones and air defence for the AirDef fork of
[lib] [lib]
crate-type = ["cdylib", "rlib"] crate-type = ["cdylib", "rlib"]
[features]
# Counts the events the by-time readers hand out (the `replay_bench` example); off in the mod build.
bench-counters = ["airdef-core/bench-counters"]
[dependencies] [dependencies]
airdef-core = { path = "../airdef-core" } airdef-core = { path = "../airdef-core" }
horizon-mod-sdk = { path = "../horizon/crates/horizon-mod-sdk" } horizon-mod-sdk = { path = "../horizon/crates/horizon-mod-sdk" }
@@ -15,6 +19,9 @@ glam = "0.30"
[dev-dependencies] [dev-dependencies]
airdef-core = { path = "../airdef-core", features = ["test-fixtures"] } airdef-core = { path = "../airdef-core", features = ["test-fixtures"] }
# The host's own block tracer, so the saturation replica answers render rays exactly as the
# WASM test host does (no runtime: just `world_query`).
horizon-mods = { path = "../horizon/crates/horizon-mods", default-features = false }
[profile.release] [profile.release]
opt-level = "s" opt-level = "s"
@@ -0,0 +1,6 @@
{
"model": {
"type": "minecraft:model",
"model": "airdef:item/deploy_optical"
}
}
@@ -0,0 +1,6 @@
{
"model": {
"type": "minecraft:model",
"model": "airdef:item/deploy_radar_height"
}
}
@@ -0,0 +1,6 @@
{
"model": {
"type": "minecraft:model",
"model": "airdef:item/deploy_radar_search"
}
}
@@ -0,0 +1,6 @@
{
"model": {
"type": "minecraft:model",
"model": "airdef:item/deploy_radar_track"
}
}
@@ -0,0 +1,6 @@
{
"model": {
"type": "minecraft:model",
"model": "airdef:item/deploy_s400_launcher"
}
}
@@ -0,0 +1,6 @@
{
"model": {
"type": "minecraft:model",
"model": "airdef:item/deploy_s500_launcher"
}
}
+6
View File
@@ -123,6 +123,12 @@
"item.airdef.deploy_tzm": "Развернуть ТЗМ", "item.airdef.deploy_tzm": "Развернуть ТЗМ",
"item.airdef.deploy_ew": "Развернуть станцию РЭБ", "item.airdef.deploy_ew": "Развернуть станцию РЭБ",
"item.airdef.deploy_light": "Развернуть прожектор", "item.airdef.deploy_light": "Развернуть прожектор",
"item.airdef.deploy_optical": "Развернуть оптический пост",
"item.airdef.deploy_s400_launcher": "Развернуть С-400 (пусковая)",
"item.airdef.deploy_s500_launcher": "Развернуть С-500 (пусковая)",
"item.airdef.deploy_radar_search": "Развернуть РЛС обзора",
"item.airdef.deploy_radar_track": "Развернуть РЛС сопровождения",
"item.airdef.deploy_radar_height": "Развернуть мачтовую РЛС",
"item.airdef.mover": "Пульт перемещения", "item.airdef.mover": "Пульт перемещения",
"item.airdef.flare_gun": "Осветительная ракета", "item.airdef.flare_gun": "Осветительная ракета",
"item.airdef.remover": "Свернуть ПВО", "item.airdef.remover": "Свернуть ПВО",
+6
View File
@@ -123,6 +123,12 @@
"item.airdef.deploy_tzm": "Развернуть ТЗМ", "item.airdef.deploy_tzm": "Развернуть ТЗМ",
"item.airdef.deploy_ew": "Развернуть станцию РЭБ", "item.airdef.deploy_ew": "Развернуть станцию РЭБ",
"item.airdef.deploy_light": "Развернуть прожектор", "item.airdef.deploy_light": "Развернуть прожектор",
"item.airdef.deploy_optical": "Развернуть оптический пост",
"item.airdef.deploy_s400_launcher": "Развернуть С-400 (пусковая)",
"item.airdef.deploy_s500_launcher": "Развернуть С-500 (пусковая)",
"item.airdef.deploy_radar_search": "Развернуть РЛС обзора",
"item.airdef.deploy_radar_track": "Развернуть РЛС сопровождения",
"item.airdef.deploy_radar_height": "Развернуть мачтовую РЛС",
"item.airdef.mover": "Пульт перемещения", "item.airdef.mover": "Пульт перемещения",
"item.airdef.flare_gun": "Осветительная ракета", "item.airdef.flare_gun": "Осветительная ракета",
"item.airdef.remover": "Свернуть ПВО", "item.airdef.remover": "Свернуть ПВО",
@@ -0,0 +1,6 @@
{
"parent": "minecraft:item/generated",
"textures": {
"layer0": "airdef:item/deploy_radar"
}
}
@@ -0,0 +1,6 @@
{
"parent": "minecraft:item/generated",
"textures": {
"layer0": "airdef:item/deploy_radar"
}
}
@@ -0,0 +1,6 @@
{
"parent": "minecraft:item/generated",
"textures": {
"layer0": "airdef:item/deploy_radar"
}
}
@@ -0,0 +1,6 @@
{
"parent": "minecraft:item/generated",
"textures": {
"layer0": "airdef:item/deploy_radar"
}
}
@@ -0,0 +1,6 @@
{
"parent": "minecraft:item/generated",
"textures": {
"layer0": "airdef:item/deploy_s400"
}
}
@@ -0,0 +1,6 @@
{
"parent": "minecraft:item/generated",
"textures": {
"layer0": "airdef:item/deploy_s500"
}
}
@@ -0,0 +1,4 @@
{
"template": "minecraft:stick",
"max_stack_size": 1
}
@@ -0,0 +1,4 @@
{
"template": "minecraft:stick",
"max_stack_size": 1
}
@@ -0,0 +1,4 @@
{
"template": "minecraft:stick",
"max_stack_size": 1
}
@@ -0,0 +1,4 @@
{
"template": "minecraft:stick",
"max_stack_size": 1
}
@@ -0,0 +1,4 @@
{
"template": "minecraft:stick",
"max_stack_size": 1
}
@@ -0,0 +1,4 @@
{
"template": "minecraft:stick",
"max_stack_size": 1
}
+261
View File
@@ -0,0 +1,261 @@
//! Replay hot-path benchmark (#150): a 10-minute raid with its journals almost full.
//!
//! Plays the recording the ways a player does — ordinary playback, reverse seeks, a pause and
//! an MP4 export (the director's film) — and reports the CPU per frame (p50/p95/p99) and the
//! events the by-time readers handed out. Run it with the counters built in:
//!
//! cargo run --release --example replay_bench --features bench-counters
//!
//! Without `bench-counters` the scanned-events numbers read 0. Native timings compare runs on
//! one machine; they say nothing about the WASM build or the GPU.
use airdef::film::{Film, Which};
use airdef::replay::{Control, Mode, Player};
use airdef::sim::record::{Event, EventKind, Recording, SceneEvent, SceneJournal, SceneKind, StrikeResult, What};
use airdef::sim::{DroneKind, Ground, MissileKind, Out, SamKind, Sim};
use glam::DVec3;
use std::time::{Duration, Instant};
/// The longest recording, ticks (10 minutes at 20 a second).
const TICKS: u32 = 12_000;
/// The event journal's cap, and the scene journal's (`MAX_SCENE_EVENTS`), nearly reached.
const EVENTS: usize = 64_000;
const SCENE: usize = 65_000;
/// Frames measured per mode (20 a second, half a minute of playback; a film frame is 0.05 s).
const FRAMES: usize = 600;
const LISTENER: DVec3 = DVec3::new(0.0, 70.0, 0.0);
/// A 10-minute raid's recording: 200 flights, a nearly full event journal and scene journal,
/// the objects, systems, tracks and the fires — the journal a busy raid leaves.
fn recording() -> Recording {
let mut rec = Recording::blank(TICKS);
rec.number = 1;
rec.len = TICKS;
rec.origin = DVec3::ZERO;
rec.sams = (0..8).map(|i| (10 + i, SamKind::S400, DVec3::new(i as f64 * 120.0, 64.0, 400.0))).collect();
rec.objects = (0..8).map(|i| DVec3::new(i as f64 * 90.0, 70.0, 0.0)).collect();
// 200 flights, each a few hundred ticks of the raid (a point every 2 ticks): the map and
// the ghosts draw them, the sounds read their launches.
for k in 0..200u32 {
let first = k * 55 % (TICKS - 700);
let last = first + 600;
let what = match k % 4 {
0 => What::Drone(DroneKind::Geran3),
1 => What::Drone(DroneKind::Shahed),
2 => What::Missile(MissileKind::M48n6, 10 + k % 8),
_ => What::Strike,
};
rec.straight(1000 + k, what, first, last, DVec3::new(-2000.0, 100.0, k as f64 * 5.0), DVec3::new(500.0, 70.0, k as f64 * 5.0));
}
// The events: interceptions, hits, losses and splits spread through the raid.
rec.events = (0..EVENTS)
.map(|i| {
let at = (i as u64 * u64::from(TICKS) / EVENTS as u64) as u32;
let drone = 1000 + (i as u32 * 7 % 200);
let pos = DVec3::new((i % 40) as f64 * 10.0, 95.0, (i % 17) as f64 * 12.0);
let kind = match i % 10 {
0 | 1 => EventKind::Kill { drone, kind: DroneKind::Geran3, sam: 10, sam_kind: SamKind::S400, sam_index: 0, missile: None, outcome: Default::default() },
2 | 3 => EventKind::Hit { drone, kind: DroneKind::Geran3, power: (i % 5) as u32, object: Some(i % 8), sam: None },
4 | 5 => EventKind::Crash { drone, kind: DroneKind::Geran3, power: (i % 5) as u32 },
6 => EventKind::SamLost { sam: 10 + (i % 8) as u32, kind: SamKind::S400, index: i % 8 },
7 => EventKind::Split { drone },
_ => EventKind::Strike { site: 1, result: StrikeResult::Destroyed },
};
Event { at, pos, kind }
})
.collect();
// The scene journal: launches and ignitions (the exact sounds), track changes and fires.
let mut scene = SceneJournal::default();
for i in 0..SCENE {
let at = (i as u64 * u64::from(TICKS) / SCENE as u64) as u32;
let missile = 5000 + (i as u32 % 300);
let pos = DVec3::new((i % 30) as f64 * 8.0, 66.0, 300.0);
let kind = match i % 100 {
// Fires are a small share of a raid's transitions (hundreds over ten minutes).
0 => SceneKind::FireStarted { fire: (i / 100) as u32, age: 0, life: 4000, size: 1.0, quiet: false, shown: true, water: Some(false) },
1 => SceneKind::FireEnded { fire: (i / 100) as u32 },
2 | 3 => SceneKind::MissileLaunch { missile, sam: 10, target: 2000, kind: MissileKind::M48n6, sound: "airdef:launch.s400", pitch: 1.0 },
4 | 5 => SceneKind::MotorIgnition { missile, kind: MissileKind::M48n6, sound: Some("airdef:launch.s400") },
6 => SceneKind::MotorBurnout { missile, kind: MissileKind::M48n6 },
7 => SceneKind::MotorEnergyLost { missile, kind: MissileKind::M48n6, speed: 4.0 },
8 | 9 => SceneKind::TrackAcquired { sam: 10, target: 2000 + (i as u32 % 200), ever_own: true },
_ => SceneKind::TrackLost { sam: 10, target: 2000 + (i as u32 % 200) },
};
scene.fixture_push(SceneEvent { at, pos, kind });
}
rec.scene = Some(scene);
rec.close();
rec
}
/// Answers the ground queries the replays make with a flat 70-block land, as the game would.
fn settle(ground: &mut Ground, now: u64) {
let wanted = ground.take_wanted();
if !wanted.is_empty() {
ground.answer(wanted.into_iter().map(|(x, z)| (x, z, 70)).collect(), now);
}
}
fn percentile(sorted: &[Duration], p: f64) -> f64 {
if sorted.is_empty() {
return 0.0;
}
let i = (((sorted.len() - 1) as f64) * p).round() as usize;
sorted[i].as_secs_f64() * 1e6
}
struct Measured {
mode: &'static str,
frames: usize,
scanned: u64,
cpu: Vec<Duration>,
}
impl Measured {
fn cpu_p(&self, p: f64) -> f64 {
let mut sorted = self.cpu.clone();
sorted.sort_unstable();
percentile(&sorted, p)
}
fn json(&self, rec: &Recording, sim: &Sim) -> String {
let events_bytes = rec.events.capacity() * std::mem::size_of::<Event>();
let scene_events = rec.scene.as_ref().map_or(0, |s| s.events().len());
let scene_bytes = scene_events * std::mem::size_of::<SceneEvent>();
let index_bytes: usize = sim.replays.iter().map(Recording::index_bytes).sum();
format!(
"{{\"mode\":\"{}\",\"frames\":{},\"journal_events\":{},\"journal_scene\":{},\
\"scanned_events\":{},\"scanned_per_frame\":{:.1},\"full_pass_events\":{},\
\"p50_us\":{:.1},\"p95_us\":{:.1},\"p99_us\":{:.1},\"max_us\":{:.1},\
\"events_bytes\":{},\"scene_bytes\":{},\"index_bytes\":{}}}",
self.mode,
self.frames,
rec.events.len(),
scene_events,
self.scanned,
self.scanned as f64 / self.frames.max(1) as f64,
// One whole-journal pass per frame: what the readers did before the ranges (#150).
(rec.events.len() + scene_events) as u64 * self.frames as u64,
self.cpu_p(0.50),
self.cpu_p(0.95),
self.cpu_p(0.99),
self.cpu.iter().copied().max().unwrap_or_default().as_secs_f64() * 1e6,
events_bytes,
scene_bytes,
index_bytes,
)
}
}
/// Steps the replay's clock to `t` the way the wheel does (5 s a press), so the seek resets the
/// sound cursor and the shot as a player's would.
fn seek_to(p: &mut Player, rec: &Recording, t: f64) {
for _ in 0..((t.max(0.0) / 100.0) as usize) {
p.control(Control::Forward, rec);
}
}
fn sim_with(rec: Recording) -> (Sim, u64) {
let mut sim = Sim::new(1);
sim.replays.push(rec);
(sim, 1)
}
/// Ordinary playback from a moment near the end of the raid, time running at ×2.
fn playback() -> Measured {
let (sim, mut tick) = sim_with(recording());
let rec = &sim.replays[0];
let mut p = Player::new(1, Mode::Full, &sim);
seek_to(&mut p, rec, rec.len as f64 - 1_200.0);
let mut ground = Ground::default();
let mut out = Out::default();
let _ = airdef::sim::record::scanned_events();
let mut cpu = Vec::with_capacity(FRAMES);
for _ in 0..FRAMES {
let started = Instant::now();
p.tick(&sim, &mut ground, LISTENER, &mut out);
settle(&mut ground, tick);
tick += 1;
cpu.push(started.elapsed());
out = Out::default();
}
Measured { mode: "playback", frames: FRAMES, scanned: airdef::sim::record::scanned_events(), cpu }
}
/// Reverse seeks: five seconds back every frame, then a frame of playback.
fn reverse_seek() -> Measured {
let (sim, mut tick) = sim_with(recording());
let rec = &sim.replays[0];
let mut p = Player::new(1, Mode::Full, &sim);
seek_to(&mut p, rec, rec.len as f64 - 200.0);
let mut ground = Ground::default();
let mut out = Out::default();
let _ = airdef::sim::record::scanned_events();
let mut cpu = Vec::with_capacity(FRAMES);
for _ in 0..FRAMES {
let started = Instant::now();
p.control(Control::Back, rec);
p.tick(&sim, &mut ground, LISTENER, &mut out);
settle(&mut ground, tick);
tick += 1;
cpu.push(started.elapsed());
out = Out::default();
}
Measured { mode: "reverse_seek", frames: FRAMES, scanned: airdef::sim::record::scanned_events(), cpu }
}
/// A pause held while frames keep coming (the HUD and the ghosts stay, nothing sounds).
fn paused() -> Measured {
let (sim, mut tick) = sim_with(recording());
let rec = &sim.replays[0];
let mut p = Player::new(1, Mode::Full, &sim);
seek_to(&mut p, rec, rec.len as f64 * 0.75);
p.control(Control::Pause, rec);
let mut ground = Ground::default();
let mut out = Out::default();
let _ = airdef::sim::record::scanned_events();
let mut cpu = Vec::with_capacity(FRAMES);
for _ in 0..FRAMES {
let started = Instant::now();
p.tick(&sim, &mut ground, LISTENER, &mut out);
settle(&mut ground, tick);
tick += 1;
cpu.push(started.elapsed());
out = Out::default();
}
Measured { mode: "pause", frames: FRAMES, scanned: airdef::sim::record::scanned_events(), cpu }
}
/// An MP4 export: the director's film, its frames prepared and drawn as the game records them.
fn mp4() -> Measured {
let (sim, mut tick) = sim_with(recording());
let rec = &sim.replays[0];
let film = Film::build(rec, Which::Best).expect("the raid has moments to film");
let mut p = Player::new(1, Mode::Film(Box::new(film)), &sim);
p.wait = true;
p.clean = true;
let mut ground = Ground::default();
let mut out = Out::default();
let _ = airdef::sim::record::scanned_events();
let mut cpu = Vec::with_capacity(FRAMES);
for _ in 0..FRAMES {
let started = Instant::now();
p.tick(&sim, &mut ground, LISTENER, &mut out);
settle(&mut ground, tick);
tick += 1;
cpu.push(started.elapsed());
out = Out::default();
}
Measured { mode: "mp4", frames: FRAMES, scanned: airdef::sim::record::scanned_events(), cpu }
}
pub fn main() {
let (playback, reverse_seek, paused, mp4) = (playback(), reverse_seek(), paused(), mp4());
let (sim, _) = sim_with(recording());
let rec = &sim.replays[0];
if !airdef::sim::record::scan_counters() {
eprintln!("replay_bench: scanned events read 0; rerun with --features bench-counters");
}
let rows = [playback.json(rec, &sim), reverse_seek.json(rec, &sim), paused.json(rec, &sim), mp4.json(rec, &sim)];
println!("[");
println!("{}", rows.join(",\n"));
println!("]");
}
+41 -1
View File
@@ -72,6 +72,9 @@ pub struct Scenario {
pub ew: bool, pub ew: bool,
/// Ticks a truck on a job may stand still before it counts as stuck. /// Ticks a truck on a job may stand still before it counts as stuck.
pub stuck_after: u64, pub stuck_after: u64,
/// The smart enemy runs the legacy picks (#149's comparison runner): separate hint lists,
/// the lifetime bearing tally, no mark pricing and no refresh of the unreleased portion.
pub legacy: bool,
} }
impl Scenario { impl Scenario {
@@ -87,6 +90,7 @@ impl Scenario {
stop_at_end: true, stop_at_end: true,
ew: false, ew: false,
stuck_after: 600, stuck_after: 600,
legacy: false,
} }
} }
pub fn unit(&mut self, kind: SamKind, x: f64, z: f64) -> &mut Unit { pub fn unit(&mut self, kind: SamKind, x: f64, z: f64) -> &mut Unit {
@@ -138,6 +142,18 @@ pub struct Report {
pub intents: String, pub intents: String,
/// The most aim switches one drone went through. /// The most aim switches one drone went through.
pub switches_max: u16, pub switches_max: u16,
/// Smart drones seen over the run (#149's comparison).
pub smart_seen: u32,
/// The share of them whose last aim was a live public hint when last seen (#149).
pub useful_share: f64,
/// Distinct aim units over the smart drones seen, per drone (#149).
pub diversity: f64,
/// The share of smart drones switched twice or more (#149's jitter).
pub jittery_share: f64,
/// The bearing picker's last typed reason (#149).
pub bearing_reason: String,
/// Aims the bounded refresh re-chose (#149).
pub refresh_applied: u32,
} }
/// The last intent every smart drone of the run was seen carrying, as `name:count`. /// The last intent every smart drone of the run was seen carrying, as `name:count`.
@@ -146,7 +162,7 @@ fn intent_counts(seen: &HashMap<u32, &'static str>) -> String {
for name in seen.values() { for name in seen.values() {
*counts.entry(*name).or_insert(0usize) += 1; *counts.entry(*name).or_insert(0usize) += 1;
} }
["plan", "sead", "react", "replace"].iter().map(|k| format!("{k}:{}", counts.get(*k).copied().unwrap_or(0))).collect::<Vec<_>>().join(",") ["plan", "sead", "react", "replace", "refresh"].iter().map(|k| format!("{k}:{}", counts.get(*k).copied().unwrap_or(0))).collect::<Vec<_>>().join(",")
} }
fn finite(v: DVec3) -> bool { fn finite(v: DVec3) -> bool {
@@ -154,7 +170,14 @@ fn finite(v: DVec3) -> bool {
} }
pub fn run(sc: &Scenario) -> Report { pub fn run(sc: &Scenario) -> Report {
run_with_hook(sc, &mut |_, _| {})
}
/// The same, with a hook called after every tick (#149's comparison runner): a scenario may
/// change the defence between waves or shoot a recon flight down before its report.
pub fn run_with_hook(sc: &Scenario, hook: &mut dyn FnMut(u64, &mut Sim)) -> Report {
let mut sim = Sim::new(sc.seed); let mut sim = Sim::new(sc.seed);
sim.smart_legacy = sc.legacy;
sim.damage = false; // explosions would change the land the height function describes sim.damage = false; // explosions would change the land the height function describes
for u in &sc.units { for u in &sc.units {
let id = sim.id(); let id = sim.id();
@@ -183,6 +206,8 @@ pub fn run(sc: &Scenario) -> Report {
let mut standing: HashMap<u32, (DVec3, u64)> = HashMap::new(); let mut standing: HashMap<u32, (DVec3, u64)> = HashMap::new();
// drone id -> the last structured intent it carried (#127). // drone id -> the last structured intent it carried (#127).
let mut intents_seen: HashMap<u32, &'static str> = HashMap::new(); let mut intents_seen: HashMap<u32, &'static str> = HashMap::new();
// drone id -> (last aim unit, whether the picture held it live then, switches) (#149).
let mut decisions: HashMap<u32, (u32, bool, u16)> = HashMap::new();
let mut out = Out::default(); let mut out = Out::default();
for now in 1..=sc.ticks { for now in 1..=sc.ticks {
// Raids come in order: one is ordered once the previous one has been sent. // Raids come in order: one is ordered once the previous one has been sent.
@@ -205,6 +230,7 @@ pub fn run(sc: &Scenario) -> Report {
ground.world.serve(&sc.terrain, sections, now); ground.world.serve(&sc.terrain, sections, now);
let dt = t.elapsed(); let dt = t.elapsed();
times.push(dt); times.push(dt);
hook(now, &mut sim);
if planning { if planning {
r.planning += dt; r.planning += dt;
r.planning_ticks += 1; r.planning_ticks += 1;
@@ -220,6 +246,8 @@ pub fn run(sc: &Scenario) -> Report {
for d in sim.drones.iter().chain(sim.queue.iter().map(|(_, d)| d)) { for d in sim.drones.iter().chain(sim.queue.iter().map(|(_, d)| d)) {
if d.alive() && d.smart() { if d.alive() && d.smart() {
intents_seen.insert(d.id, d.intent().name()); intents_seen.insert(d.id, d.intent().name());
let unit = d.aim_unit();
decisions.insert(d.id, (unit, unit != 0 && sim.known_live(unit), d.aim_switches()));
} }
} }
// The air section a save would take, sampled when the sky is fullest (writing it every tick // The air section a save would take, sampled when the sky is fullest (writing it every tick
@@ -271,6 +299,18 @@ pub fn run(sc: &Scenario) -> Report {
r.raids_ended = ended.iter().filter(|o| **o).count(); r.raids_ended = ended.iter().filter(|o| **o).count();
r.all_ended = r.raids_ended == sc.raids.len(); r.all_ended = r.raids_ended == sc.raids.len();
r.intents = intent_counts(&intents_seen); r.intents = intent_counts(&intents_seen);
r.smart_seen = decisions.len() as u32;
if !decisions.is_empty() {
let n = decisions.len() as f64;
r.useful_share = decisions.values().filter(|(_, live, _)| *live).count() as f64 / n;
let mut units: Vec<u32> = decisions.values().map(|(u, _, _)| *u).collect();
units.sort_unstable();
units.dedup();
r.diversity = units.len() as f64 / n;
r.jittery_share = decisions.values().filter(|(_, _, s)| *s >= 2).count() as f64 / n;
}
r.bearing_reason = sim.bearing_report().reason.name().to_string();
r.refresh_applied = sim.refresh_applied();
r.tick_total = times.iter().sum(); r.tick_total = times.iter().sum();
times.sort(); times.sort();
if !times.is_empty() { if !times.is_empty() {
+187
View File
@@ -0,0 +1,187 @@
//! Smart v2 comparison runner (#149): the simple mode, the current (legacy) Smart and the
//! candidate, on fixed seeds and one scenario set — open map, hills, a configuration changed
//! between waves, and a recon flight shot down before its report.
//!
//! It prints one JSON array of rows: the share of useful decisions (a smart drone whose last
//! aim was a live public hint), the diversity of aims, the reasons (intents) on the review,
//! the share of jittery drones (two switches or more), the bearing picker's typed reason, the
//! refresh count, and the CPU/worst-job figures. The goal is interesting counterplay and clear
//! mistakes, not a maximised hit count — read the reasons and the jitter beside the losses.
//!
//! cargo run --release --example smart_bench
#[path = "sim_run/harness.rs"]
mod harness;
use airdef::sim::{Aim, Approach, DroneKind, Sam, SamKind, Sim};
use glam::DVec3;
use harness::{Report, Scenario, Terrain};
#[derive(Clone, Copy, PartialEq)]
enum Mode {
Simple,
Current,
Candidate,
}
impl Mode {
fn name(self) -> &'static str {
match self {
Mode::Simple => "simple",
Mode::Current => "current",
Mode::Candidate => "candidate",
}
}
fn apply(self, sc: &mut Scenario) {
sc.legacy = self == Mode::Current;
let aim = match self {
Mode::Simple => Aim::ObjectsAndSams,
_ => Aim::Smart,
};
for raid in &mut sc.raids {
raid.aim = aim;
}
}
}
fn esc(s: &str) -> String {
s.chars().flat_map(|c| match c {
'"' => "\\\"".chars().collect::<Vec<_>>(),
'\\' => "\\\\".chars().collect::<Vec<_>>(),
c => vec![c],
}).collect()
}
fn row(sc: &str, mode: Mode, r: &Report) -> String {
format!(
"{{\"scenario\":\"{}\",\"mode\":\"{}\",\"seed\":{},\"ticks\":{},\"all_ended\":{},\"launched\":{},\"kills\":{},\"hits\":{},\"fired\":{},\"sams_lost\":{},\"smart_seen\":{},\"useful_share\":{:.3},\"diversity\":{:.3},\"jittery_share\":{:.3},\"intents\":\"{}\",\"bearing_reason\":\"{}\",\"refresh_applied\":{},\"switches_max\":{},\"retargets_max\":{},\"tick_p95_ms\":{:.3},\"tick_max_ms\":{:.3},\"planning_ms\":{:.1},\"air_bytes\":{}}}",
esc(sc),
mode.name(),
r.seed,
r.ticks_run,
r.all_ended,
r.launched,
r.kills,
r.hits,
r.fired,
r.sams_lost,
r.smart_seen,
r.useful_share,
r.diversity,
r.jittery_share,
esc(&r.intents),
esc(&r.bearing_reason),
r.refresh_applied,
r.switches_max,
r.retargets_max,
r.tick_p95.as_secs_f64() * 1000.0,
r.tick_max.as_secs_f64() * 1000.0,
r.planning.as_secs_f64() * 1000.0,
r.air_bytes,
)
}
/// An open map: a ring of systems on flat land, one combined strike.
fn open() -> Scenario {
let mut sc = Scenario::new("open");
sc.terrain = Terrain::Flat(70);
for i in 0..18 {
let a = i as f64 * 2.399_963;
let r = 120.0 + (i as f64 / 18.0) * 320.0;
let kind = [SamKind::Radar, SamKind::S400, SamKind::Pantsir, SamKind::Ew, SamKind::Tor][i % 5];
sc.unit(kind, a.sin() * r, a.cos() * r).heading = a;
}
sc.raids.push(harness::RaidSpec {
kinds: vec![(DroneKind::Gerbera, 6), (DroneKind::Shahed, 10), (DroneKind::Kh101, 3), (DroneKind::Kh22, 2), (DroneKind::Lancet, 3)],
approach: Approach::AllSides,
aim: Aim::Smart,
dist: 500.0,
at: 1,
});
sc.ticks = 20 * 60 * 6;
sc
}
/// Hills: the standard big smart scenario's terrain and force.
fn hills() -> Scenario {
let mut sc = harness::big_smart();
sc.name = "hills".into();
sc.ticks = 20 * 60 * 6;
sc
}
/// Two waves with the defence changed between them: a radar moves unobserved, the EW stations
/// switch on, and a fresh battery appears. The second wave's picture must earn what it knows.
fn config_change() -> Scenario {
let mut sc = open();
sc.name = "config-change".into();
sc.raids.push(harness::RaidSpec {
kinds: vec![(DroneKind::Shahed, 8), (DroneKind::Geran3, 4), (DroneKind::Kh22, 2), (DroneKind::Iskander, 2)],
approach: Approach::TwoSectors,
aim: Aim::Smart,
dist: 600.0,
at: 4200,
});
sc.ticks = 20 * 60 * 10;
sc
}
/// A recon flight shot down before its report: the strike must fly on the picture it had, and
/// the bounded refresh must never hold the raid waiting for a report that will not come.
fn recon_lost() -> Scenario {
let mut sc = open();
sc.name = "recon-lost".into();
sc.ticks = 20 * 60 * 6;
sc
}
pub fn main() {
let seeds = [1u64, 7, 42];
let scenarios: [(&str, fn() -> Scenario); 4] = [("open", open), ("hills", hills), ("config-change", config_change), ("recon-lost", recon_lost)];
let modes = [Mode::Simple, Mode::Current, Mode::Candidate];
let mut rows = Vec::new();
for (name, make) in scenarios {
for mode in modes {
for &seed in &seeds {
let r = run(mode, name, make, seed);
rows.push(row(name, mode, &r));
eprintln!("{name} {} seed {seed}: useful {:.2} diversity {:.2} jitter {:.2} kills {} hits {} reasons {} bearing {} refresh {}", mode.name(), r.useful_share, r.diversity, r.jittery_share, r.kills, r.hits, r.intents, r.bearing_reason, r.refresh_applied);
}
}
}
println!("[{}]", rows.join(",\n"));
}
fn run(mode: Mode, name: &str, make: fn() -> Scenario, seed: u64) -> Report {
let mut sc = make();
sc.seed = seed;
mode.apply(&mut sc);
match name {
"config-change" => {
let mut changed = false;
harness::run_with_hook(&sc, &mut |now, sim: &mut Sim| {
if !changed && now >= 3600 && !sim.planning() {
changed = true;
if let Some(radar) = sim.sams.iter_mut().find(|s| s.kind == SamKind::Radar) {
radar.pos += DVec3::new(300.0, 0.0, -200.0);
}
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::Pantsir, DVec3::new(-200.0, 70.0, 250.0), 0.0));
sim.set_ew(true);
}
})
}
"recon-lost" => {
let mut killed = false;
harness::run_with_hook(&sc, &mut |now, sim: &mut Sim| {
if !killed && now >= 120 {
let recon: Vec<u32> = sim.drones.iter().filter(|d| sim.is_recon_drone(d.id)).map(|d| d.id).collect();
if !recon.is_empty() {
sim.drones.retain(|d| !recon.contains(&d.id));
killed = true;
}
}
})
}
_ => harness::run(&sc),
}
}
+20 -2
View File
@@ -114,12 +114,18 @@ b50fe5804cbbe10df992ebbc7e095a32ce8b73fc35159fa19889640681e408e9 assets/airdef/
0c9c5ee3fc87e2dc6d716bdb0bb5f30d3b265268bfd5083462b4861a8da65f0f assets/airdef/items/deploy_irist.json 0c9c5ee3fc87e2dc6d716bdb0bb5f30d3b265268bfd5083462b4861a8da65f0f assets/airdef/items/deploy_irist.json
09e46a6c4b59f66c24060ac627e6a287bf6797c7b1e32a9ec6c9d9662fdc3de3 assets/airdef/items/deploy_light.json 09e46a6c4b59f66c24060ac627e6a287bf6797c7b1e32a9ec6c9d9662fdc3de3 assets/airdef/items/deploy_light.json
6983561b3558aee16662aa83d2d9af760fb6236cc7dbe79ba20802f8a2ff15b9 assets/airdef/items/deploy_nasams.json 6983561b3558aee16662aa83d2d9af760fb6236cc7dbe79ba20802f8a2ff15b9 assets/airdef/items/deploy_nasams.json
e39c555ff197ed6c7c8fdfab924b7a609b5d111a905ca599a75a7b1270448fcc assets/airdef/items/deploy_optical.json
d8ac6a9258e2fc2e0791bbce18a3a07a72e471fbc72b6be7b5ca545c53f8d633 assets/airdef/items/deploy_p1sun.json d8ac6a9258e2fc2e0791bbce18a3a07a72e471fbc72b6be7b5ca545c53f8d633 assets/airdef/items/deploy_p1sun.json
e2353c70f6e5053864ab2fdf51df886d72c03e5c34db84fef8f3fff9c84a7ae4 assets/airdef/items/deploy_pantsir.json e2353c70f6e5053864ab2fdf51df886d72c03e5c34db84fef8f3fff9c84a7ae4 assets/airdef/items/deploy_pantsir.json
68dd9b1382b2dd6ad23d0f507a8cfcdcfa18ef5c4203e69c61f6ade9cfbf238e assets/airdef/items/deploy_patriot.json 68dd9b1382b2dd6ad23d0f507a8cfcdcfa18ef5c4203e69c61f6ade9cfbf238e assets/airdef/items/deploy_patriot.json
d93b6bf77de4aed1f1955e76353661729f06445788ad7a6654ed6af1a67fc48d assets/airdef/items/deploy_radar.json d93b6bf77de4aed1f1955e76353661729f06445788ad7a6654ed6af1a67fc48d assets/airdef/items/deploy_radar.json
84306c42dd25300f1cef69c83e3211ccc921fa606046157295a4ca3e3d568a0a assets/airdef/items/deploy_radar_height.json
28f6b71116bdc911e70d2382807c86edff40adae44acd256f798360dc60bd572 assets/airdef/items/deploy_radar_search.json
0e470cfa2a13383fadb74336c5333449f4079659d9d83596dcfcf2d592521a4c assets/airdef/items/deploy_radar_track.json
0b9445f3b54a9e958da0b9bd4243a41d85fc8f12b5c4e56bbc070edb8f1bf618 assets/airdef/items/deploy_s400.json 0b9445f3b54a9e958da0b9bd4243a41d85fc8f12b5c4e56bbc070edb8f1bf618 assets/airdef/items/deploy_s400.json
77355fc96ed50feb117bc6e7f7f70e9559bc69174a7a84afe7e3121db65efbfd assets/airdef/items/deploy_s400_launcher.json
dd7478f447d87dcad42e1a7e6dcb5fae555c832e933a3722022d0e10e2de011e assets/airdef/items/deploy_s500.json dd7478f447d87dcad42e1a7e6dcb5fae555c832e933a3722022d0e10e2de011e assets/airdef/items/deploy_s500.json
47dabb117d3e6fb44005f4be8c2be2b6c4f8d7e06ff5ed2d426ac1e58e6408ce assets/airdef/items/deploy_s500_launcher.json
14e9a20dcddee5a6262ef624783900576dac2bd16e5079e731cf6115f13c76ec assets/airdef/items/deploy_tor.json 14e9a20dcddee5a6262ef624783900576dac2bd16e5079e731cf6115f13c76ec assets/airdef/items/deploy_tor.json
d4ff57f630ca92bf52ba228d8c6fd5292928b685d6bb5a9c9b9dc0c3d586fc2e assets/airdef/items/deploy_tzm.json d4ff57f630ca92bf52ba228d8c6fd5292928b685d6bb5a9c9b9dc0c3d586fc2e assets/airdef/items/deploy_tzm.json
044fc626ad99ff8be6db0800f96dc743fc80606d813bd59abad531396bf9d8ce assets/airdef/items/designator.json 044fc626ad99ff8be6db0800f96dc743fc80606d813bd59abad531396bf9d8ce assets/airdef/items/designator.json
@@ -136,8 +142,8 @@ b4d98a938486d49db28c6c7a608ca3b6ab0c9c3eac266ecf12c7dd931cc28f93 assets/airdef/
489799dcb5b441e9d4be8bfb3d73a6ebd5fdf2b5ee614b62f38b85bb2fbfad75 assets/airdef/items/launch_zircon.json 489799dcb5b441e9d4be8bfb3d73a6ebd5fdf2b5ee614b62f38b85bb2fbfad75 assets/airdef/items/launch_zircon.json
6b6da5887aa8d9bc987b2c181c243bc2afdd5846a869818f699b59204e559929 assets/airdef/items/mover.json 6b6da5887aa8d9bc987b2c181c243bc2afdd5846a869818f699b59204e559929 assets/airdef/items/mover.json
177f7535e4c52ed975d6f737c2b2acb7741b7a928955c8899aced85211443bbf assets/airdef/items/remover.json 177f7535e4c52ed975d6f737c2b2acb7741b7a928955c8899aced85211443bbf assets/airdef/items/remover.json
cede33ba58f61891a8afe42e1f4311cb293ca93f4d7eb3a57636caff17317a4d assets/airdef/lang/en_us.json ddfba1d8e940c870b43268a5d8ebae130a4061f2f734a750df4bfd54452c8012 assets/airdef/lang/en_us.json
cede33ba58f61891a8afe42e1f4311cb293ca93f4d7eb3a57636caff17317a4d assets/airdef/lang/ru_ru.json ddfba1d8e940c870b43268a5d8ebae130a4061f2f734a750df4bfd54452c8012 assets/airdef/lang/ru_ru.json
b9b5b5bec33a77e944552c225ee2f526ab9820fa8fca4b3ccf311f2a325925ee assets/airdef/models/block/amraam_missile.json b9b5b5bec33a77e944552c225ee2f526ab9820fa8fca4b3ccf311f2a325925ee assets/airdef/models/block/amraam_missile.json
c54e6b24ab69e9d9a2dbbbc63fe2ac60fa37735bf644500ddd5c3de0b91908cf assets/airdef/models/block/barge.json c54e6b24ab69e9d9a2dbbbc63fe2ac60fa37735bf644500ddd5c3de0b91908cf assets/airdef/models/block/barge.json
a4198ff647de5866919f9b82a3d53e6486fc56cc9f175f7907951d063a6f4526 assets/airdef/models/block/beam.json a4198ff647de5866919f9b82a3d53e6486fc56cc9f175f7907951d063a6f4526 assets/airdef/models/block/beam.json
@@ -254,12 +260,18 @@ a5d0450da8d6757b9b45f86e6b36977894dd9e3e1278c3668b99a8acab36f399 assets/airdef/
e80ee81085241b9712e024bbef73ef744ef5493eebb88770f4912d8aae138fe6 assets/airdef/models/item/deploy_irist.json e80ee81085241b9712e024bbef73ef744ef5493eebb88770f4912d8aae138fe6 assets/airdef/models/item/deploy_irist.json
637b9bfe426ee50045f8fcbfd4f25dfbc1d819ce36dedbd60abdac63c274f088 assets/airdef/models/item/deploy_light.json 637b9bfe426ee50045f8fcbfd4f25dfbc1d819ce36dedbd60abdac63c274f088 assets/airdef/models/item/deploy_light.json
3398844e90203f97ee73e35619684c775d1856c8ca3399b5ed682786170d9327 assets/airdef/models/item/deploy_nasams.json 3398844e90203f97ee73e35619684c775d1856c8ca3399b5ed682786170d9327 assets/airdef/models/item/deploy_nasams.json
332f9de8c88658a562748fc7a6de7ec37847273ac0cd0733e23c0dff4b44418c assets/airdef/models/item/deploy_optical.json
76019c05d070cf1141cdf95b744b3d6198ab99469dba1f88a6903de1de303bde assets/airdef/models/item/deploy_p1sun.json 76019c05d070cf1141cdf95b744b3d6198ab99469dba1f88a6903de1de303bde assets/airdef/models/item/deploy_p1sun.json
8b1af688bc83be5a8065673bca7054deee86ca425f0bfd1fb4ffb491844e90bf assets/airdef/models/item/deploy_pantsir.json 8b1af688bc83be5a8065673bca7054deee86ca425f0bfd1fb4ffb491844e90bf assets/airdef/models/item/deploy_pantsir.json
d0091d809816350c648e532a90ae59a3c5c9b94f837b2a46b5695e7f985a00f9 assets/airdef/models/item/deploy_patriot.json d0091d809816350c648e532a90ae59a3c5c9b94f837b2a46b5695e7f985a00f9 assets/airdef/models/item/deploy_patriot.json
332f9de8c88658a562748fc7a6de7ec37847273ac0cd0733e23c0dff4b44418c assets/airdef/models/item/deploy_radar.json 332f9de8c88658a562748fc7a6de7ec37847273ac0cd0733e23c0dff4b44418c assets/airdef/models/item/deploy_radar.json
332f9de8c88658a562748fc7a6de7ec37847273ac0cd0733e23c0dff4b44418c assets/airdef/models/item/deploy_radar_height.json
332f9de8c88658a562748fc7a6de7ec37847273ac0cd0733e23c0dff4b44418c assets/airdef/models/item/deploy_radar_search.json
332f9de8c88658a562748fc7a6de7ec37847273ac0cd0733e23c0dff4b44418c assets/airdef/models/item/deploy_radar_track.json
9ee1dfa7d2c2587c85a8f73554962a02a06f1969a9a56c56110162dd93db7301 assets/airdef/models/item/deploy_s400.json 9ee1dfa7d2c2587c85a8f73554962a02a06f1969a9a56c56110162dd93db7301 assets/airdef/models/item/deploy_s400.json
9ee1dfa7d2c2587c85a8f73554962a02a06f1969a9a56c56110162dd93db7301 assets/airdef/models/item/deploy_s400_launcher.json
55f1dae5cd7f0126533825c9da3ed3ee316e74d4be8f9bb217a3ebc6f827d24d assets/airdef/models/item/deploy_s500.json 55f1dae5cd7f0126533825c9da3ed3ee316e74d4be8f9bb217a3ebc6f827d24d assets/airdef/models/item/deploy_s500.json
55f1dae5cd7f0126533825c9da3ed3ee316e74d4be8f9bb217a3ebc6f827d24d assets/airdef/models/item/deploy_s500_launcher.json
aca5ea765ca0d84ed12444bf433c024b57d6ea9b9b7cf06449dfbd6892a66ae6 assets/airdef/models/item/deploy_tor.json aca5ea765ca0d84ed12444bf433c024b57d6ea9b9b7cf06449dfbd6892a66ae6 assets/airdef/models/item/deploy_tor.json
67912cc711c2f1514e6e2f8f17aa340fa9a99534fbbaeb2b8e319aa6ef80f38d assets/airdef/models/item/deploy_tzm.json 67912cc711c2f1514e6e2f8f17aa340fa9a99534fbbaeb2b8e319aa6ef80f38d assets/airdef/models/item/deploy_tzm.json
d0976d990130c6398f4adf5d3086e9cf50e5a2adbec081e4682e810af368c332 assets/airdef/models/item/designator.json d0976d990130c6398f4adf5d3086e9cf50e5a2adbec081e4682e810af368c332 assets/airdef/models/item/designator.json
@@ -567,12 +579,18 @@ cc0877f40434365b45b03429222926aa0cf135e504017311be53263fd27c5f8f data/airdef/ho
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_irist.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_irist.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_light.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_light.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_nasams.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_nasams.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_optical.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_p1sun.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_p1sun.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_pantsir.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_pantsir.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_patriot.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_patriot.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_radar.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_radar.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_radar_height.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_radar_search.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_radar_track.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_s400.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_s400.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_s400_launcher.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_s500.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_s500.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_s500_launcher.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_tor.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_tor.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_tzm.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/deploy_tzm.json
2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/designator.json 2a3912a7c9d5bb8025b1ac16a1a1d6b5eff0360bb3184e810d319e498255bf97 data/airdef/horizon/item/designator.json
+8 -1
View File
@@ -209,6 +209,10 @@ fn post(uv: vec2<f32>, pixel: vec2<f32>) -> vec4<f32> {
let on_screen = radius / max(length(centre), 1.0); let on_screen = radius / max(length(centre), 1.0);
let steps = i32(clamp(on_screen * 40.0, 6.0, 14.0)); let steps = i32(clamp(on_screen * 40.0, 6.0, 14.0));
let ds = (t1 - t0) / f32(steps); let ds = (t1 - t0) / f32(steps);
// At zero fade every step's density is zero: absorb is 0, so the march adds no light and
// leaves the transmittance alone. Skip it (the HD smoke path fades out by k = 0.28) instead
// of sampling the noise and shading a volume that cannot be seen.
if fade > 0.0 {
for (var s = 0; s < steps; s++) { for (var s = 0; s < steps; s++) {
if trans < 0.02 { break; } if trans < 0.02 { break; }
let p = dir * (t0 + (f32(s) + 0.5) * ds); let p = dir * (t0 + (f32(s) + 0.5) * ds);
@@ -226,10 +230,13 @@ fn post(uv: vec2<f32>, pixel: vec2<f32>) -> vec4<f32> {
lit += trans * absorb * c; lit += trans * absorb * c;
trans *= 1.0 - absorb; trans *= 1.0 - absorb;
} }
// Light thrown round by the fire. }
// Light thrown round by the fire (zero once its heat is spent).
if heat > 0.0 {
let d = length(centre); let d = length(centre);
glow += vec3<f32>(1.0, 0.5, 0.15) * heat * heat * size * 0.05 / (1.0 + d * 0.03); glow += vec3<f32>(1.0, 0.5, 0.15) * heat * heat * size * 0.05 / (1.0 + d * 0.03);
} }
}
color = color * trans + lit; color = color * trans + lit;
// 3. Flashes (#51): a huge bright bloom at the blast, a wide halo that lifts the sky and the // 3. Flashes (#51): a huge bright bloom at the blast, a wide halo that lifts the sky and the
+186 -15
View File
@@ -1,22 +1,34 @@
//! Player-facing labels for battery configuration snapshots. //! Player-facing labels for battery configuration and status.
use crate::sim::battery::{BatteryStatus, RadarRole, SamMode}; use crate::sim::battery::{BatteryStatus, RadarProfile, SamMode};
use crate::sim::{Sam, SamKind};
pub fn radar_role_name(role: RadarRole) -> &'static str { /// One profile's functions in a line the player can read.
match role { pub fn radar_profile_line(profile: RadarProfile) -> String {
RadarRole::Multifunction => "многофункциональная", let channels = if profile.channels == 0 { "без каналов уточнения".to_string() } else { format!("каналы {}", profile.channels) };
RadarRole::Search => "обзорная", format!(
RadarRole::Engagement => "сопровождения", "{} [{}]: {}, оборот {:.1} с, {}, локальный поиск {}; развёртывание: {}",
RadarRole::Height => "мачтовая", profile.name,
} profile.id,
profile.products_text(),
profile.cycle as f64 / 20.0,
channels,
if profile.local >= 1.0 { "во всей дальности".to_string() } else { format!("{:.0}% дальности", profile.local * 100.0) },
profile.deployment,
)
} }
pub fn status(status: BatteryStatus) -> String { pub fn status(status: BatteryStatus) -> String {
match status { match status {
BatteryStatus::Radar { index, role, emitting, operational } => format!( BatteryStatus::Radar { index, role, emitting, operational } => {
"№{} РЛС: {}, излучение {}, {}", index + 1, radar_role_name(role), let profile = role.profile();
format!(
"№{} РЛС: {}; излучение {}, {}",
index + 1,
radar_profile_line(profile),
if emitting { "вкл" } else { "выкл" }, if emitting { "вкл" } else { "выкл" },
if operational { "работает" } else { "нет связи или РЛС не работает" } if operational { "работает" } else { "нет связи или РЛС не работает" }
), )
}
BatteryStatus::Launcher { index, kind, mode, linked } => format!( BatteryStatus::Launcher { index, kind, mode, linked } => format!(
"№{} {}: {}{}", index + 1, kind.name(), mode.key(), "№{} {}: {}{}", index + 1, kind.name(), mode.key(),
if mode == SamMode::LauncherOnly { if mode == SamMode::LauncherOnly {
@@ -26,15 +38,174 @@ pub fn status(status: BatteryStatus) -> String {
} }
} }
/// One system's line in the summary panel and on the map.
pub fn sam_status(sam: &Sam, now: u64) -> String {
let spec = sam.kind.spec();
let mut text = spec.name.to_string();
if !sam.alive() {
return text + " УНИЧТОЖЕН";
}
if sam.moving() {
return text + " " + &sam.state.name().to_lowercase();
}
match sam.kind {
SamKind::Depot => return format!("{text}: {} перезарядок, RM48U {}, снятых ПВО {}", sam.cargo, sam.ground_stock, sam.air_48n6_stock),
SamKind::Tzm => return format!(
"{text}: на борту {}/2, RM48U {}, снятых ПВО {}{}",
sam.cargo,
sam.ground_stock,
sam.air_48n6_stock,
if sam.return_cargo { ", везёт RM48U на склад" } else if sam.job().is_some() { ", в пути" } else { "" }
),
SamKind::Ew => {
let state = if sam.ew_on { "ГЛУШИТ" } else if sam.ew_lock { "остывает" } else { "готова" };
return format!("{text}: {state}, нагрев {:.0}%", sam.heat * 100.0);
}
SamKind::Radar => {
let broken = if sam.comps.whole() { String::new() } else { format!(" [{}]", crate::why_view::worst(&sam.comps, sam.kind)) };
let profile = sam.radar_profile();
let channels = if profile.channels == 0 {
"без уточнения".to_string()
} else {
format!("каналы {}/{}", sam.own_channels_used(now), profile.channels)
};
return format!("{text} «{}»: {}; целей {}{broken}, {channels}", profile.name, profile.products_text(), sam.own.len());
}
SamKind::Light => return format!("{text}{}", if sam.target.is_some() { ": в луче цель" } else { "" }),
SamKind::Optical => {
let mut t = format!("{text}: {}", sam.optical.status_text());
if sam.health < 1.0 {
t += &format!(" ({:.0}%)", sam.health * 100.0);
}
if !sam.comps.whole() {
t += &format!(" [{}]", crate::why_view::worst(&sam.comps, sam.kind));
}
return t;
}
_ => {}
}
if let Some(cell) = sam.preparing_cell() {
text += &format!(" · открытие ТПК №{}", cell + 1);
}
if sam.empty && sam.missiles == 0 {
text += " ЖДЁТ БК";
}
if sam.health < 1.0 {
text += &format!(" ({:.0}%)", sam.health * 100.0);
}
if !sam.comps.whole() {
text += &format!(" [{}]", crate::why_view::worst(&sam.comps, sam.kind));
}
if sam.reloading > 0 {
text += &format!(" перезарядка {}с", sam.reloading.div_ceil(20));
} else {
if let Some(magazine) = sam.kind.missile_magazine() {
if sam.kind == SamKind::S400 {
text += &format!(" ПВО {} · RM48U {} / {} ячеек", sam.missiles, sam.ground_rounds, sam.cells());
if sam.ground_return { text += " · ожидает вывоза RM48U"; }
} else {
text += &format!(" ракеты {}/{}", sam.missiles, magazine);
}
}
if sam.kind.has_gun() {
text += &format!(" очереди {}", sam.bursts);
}
}
text
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::sim::SamKind; use crate::sim::battery::RadarRole;
use crate::sim::{Part, Sam, SamKind, SamState};
use glam::DVec3;
#[test]
fn renders_system_status_in_existing_format() {
let mut s400 = Sam::new(1, SamKind::S400, DVec3::ZERO, 0.0);
s400.missiles = 1;
s400.ground_rounds = 2;
assert_eq!(sam_status(&s400, 0), "С-400 ПВО 1 · RM48U 2 / 4 ячеек");
s400.ground_return = true;
assert_eq!(sam_status(&s400, 0), "С-400 ПВО 1 · RM48U 2 / 4 ячеек · ожидает вывоза RM48U");
let mut pantsir = Sam::new(2, SamKind::Pantsir, DVec3::ZERO, 0.0);
pantsir.missiles = 7;
pantsir.bursts = 100;
assert_eq!(sam_status(&pantsir, 0), "Панцирь-С1 ракеты 7/12 очереди 100");
let mut worn = Sam::new(3, SamKind::Patriot, DVec3::ZERO, 0.0);
worn.health = 0.5;
worn.comps.0[Part::Sensor as usize] = 0.4;
worn.reloading = 21;
assert_eq!(sam_status(&worn, 0), "Patriot (50%) [РЛС 40%] перезарядка 2с");
}
#[test]
fn renders_special_system_lines_in_existing_format() {
let mut radar = Sam::new(4, SamKind::Radar, DVec3::ZERO, 0.0);
radar.own.push(7);
radar.comps.0[Part::Sensor as usize] = 0.0;
assert_eq!(sam_status(&radar, 0), "РЛС дальнего обнаружения «многофункциональная»: обзор, уточнение, пуск; целей 1 [РЛС отказ], каналы 0/3");
let mut depot = Sam::new(5, SamKind::Depot, DVec3::ZERO, 0.0);
depot.cargo = 2;
depot.ground_stock = 3;
depot.air_48n6_stock = 1;
assert_eq!(sam_status(&depot, 0), "Склад боеприпасов: 2 перезарядок, RM48U 3, снятых ПВО 1");
let mut tzm = Sam::new(6, SamKind::Tzm, DVec3::ZERO, 0.0);
tzm.cargo = 1;
tzm.return_cargo = true;
assert_eq!(sam_status(&tzm, 0), "ТЗМ: на борту 1/2, RM48U 0, снятых ПВО 0, везёт RM48U на склад");
let mut ew = Sam::new(7, SamKind::Ew, DVec3::ZERO, 0.0);
ew.ew_on = true;
ew.heat = 0.5;
assert_eq!(sam_status(&ew, 0), "Станция РЭБ: ГЛУШИТ, нагрев 50%");
let mut light = Sam::new(8, SamKind::Light, DVec3::ZERO, 0.0);
light.target = Some(1);
assert_eq!(sam_status(&light, 0), "Прожектор: в луче цель");
let optical = Sam::new(9, SamKind::Optical, DVec3::ZERO, 0.0);
assert_eq!(sam_status(&optical, 0), "Оптический пост: ищет");
}
#[test]
fn renders_moving_and_destroyed_systems_in_existing_format() {
let mut moving = Sam::new(9, SamKind::S400, DVec3::ZERO, 0.0);
moving.state = SamState::Moving;
assert_eq!(sam_status(&moving, 0), "С-400 на марше");
let mut dead = Sam::new(10, SamKind::S400, DVec3::ZERO, 0.0);
dead.health = 0.0;
assert_eq!(sam_status(&dead, 0), "С-400 УНИЧТОЖЕН");
}
#[test]
fn profiles_explain_their_different_functions() {
for role in [RadarRole::Search, RadarRole::Height, RadarRole::Engagement, RadarRole::Multifunction] {
let text = radar_profile_line(role.profile());
assert!(text.contains(role.profile().id));
assert!(text.contains(&format!("оборот {:.1} с", role.profile().cycle as f64 / 20.0)));
}
assert!(radar_profile_line(RadarRole::Search.profile()).contains("без каналов"));
assert!(radar_profile_line(RadarRole::Engagement.profile()).contains("каналы 2"));
assert!(radar_profile_line(RadarRole::Height.profile()).contains("уточнение"));
}
#[test] #[test]
fn renders_battery_status_in_existing_format() { fn renders_battery_status_in_existing_format() {
assert_eq!(status(BatteryStatus::Radar { index: 0, role: RadarRole::Search, emitting: false, operational: false }), "№1 РЛС: обзорная, излучение выкл, нет связи или РЛС не работает"); assert_eq!(
assert_eq!(status(BatteryStatus::Radar { index: 1, role: RadarRole::Engagement, emitting: true, operational: true }), "№2 РЛС: сопровождения, излучение вкл, работает"); status(BatteryStatus::Radar { index: 0, role: RadarRole::Search, emitting: false, operational: false }),
"№1 РЛС: дальнего обзора [radar_search]: обзор, оборот 8.5 с, без каналов уточнения, локальный поиск во всей дальности; развёртывание: крупная стационарная антенна; излучение выкл, нет связи или РЛС не работает"
);
assert_eq!(
status(BatteryStatus::Radar { index: 1, role: RadarRole::Engagement, emitting: true, operational: true }),
"№2 РЛС: сопровождения [radar_track]: обзор, уточнение, пуск, оборот 3.5 с, каналы 2, локальный поиск 12% дальности; развёртывание: мобильная панель; излучение вкл, работает"
);
assert_eq!(status(BatteryStatus::Launcher { index: 2, kind: SamKind::S400, mode: SamMode::LauncherOnly, linked: true }), "№3 С-400: launcher, РЛС связана"); assert_eq!(status(BatteryStatus::Launcher { index: 2, kind: SamKind::S400, mode: SamMode::LauncherOnly, linked: true }), "№3 С-400: launcher, РЛС связана");
assert_eq!(status(BatteryStatus::Launcher { index: 3, kind: SamKind::S500, mode: SamMode::LauncherOnly, linked: false }), "№4 С-500: launcher, нет связанной РЛС сопровождения"); assert_eq!(status(BatteryStatus::Launcher { index: 3, kind: SamKind::S500, mode: SamMode::LauncherOnly, linked: false }), "№4 С-500: launcher, нет связанной РЛС сопровождения");
assert_eq!(status(BatteryStatus::Launcher { index: 4, kind: SamKind::S400, mode: SamMode::Integrated, linked: false }), "№5 С-400: integrated"); assert_eq!(status(BatteryStatus::Launcher { index: 4, kind: SamKind::S400, mode: SamMode::Integrated, linked: false }), "№5 С-400: integrated");
+6 -1
View File
@@ -95,6 +95,7 @@ pub fn diagnostics() -> String {
let lights = render::point_lights_status(); let lights = render::point_lights_status();
let sources = render::sound_sources_status(); let sources = render::sound_sources_status();
let cameras = render::camera_status(); let cameras = render::camera_status();
let dlss = render::dlss_status();
let smoke_reason = match smoke.reason { let smoke_reason = match smoke.reason {
render::SmokeReason::AwaitingFrame => "awaiting-frame", render::SmokeReason::AwaitingFrame => "awaiting-frame",
render::SmokeReason::Disabled => "disabled", render::SmokeReason::Disabled => "disabled",
@@ -102,7 +103,7 @@ pub fn diagnostics() -> String {
render::SmokeReason::Ready => "ready", render::SmokeReason::Ready => "ready",
}; };
[ [
"Возможности движка (API 30; подготовка не означает готовый GPU-кадр, слышимый звук или файл):".into(), "Возможности движка (API 33; подготовка не означает готовый GPU-кадр, слышимый звук или файл):".into(),
line( line(
"Дым", "Дым",
smoke.generation, smoke.generation,
@@ -149,6 +150,10 @@ pub fn diagnostics() -> String {
capture.prepared, capture.prepared,
reason(capture.reason), reason(capture.reason),
), ),
format!(
"DLSS: устройство={}, включено={} (выкл — родной TAAU; вкл без устройства — при следующем запуске)",
dlss.available, dlss.enabled
),
] ]
.join("\n") .join("\n")
} }
+23 -7
View File
@@ -14,7 +14,7 @@ fn on_off() -> Value {
/// `/airdef ...` as `lib.rs` accepts it. /// `/airdef ...` as `lib.rs` accepts it.
pub fn tree() -> Tree { pub fn tree() -> Tree {
let wave_kinds: Vec<&str> = DroneKind::ALL.iter().map(|k| k.spec().key).chain(["mix"]).collect(); let wave_kinds: Vec<&str> = DroneKind::ALL.iter().map(|k| k.spec().key).chain(["mix"]).collect();
let deploy_kinds: Vec<&str> = SamKind::ALL.iter().map(|k| k.key()).chain(["s400_launcher", "s500_launcher", "radar_search", "radar_track", "radar_height"]).collect(); let deploy_kinds: Vec<&str> = SamKind::ALL.iter().map(|k| k.key()).chain(crate::sim::catalog::VARIANTS.iter().map(|v| v.id)).collect();
let armed: Vec<&str> = SamKind::ARMED.iter().map(|k| k.key()).chain(["all"]).collect(); let armed: Vec<&str> = SamKind::ARMED.iter().map(|k| k.key()).chain(["all"]).collect();
let toggle = |word: &str| Node::lit(word).then(Node::arg("on/off", on_off()).runs()); let toggle = |word: &str| Node::lit(word).then(Node::arg("on/off", on_off()).runs());
Tree::new("airdef").runs().with([ Tree::new("airdef").runs().with([
@@ -57,7 +57,10 @@ pub fn tree() -> Tree {
Node::lit("list").runs(), Node::lit("list").runs(),
Node::lit("delete").then(Node::arg("имя", Value::names(SCENARIOS)).runs()), Node::lit("delete").then(Node::arg("имя", Value::names(SCENARIOS)).runs()),
]), ]),
Node::lit("why").runs().then(Node::arg("номер", Value::int_from(1)).runs()), Node::lit("why").runs().then(
Node::arg("номер", Value::int_from(1)).runs().then(Node::lit("source").runs()),
),
Node::lit("chains").runs().then(Node::arg("батарея", Value::int_from(1)).runs()),
Node::lit("raid").runs(), Node::lit("raid").runs(),
Node::lit("sites").runs(), Node::lit("sites").runs(),
Node::lit("ground-stock").then(Node::arg("склад", Value::int_from(1)).then(Node::arg("количество", Value::int_from(0)).runs())), Node::lit("ground-stock").then(Node::arg("склад", Value::int_from(1)).then(Node::arg("количество", Value::int_from(0)).runs())),
@@ -73,7 +76,7 @@ pub fn tree() -> Tree {
Node::lit("target").then(Node::lit("here").runs()), Node::lit("target").then(Node::lit("here").runs()),
Node::lit("give").runs(), Node::lit("give").runs(),
Node::lit("battery").runs().then(Node::arg("номер", Value::int_from(1)).then(Node::arg("режим", Value::choice(["integrated", "launcher"])).runs())), Node::lit("battery").runs().then(Node::arg("номер", Value::int_from(1)).then(Node::arg("режим", Value::choice(["integrated", "launcher"])).runs())),
Node::lit("radar").then(Node::arg("номер", Value::int_from(1)).then(Node::arg("роль", Value::choice(["on", "off", "multi", "search", "engagement", "height"])).runs())), Node::lit("radar").then(Node::arg("номер", Value::int_from(1)).then(Node::arg("режим", Value::Word(vec!["on".into(), "off".into()])).runs())),
Node::lit("deploy").then(Node::arg("комплекс", Value::choice(deploy_kinds)).runs()), Node::lit("deploy").then(Node::arg("комплекс", Value::choice(deploy_kinds)).runs()),
Node::lit("wave").then( Node::lit("wave").then(
Node::arg("тип", Value::choice(wave_kinds)).runs().then( Node::arg("тип", Value::choice(wave_kinds)).runs().then(
@@ -106,6 +109,7 @@ pub fn tree() -> Tree {
Node::lit("guard").with([Node::lit("off").runs(), Node::arg("объекты", Value::word()).runs()]), Node::lit("guard").with([Node::lit("off").runs(), Node::arg("объекты", Value::word()).runs()]),
Node::lit("reset").runs(), Node::lit("reset").runs(),
])), ])),
Node::lit("recon").runs(),
Node::lit("stats").runs(), Node::lit("stats").runs(),
]) ])
} }
@@ -162,12 +166,12 @@ mod tests {
#[test] #[test]
fn every_branch_of_the_handler_parses() { fn every_branch_of_the_handler_parses() {
for line in [ for line in [
"", "menu", "capabilities", "monitor", "grid", "give", "raid", "repair", "import", "flare", "clear", "stats", "roles", "", "menu", "capabilities", "monitor", "grid", "give", "raid", "repair", "import", "flare", "clear", "stats", "recon", "roles",
"replay", "replay map", "replay full", "replay reel", "replay film", "replay film best", "replay film all", "replay", "replay map", "replay full", "replay reel", "replay film", "replay film best", "replay film all",
"replay film 3", "replay export", "replay export mine", "replay export best", "replay export all", "replay export 3", "replay film 3", "replay export", "replay export mine", "replay export best", "replay export all", "replay export 3",
"replay export mine all fps=30 size=1280x720 crf=18 sec=12.5 noaudio", "replay export fps=60", "replay stop", "replay export mine all fps=30 size=1280x720 crf=18 sec=12.5 noaudio", "replay export fps=60", "replay stop",
"scenario save a", "scenario save a fresh", "scenario load a", "scenario load a force", "scenario list", "scenario save a", "scenario save a fresh", "scenario load a", "scenario load a force", "scenario list",
"scenario delete a", "why", "why 2", "ew on", "ew off", "move 4", "target here", "targets clear", "scenario delete a", "why", "why 2", "why 2 source", "chains", "chains 2", "ew on", "ew off", "move 4", "target here", "targets clear",
"sites", "strike 3", "battery", "battery 1 launcher", "battery 1 integrated", "radar 2 on", "radar 2 off", "radar 2 engagement", "radar 2 search", "deploy s400_launcher", "deploy s500_launcher", "deploy radar_search", "deploy radar_track", "deploy radar_height", "deploy patriot", "deploy light", "deploy s400", "wave mix", "wave shahed", "wave shahed 20", "wave kh101 80 800", "wave shahed 20 4000", "sites", "strike 3", "battery", "battery 1 launcher", "battery 1 integrated", "radar 2 on", "radar 2 off", "radar 2 engagement", "radar 2 search", "deploy s400_launcher", "deploy s500_launcher", "deploy radar_search", "deploy radar_track", "deploy radar_height", "deploy patriot", "deploy light", "deploy s400", "wave mix", "wave shahed", "wave shahed 20", "wave kh101 80 800", "wave shahed 20 4000",
"wave oreshnik 1 60", "damage on", "damage off", "truth on", "shader hd", "shader off", "shader on", "hold on", "lastchance on", "lastchance off", "wave oreshnik 1 60", "damage on", "damage off", "truth on", "shader hd", "shader off", "shader on", "hold on", "lastchance on", "lastchance off",
"roles all default", "doctrine", "doctrine 1 reserve 4", "doctrine all salvo eco", "doctrine 2 sector 90 45", "doctrine 2 sector off", "doctrine 1 guard 1,2", "doctrine 1 reset", "roles patriot drone,jet", "roles pantsir all", "roles tor ballistic", "roles all default", "doctrine", "doctrine 1 reserve 4", "doctrine all salvo eco", "doctrine 2 sector 90 45", "doctrine 2 sector off", "doctrine 1 guard 1,2", "doctrine 1 reset", "roles patriot drone,jet", "roles pantsir all", "roles tor ballistic",
@@ -241,10 +245,10 @@ mod tests {
fn completion_offers_the_next_word_only() { fn completion_offers_the_next_word_only() {
let top = complete("", &[]); let top = complete("", &[]);
for w in ["menu", "monitor", "grid", "replay", "scenario", "why", "raid", "repair", "import", "ew", "flare", "move", for w in ["menu", "monitor", "grid", "replay", "scenario", "why", "raid", "repair", "import", "ew", "flare", "move",
"target", "give", "deploy", "wave", "clear", "targets", "damage", "truth", "shader", "hold", "lastchance", "roles", "doctrine", "stats", "sites", "strike", "ground-stock", "ground-load", "ground-unload", "ground-cancel"] { "target", "give", "deploy", "wave", "clear", "targets", "damage", "truth", "shader", "hold", "lastchance", "roles", "doctrine", "stats", "recon", "sites", "strike", "ground-stock", "ground-load", "ground-unload", "ground-cancel", "chains"] {
assert!(top.contains(&w.to_string()), "{w} in {top:?}"); assert!(top.contains(&w.to_string()), "{w} in {top:?}");
} }
assert_eq!(top.len(), 35); assert_eq!(top.len(), 37);
assert_eq!(complete("rep", &[]), ["repair", "replay"]); assert_eq!(complete("rep", &[]), ["repair", "replay"]);
assert_eq!(complete("replay ", &[]), ["export", "film", "full", "map", "reel", "stop"]); assert_eq!(complete("replay ", &[]), ["export", "film", "full", "map", "reel", "stop"]);
assert_eq!(complete("replay film ", &[]), ["all", "best"]); assert_eq!(complete("replay film ", &[]), ["all", "best"]);
@@ -258,6 +262,18 @@ mod tests {
assert!(complete("wave nothing ", &[]).is_empty()); assert!(complete("wave nothing ", &[]).is_empty());
} }
/// A station's profile is fixed at deployment: completion offers only emission, while an
/// old role word still reaches the handler's explanation instead of a bare parse error.
#[test]
fn radar_completion_offers_emission_only() {
let words = complete("radar 1 ", &[]);
assert_eq!(words.len(), 2, "{words:?}");
assert!(words.contains(&"on".to_string()) && words.contains(&"off".to_string()));
for old in ["multi", "search", "engagement", "height"] {
assert!(tree().parse(&format!("radar 1 {old}")).is_ok(), "`{old}` should reach the handler");
}
}
/// The names follow the data: after a save the new name is offered, after a delete it is gone. /// The names follow the data: after a save the new name is offered, after a delete it is gone.
#[test] #[test]
fn scenario_names_follow_a_save_and_a_delete() { fn scenario_names_follow_a_save_and_a_delete() {
+56 -1
View File
@@ -31,6 +31,9 @@ pub struct SamRec {
pub air_48n6_stock: u32, pub air_48n6_stock: u32,
pub mode: sim::battery::SamMode, pub mode: sim::battery::SamMode,
pub radar_role: sim::battery::RadarRole, pub radar_role: sim::battery::RadarRole,
/// The stable profile ID when the file names one (new saves); old files
/// have only the role key, which migrates to the matching profile.
pub radar_profile: Option<sim::battery::RadarProfile>,
pub spent_cells: u8, pub spent_cells: u8,
pub radar_on: bool, pub radar_on: bool,
} }
@@ -45,6 +48,9 @@ pub struct Layout {
pub wave: Option<Vec<String>>, pub wave: Option<Vec<String>>,
pub far: Option<bool>, pub far: Option<bool>,
pub acoustics: Option<bool>, pub acoustics: Option<bool>,
/// The player's DLSS request; absent in older saves (the engine's own
/// default applies: on where supported).
pub dlss: Option<bool>,
pub effects: Option<(bool, bool)>, pub effects: Option<(bool, bool)>,
pub roles: Vec<(SamKind, u8)>, pub roles: Vec<(SamKind, u8)>,
/// Fire doctrines by the system's place in the file (#47). /// Fire doctrines by the system's place in the file (#47).
@@ -147,10 +153,20 @@ impl Layout {
let radar_on = l.flag(29, "излучение РЛС")?.unwrap_or(true); let radar_on = l.flag(29, "излучение РЛС")?.unwrap_or(true);
let ground_return = l.flag(30, "заявка на вывоз RM48U")?.unwrap_or(false); let ground_return = l.flag(30, "заявка на вывоз RM48U")?.unwrap_or(false);
let return_cargo = l.flag(31, "возвращаемый груз RM48U")?.unwrap_or(false); let return_cargo = l.flag(31, "возвращаемый груз RM48U")?.unwrap_or(false);
let radar_profile = match l.w.get(32) {
None => None,
Some(v) => Some(sim::battery::RadarProfile::from_id(v).ok_or_else(|| l.bad("профиль РЛС", "radar_multi, radar_search, radar_track или radar_height"))?),
};
if (ground_return && (kind != SamKind::S400 || ground_request || ground_rounds == 0)) || (return_cargo && (kind != SamKind::Tzm || ground_stock == 0)) { return Err(l.bad("возврат RM48U", "несовместимое состояние")); } if (ground_return && (kind != SamKind::S400 || ground_request || ground_rounds == 0)) || (return_cargo && (kind != SamKind::Tzm || ground_stock == 0)) { return Err(l.bad("возврат RM48U", "несовместимое состояние")); }
if radar_role != sim::battery::RadarRole::Multifunction && kind != SamKind::Radar { if radar_role != sim::battery::RadarRole::Multifunction && kind != SamKind::Radar {
return Err(l.bad("роль РЛС", "роль поддерживается только отдельной РЛС")); return Err(l.bad("роль РЛС", "роль поддерживается только отдельной РЛС"));
} }
if let Some(profile) = radar_profile {
if kind != SamKind::Radar { return Err(l.bad("профиль РЛС", "профиль поддерживается только отдельной РЛС")); }
if profile.role() != radar_role { return Err(l.bad("профиль РЛС", "профиль и роль не совпадают")); }
}
// An old line has only the role: it migrates to the matching profile.
let radar_profile = radar_profile.or((kind == SamKind::Radar).then(|| sim::battery::RadarProfile::of(radar_role)));
if mode == sim::battery::SamMode::LauncherOnly && !matches!(kind, SamKind::S400 | SamKind::S500) { if mode == sim::battery::SamMode::LauncherOnly && !matches!(kind, SamKind::S400 | SamKind::S500) {
return Err(l.bad("режим", "пусковая поддерживается только С-400 и С-500")); return Err(l.bad("режим", "пусковая поддерживается только С-400 и С-500"));
} }
@@ -160,7 +176,7 @@ impl Layout {
if let Some((m, _, _, _)) = ammo && m + ground_rounds > 4 && kind == SamKind::S400 { if let Some((m, _, _, _)) = ammo && m + ground_rounds > 4 && kind == SamKind::S400 {
return Err(l.bad("боезапас", "больше четырёх ячеек")); return Err(l.bad("боезапас", "больше четырёх ячеек"));
} }
out.sams.push(SamRec { kind, pos, heading, roles, health, cargo, ammo, dest, comps, ground_rounds, ground_stock, air_48n6_stock, mode, radar_role, spent_cells, ground_request, radar_on, ground_return, return_cargo }); out.sams.push(SamRec { kind, pos, heading, roles, health, cargo, ammo, dest, comps, ground_rounds, ground_stock, air_48n6_stock, mode, radar_role, radar_profile, spent_cells, ground_request, radar_on, ground_return, return_cargo });
} }
"target" => { "target" => {
if out.targets.len() >= MAX_UNITS { if out.targets.len() >= MAX_UNITS {
@@ -175,6 +191,7 @@ impl Layout {
"strikes" => out.strikes = Some((l.need(1, "запас", 0.0, COUNT)? as u32, l.num(2, "до следующей", 0.0, COUNT)?.map_or(0, |v| v as u32))), "strikes" => out.strikes = Some((l.need(1, "запас", 0.0, COUNT)? as u32, l.num(2, "до следующей", 0.0, COUNT)?.map_or(0, |v| v as u32))),
"far" => out.far = l.flag(1, "значение")?, "far" => out.far = l.flag(1, "значение")?,
"acoustics" => out.acoustics = l.flag(1, "значение")?, "acoustics" => out.acoustics = l.flag(1, "значение")?,
"dlss" => out.dlss = l.flag(1, "значение")?,
"effects" => out.effects = Some((l.flag(1, "шейдер")?.unwrap_or(true), l.flag(2, "HD")?.unwrap_or(false))), "effects" => out.effects = Some((l.flag(1, "шейдер")?.unwrap_or(true), l.flag(2, "HD")?.unwrap_or(false))),
"seed" => { "seed" => {
let v = l.w.get(1).ok_or_else(|| l.bad("значение", "строка оборвана"))?; let v = l.w.get(1).ok_or_else(|| l.bad("значение", "строка оборвана"))?;
@@ -220,6 +237,7 @@ mod tests {
assert_eq!(l.sams[0].mode, sim::battery::SamMode::LauncherOnly); assert_eq!(l.sams[0].mode, sim::battery::SamMode::LauncherOnly);
assert_eq!(l.sams[0].spent_cells, 5); assert_eq!(l.sams[0].spent_cells, 5);
assert_eq!(l.sams[1].radar_role, sim::battery::RadarRole::Engagement); assert_eq!(l.sams[1].radar_role, sim::battery::RadarRole::Engagement);
assert_eq!(l.sams[1].radar_profile, Some(sim::battery::RadarProfile::ENGAGEMENT), "an old role-only line migrates");
assert!(!Layout::parse(&data.replace("launcher multi 5", "launcher multi 5 0 false")).unwrap().sams[0].radar_on); assert!(!Layout::parse(&data.replace("launcher multi 5", "launcher multi 5 0 false")).unwrap().sams[0].radar_on);
assert!(Layout::parse(&data.replace("launcher multi 5", "launcher multi 5 0 nope")).is_err()); assert!(Layout::parse(&data.replace("launcher multi 5", "launcher multi 5 0 nope")).is_err());
assert!(Layout::parse(&data.replace("engagement", "invalid")).is_err()); assert!(Layout::parse(&data.replace("engagement", "invalid")).is_err());
@@ -230,6 +248,13 @@ mod tests {
SamKind::Patriot.key() SamKind::Patriot.key()
} }
#[test]
fn an_optical_post_loads_by_its_catalog_key() {
let l = Layout::parse("sam optical 10 70 20 0.5\n").unwrap();
assert_eq!(l.sams[0].kind, SamKind::Optical);
assert_eq!(l.sams[0].mode, sim::battery::SamMode::Integrated);
}
// #86: the issue's file, and the other ways a saved state can be wrong: refused whole, with the line // #86: the issue's file, and the other ways a saved state can be wrong: refused whole, with the line
#[test] #[test]
fn a_damaged_state_is_refused_as_a_whole_with_its_line_and_field() { fn a_damaged_state_is_refused_as_a_whole_with_its_line_and_field() {
@@ -258,6 +283,36 @@ mod tests {
assert!(Layout::parse(&many).is_err(), "no limit on the number of objects"); assert!(Layout::parse(&many).is_err(), "no limit on the number of objects");
} }
#[test]
fn the_dlss_request_round_trips_and_old_saves_keep_the_engine_default() {
assert_eq!(Layout::parse("dlss false\n").unwrap().dlss, Some(false));
assert_eq!(Layout::parse("dlss true\n").unwrap().dlss, Some(true));
assert!(Layout::parse("dlss maybe\n").is_err());
// Older saves have no line: the engine's own default (on) applies.
assert_eq!(Layout::parse("damage true\n").unwrap().dlss, None);
}
#[test]
fn radar_profile_ids_round_trip_and_old_roles_map_to_them() {
let old = "sam radar 1 70 0 0 0 1 0 0 0 0 0 - - - 1 1 1 1 1 1 0 0 0 integrated search";
let l = Layout::parse(old).unwrap();
assert_eq!(l.sams[0].radar_role, sim::battery::RadarRole::Search);
assert_eq!(l.sams[0].radar_profile, Some(sim::battery::RadarProfile::SEARCH));
let new = "sam radar 1 70 0 0 0 1 0 0 0 0 0 - - - 1 1 1 1 1 1 0 0 0 integrated engagement 0 0 true false false radar_track";
let l = Layout::parse(new).unwrap();
assert_eq!(l.sams[0].radar_profile, Some(sim::battery::RadarProfile::ENGAGEMENT));
assert_eq!(l.sams[0].radar_role, sim::battery::RadarRole::Engagement);
assert_eq!(
Layout::parse("sam radar 1 70 0 0 0 1 0 0 0 0 0 - - - 1 1 1 1 1 1 0 0 0 integrated multi 0 0 true false false radar_multi").unwrap().sams[0].radar_profile,
Some(sim::battery::RadarProfile::MULTI)
);
// A profile and the legacy role must agree; a profile on a non-radar is refused.
assert!(Layout::parse(&new.replace("engagement 0", "search 0")).is_err());
assert!(Layout::parse(&new.replace("sam radar", "sam s400").replace("engagement", "multi")).is_err());
assert!(Layout::parse(&new.replace("radar_track", "radar_unknown")).is_err());
assert_eq!(sim::battery::RadarProfile::from_id("multi"), Some(sim::battery::RadarProfile::MULTI));
}
// #86: files made by older builds (no ammunition, no parts, no destination marks) and unknown lines still load // #86: files made by older builds (no ammunition, no parts, no destination marks) and unknown lines still load
#[test] #[test]
fn older_valid_saves_still_load() { fn older_valid_saves_still_load() {
+371 -79
View File
@@ -19,12 +19,14 @@ mod engines;
mod commands; mod commands;
mod layout; mod layout;
mod map; mod map;
mod film; pub mod film;
mod monitor; mod monitor;
mod overlay;
mod panel; mod panel;
mod presentation; mod presentation;
mod radar; mod radar;
mod replay; mod recon_view;
pub mod replay;
mod scene; mod scene;
mod smoke; mod smoke;
pub use airdef_core::sim; pub use airdef_core::sim;
@@ -62,6 +64,9 @@ struct AirDef {
far: bool, far: bool,
/// The acoustics asked for, until the game has them (its answer comes a tick later). /// The acoustics asked for, until the game has them (its answer comes a tick later).
acoustics: Option<bool>, acoustics: Option<bool>,
/// The DLSS request saved for this world; None leaves the engine's own
/// choice (on where supported). The live state is `render::dlss_status`.
dlss: Option<bool>,
/// The game's log of block changes (`render.world-log-start`): a replay shows the world as /// The game's log of block changes (`render.world-log-start`): a replay shows the world as
/// it was at its moment, not the holes the raid left (None where the game has no such log). /// it was at its moment, not the holes the raid left (None where the game has no such log).
block_log: Option<u32>, block_log: Option<u32>,
@@ -77,6 +82,8 @@ struct AirDef {
health_mark: u64, health_mark: u64,
/// The menu's page while it is open. /// The menu's page while it is open.
menu: Option<Page>, menu: Option<Page>,
/// The battery the after-action chain list is filtered to (its id; None: all).
chain_filter: Option<u32>,
/// Where the player is, for the sounds' delay and far variants. /// Where the player is, for the sounds' delay and far variants.
listener: DVec3, listener: DVec3,
/// The picture punch (#51) the HD exposure and bloom were last set for. /// The picture punch (#51) the HD exposure and bloom were last set for.
@@ -96,6 +103,10 @@ struct AirDef {
by_id: Vec<ModelInstanceId>, by_id: Vec<ModelInstanceId>,
/// The command map (#48). /// The command map (#48).
map: map::MapUi, map: map::MapUi,
/// The world overlay's key held (#132): markers over normal gameplay while it is.
overlay_held: bool,
/// The overlay's shapes are the mod's `set-hud` now: cleared when it lets go.
overlay_shown: bool,
} }
/// What `/airdef replay export` was asked for. /// What `/airdef replay export` was asked for.
@@ -191,7 +202,6 @@ fn travels(event: &str) -> bool {
#[derive(Clone, Copy, PartialEq)] #[derive(Clone, Copy, PartialEq)]
enum Page { enum Page {
Main, Main,
BatteryDeploy,
Roles(SamKind), Roles(SamKind),
/// The raid's make-up, then its parameters and the launch. /// The raid's make-up, then its parameters and the launch.
Wave, Wave,
@@ -200,33 +210,29 @@ enum Page {
More, More,
/// The last raid's events and its replays. /// The last raid's events and its replays.
Replays, Replays,
/// The last raid's short battle chains: mark → handoff → lock → launch → outcome (#148).
Chains,
/// The enemy's recon picture and why it prices each mark: debug and after-action review (#135).
Recon,
/// The systems with their doctrines, and one system's doctrine (by id) (#47). /// The systems with their doctrines, and one system's doctrine (by id) (#47).
Fleet, Fleet,
Doctrine(u32), Doctrine(u32),
} }
const MENU_KINDS: u32 = 1; const MENU_KINDS: u32 = 1;
const BATTERY_ROWS: u32 = 5;
const BTN_BATTERY: u32 = 22;
const BATTERY_DEPLOY: [(&str, &str); 5] = [
("s400_launcher", "С-400 — отдельная пусковая"),
("s500_launcher", "С-500 — отдельная пусковая"),
("radar_search", "РЛС обзора"),
("radar_track", "РЛС сопровождения"),
("radar_height", "Мачтовая РЛС"),
];
/// A battery deploy piece from the catalog: a unit kind, one of its variants, or
/// the remote item that places either.
fn deploy_configuration(key: &str) -> Option<(SamKind, sim::battery::SamMode, sim::battery::RadarRole)> { fn deploy_configuration(key: &str) -> Option<(SamKind, sim::battery::SamMode, sim::battery::RadarRole)> {
use sim::battery::{RadarRole as R, SamMode as M}; use sim::battery::{RadarRole as R, SamMode as M};
Some(match key { if let Some(config) = sim::catalog::deploy_item_configuration(key) { return Some(config); }
"s400_launcher" => (SamKind::S400, M::LauncherOnly, R::Multifunction), match sim::catalog::variant(key) {
"s500_launcher" => (SamKind::S500, M::LauncherOnly, R::Multifunction), Some(v) => Some((v.kind, v.mode, v.role)),
"radar_search" => (SamKind::Radar, M::Integrated, R::Search), // A bare kind deploys its ordinary integrated configuration.
"radar_track" => (SamKind::Radar, M::Integrated, R::Engagement), None => Some((SamKind::from_key(key)?, M::Integrated, R::Multifunction)),
"radar_height" => (SamKind::Radar, M::Integrated, R::Height), }
_ => (SamKind::from_key(key)?, M::Integrated, R::Multifunction),
})
} }
const BTN_HOLD: u32 = 10; const BTN_HOLD: u32 = 10;
const BTN_SHADER: u32 = 11; const BTN_SHADER: u32 = 11;
const BTN_DAMAGE: u32 = 12; const BTN_DAMAGE: u32 = 12;
@@ -243,12 +249,18 @@ const BTN_LAUNCH: u32 = 34;
const BTN_NEXT: u32 = 35; const BTN_NEXT: u32 = 35;
const BTN_MORE: u32 = 17; const BTN_MORE: u32 = 17;
const BTN_REPLAYS: u32 = 18; const BTN_REPLAYS: u32 = 18;
const BTN_RECON: u32 = 23;
const REPLAY_EVENTS: u32 = 3; const REPLAY_EVENTS: u32 = 3;
const RECON_ROWS: u32 = 6;
const CHAIN_ROWS: u32 = 7;
const BTN_CHAINS: u32 = 43;
const BTN_CHAIN_FILTER: u32 = 44;
const BTN_MAP: u32 = 40; const BTN_MAP: u32 = 40;
const BTN_FULL: u32 = 41; const BTN_FULL: u32 = 41;
const BTN_REEL: u32 = 42; const BTN_REEL: u32 = 42;
const BTN_FAR: u32 = 19; const BTN_FAR: u32 = 19;
const BTN_ACOUSTICS: u32 = 20; const BTN_ACOUSTICS: u32 = 20;
const BTN_DLSS: u32 = 24;
const BTN_DOCTRINE: u32 = 21; const BTN_DOCTRINE: u32 = 21;
const FLEET_ROWS: u32 = 4; const FLEET_ROWS: u32 = 4;
const BTN_RESERVE: u32 = 50; const BTN_RESERVE: u32 = 50;
@@ -342,21 +354,16 @@ impl AirDef {
None => say("Наведитесь на блок или отметьте цель"), None => say("Наведитесь на блок или отметьте цель"),
} }
} }
_ if sim::catalog::deploy_item(id).is_some() => { _ if sim::catalog::deploy_item_configuration(id).is_some() => {
let Some(kind) = sim::catalog::deploy_item(id) else { return }; let Some((kind, mode, role)) = sim::catalog::deploy_item_configuration(id) else { return };
match aim() { match aim() {
Some(at) => { Some(at) => {
let d = view(&p); let d = view(&p);
let heading = (-d.x).atan2(-d.z); let heading = (-d.x).atan2(-d.z);
let sid = self.sim.id(); self.place(kind, mode, role, at, heading);
let mut sam = Sam::new(sid, kind, at, heading);
if let Some(r) = self.sim.roles.get(&kind) {
sam.roles = *r;
}
self.sim.sams.push(sam);
out.sound("minecraft:block.anvil.place", at, 2.0, 0.7); out.sound("minecraft:block.anvil.place", at, 2.0, 0.7);
say(&format!("{} развёрнут", kind.name())); let profile = if kind == SamKind::Radar { format!(", профиль {}", role.profile().id) } else { String::new() };
self.dirty = true; say(&format!("{} развёрнут{profile}", kind.name()));
} }
None => say("Наведитесь на землю, где поставить комплекс"), None => say("Наведитесь на землю, где поставить комплекс"),
} }
@@ -544,6 +551,11 @@ impl AirDef {
self.acoustics.unwrap_or_else(render::acoustics) self.acoustics.unwrap_or_else(render::acoustics)
} }
/// The DLSS request: this world's saved one, else the engine's live state.
fn dlss_on(&self) -> bool {
self.dlss.unwrap_or_else(|| render::dlss_status().enabled)
}
/// The effects preset: none, the post pass, or the post pass under the HD lighting. /// The effects preset: none, the post pass, or the post pass under the HD lighting.
fn set_effects(&mut self, shader: bool, hd: bool) { fn set_effects(&mut self, shader: bool, hd: bool) {
self.sim.shader = shader; self.sim.shader = shader;
@@ -879,7 +891,24 @@ impl AirDef {
} }
self.hud_shown = true; self.hud_shown = true;
hud::set_panel(Corner::TopRight, &panel::summary(&self.sim, &pic, player)); hud::set_panel(Corner::TopRight, &panel::summary(&self.sim, &pic, player));
render::set_corner(render::Corner::BottomRight, radar::SIZE, radar::SIZE + 12.0, &radar::draw(&self.sim, player, yaw)); let truth_label = self.sim.truth && !pic.unaided;
render::set_corner(render::Corner::BottomRight, radar::SIZE, radar::height(truth_label), &radar::draw(&self.sim, player, yaw));
}
/// Whether the world overlay draws now (#132): its key held over normal gameplay — not under
/// a replay, the grid, a monitor or the map, which own the screen themselves.
fn overlay_active(&self) -> bool {
self.overlay_held
&& self.presentation.is_live()
&& !self.grid
&& self.monitor.is_none_or(|i| i >= self.sim.sams.len())
&& !self.map.open
}
fn draw_overlay(&mut self) {
let Some(p) = player() else { return };
let shapes = overlay::draw(&self.sim, DVec3::new(p.x, p.y, p.z), render::gui_size(), |w| render::project(w.x, w.y, w.z));
render::set_hud(&shapes);
} }
// ------------------------------------------------ saving // ------------------------------------------------ saving
@@ -907,8 +936,9 @@ impl AirDef {
// The parts' states (sensor, mount, launcher, gun, tracks, comms) close the line; older saves lack them. // The parts' states (sensor, mount, launcher, gun, tracks, comms) close the line; older saves lack them.
let comps = if fresh { new.comps } else { s.comps }; let comps = if fresh { new.comps } else { s.comps };
let parts = comps.0.iter().map(|v| format!("{v:.3}")).collect::<Vec<_>>().join(" "); let parts = comps.0.iter().map(|v| format!("{v:.3}")).collect::<Vec<_>>().join(" ");
let profile = if s.kind == SamKind::Radar { format!(" {}", s.radar_profile().id) } else { String::new() };
text += &format!( text += &format!(
"sam {} {} {} {} {} {} {} {} {} {} {} {} {dest} {parts} {} {} {} {} {} {} {} {} {} {}\n", "sam {} {} {} {} {} {} {} {} {} {} {} {} {dest} {parts} {} {} {} {} {} {} {} {} {} {}{profile}\n",
s.kind.key(), s.kind.key(),
s.pos.x, s.pos.x,
s.pos.y, s.pos.y,
@@ -936,6 +966,7 @@ impl AirDef {
if view { if view {
text += &format!("far {}\n", self.far); text += &format!("far {}\n", self.far);
text += &format!("acoustics {}\n", self.acoustics_on()); text += &format!("acoustics {}\n", self.acoustics_on());
text += &format!("dlss {}\n", self.dlss_on());
text += &format!("effects {} {}\n", self.sim.shader, self.hd); text += &format!("effects {} {}\n", self.sim.shader, self.hd);
} }
for (kind, roles) in &self.sim.roles { for (kind, roles) in &self.sim.roles {
@@ -1061,7 +1092,9 @@ impl AirDef {
sam.air_48n6_stock = r.air_48n6_stock; sam.air_48n6_stock = r.air_48n6_stock;
sam.fit_cells(); sam.fit_cells();
sam.set_mode(r.mode); sam.set_mode(r.mode);
sam.set_radar_role(r.radar_role); // New saves name the stable profile; old ones only the role, which
// parses to the same profile (`Layout::parse`).
sam.set_radar_role(r.radar_profile.map_or(r.radar_role, |p| p.role()));
sam.radar_on = r.radar_on; sam.radar_on = r.radar_on;
sam.spent_cells = r.spent_cells; sam.spent_cells = r.spent_cells;
sam.sync_tube_cells(); sam.sync_tube_cells();
@@ -1096,6 +1129,10 @@ impl AirDef {
self.acoustics = Some(a); self.acoustics = Some(a);
render::set_acoustics(a); render::set_acoustics(a);
} }
if let Some(d) = layout.dlss {
self.dlss = Some(d);
render::set_dlss(d);
}
if let Some(f) = layout.far { if let Some(f) = layout.far {
self.far = f; self.far = f;
} }
@@ -1200,6 +1237,8 @@ impl AirDef {
let shader = self.sim.shader; let shader = self.sim.shader;
let seed = game::get_clock().map_or(0x5eed, |c| c.game_time.wrapping_mul(2654435761) ^ 0x9e37); let seed = game::get_clock().map_or(0x5eed, |c| c.game_time.wrapping_mul(2654435761) ^ 0x9e37);
self.sim = Sim::new(seed); self.sim = Sim::new(seed);
// A fresh world's CPU profile starts from zero (#147 step 3.1).
sim::profile::reset();
self.next_save = 0; self.next_save = 0;
self.sim.shader = shader; self.sim.shader = shader;
self.ground = Ground::default(); self.ground = Ground::default();
@@ -1207,6 +1246,9 @@ impl AirDef {
self.map_close(); self.map_close();
self.grid = false; self.grid = false;
self.grid_ids.clear(); self.grid_ids.clear();
// The overlay key lets go with the world: its camera projects nothing here anyway.
self.overlay_held = false;
self.overlay_shown = false;
// The last world's transient state: its sounds were due on its own // The last world's transient state: its sounds were due on its own
// clock, its picked unit may have another meaning in this one, and // clock, its picked unit may have another meaning in this one, and
// its models would stay until the next full model list. // its models would stay until the next full model list.
@@ -1286,6 +1328,23 @@ impl AirDef {
Ok(()) Ok(())
} }
/// Opens a battle chain's replay frame: its outcome clip when recorded, else the map at the
/// launch (or the mark) held still.
fn start_chain(&mut self, row: replay::ChainRow) -> Result<(), String> {
match row.event {
Some(i) => self.start_replay("clip", Some(i)),
None => {
self.start_replay("map", None)?;
if let Some(player) = self.presentation.playback_mut()
&& let Some(rec) = self.sim.replays.last()
{
player.seek(rec, row.at);
}
Ok(())
}
}
}
fn stop_replay(&mut self) { fn stop_replay(&mut self) {
let was_export = self.presentation.is_exporting(); let was_export = self.presentation.is_exporting();
self.end_session(presentation::ExitCause::UserStop); self.end_session(presentation::ExitCause::UserStop);
@@ -1503,13 +1562,13 @@ impl AirDef {
/// monitored one always; those shown keep a head start, so the grid doesn't flicker. /// monitored one always; those shown keep a head start, so the grid doesn't flicker.
fn pick_grid(&mut self) { fn pick_grid(&mut self) {
let shown = &self.grid_ids; let shown = &self.grid_ids;
// Units that shoot, and the radars; depots, trucks and lights have nothing to show. // Units that shoot, the radars and the passive optics; depots, trucks and lights have nothing to show.
let mut scored: Vec<(f64, u32)> = self let mut scored: Vec<(f64, u32)> = self
.sim .sim
.sams .sams
.iter() .iter()
.enumerate() .enumerate()
.filter(|(_, s)| s.kind.armed() || s.kind == SamKind::Radar) .filter(|(_, s)| s.kind.armed() || s.kind == SamKind::Radar || s.kind == SamKind::Optical)
.map(|(i, s)| { .map(|(i, s)| {
let busy = if self.sim.showing_kill(s) { 98.0 } else { match s.state { let busy = if self.sim.showing_kill(s) { 98.0 } else { match s.state {
sim::SamState::Launch | sim::SamState::Fire => 100.0, sim::SamState::Launch | sim::SamState::Fire => 100.0,
@@ -1523,7 +1582,11 @@ impl AirDef {
sim::SamState::Waiting => 35.0, sim::SamState::Waiting => 35.0,
sim::SamState::Packing | sim::SamState::Moving | sim::SamState::Deploying => 40.0, sim::SamState::Packing | sim::SamState::Moving | sim::SamState::Deploying => 40.0,
} }; } };
let near = self.sim.watched(s).map_or(0.0, |d| 15.0 * (1.0 - (d.pos.distance(s.pos) / s.kind.range()).min(1.0))); let near = if s.kind == SamKind::Optical {
0.0
} else {
self.sim.watched(s).map_or(0.0, |d| 15.0 * (1.0 - (d.pos.distance(s.pos) / s.kind.range()).min(1.0)))
};
let hurt = if s.alive() && s.health < 0.7 { 15.0 } else { 0.0 }; let hurt = if s.alive() && s.health < 0.7 { 15.0 } else { 0.0 };
let keep = if shown.contains(&s.id) { 12.0 } else { 0.0 }; let keep = if shown.contains(&s.id) { 12.0 } else { 0.0 };
let pinned = if self.monitor == Some(i) { 1000.0 } else { 0.0 }; let pinned = if self.monitor == Some(i) { 1000.0 } else { 0.0 };
@@ -1545,21 +1608,28 @@ impl AirDef {
}; };
} }
fn deploy_configured(&mut self, key: &str) -> Result<String, String> { /// Places a configured system at `at` facing `heading` and settles it.
let (kind, mode, role) = deploy_configuration(key).ok_or("Неизвестный вид техники")?; fn place(&mut self, kind: SamKind, mode: sim::battery::SamMode, role: sim::battery::RadarRole, at: DVec3, heading: f64) -> u32 {
let p = player().ok_or("Нет игрока")?;
let d = view(&p);
let flat = DVec3::new(d.x, 0.0, d.z).normalize_or(DVec3::NEG_Z);
let at = DVec3::new(p.x, p.y, p.z) + flat * 8.0;
let id = self.sim.id(); let id = self.sim.id();
let mut sam = Sam::new(id, kind, at, (-flat.x).atan2(-flat.z)); let mut sam = Sam::new(id, kind, at, heading);
sam.set_mode(mode); sam.set_mode(mode);
sam.set_radar_role(role); sam.set_radar_role(role);
if let Some(r) = self.sim.roles.get(&kind) { sam.roles = *r; } if let Some(r) = self.sim.roles.get(&kind) { sam.roles = *r; }
self.sim.sams.push(sam); self.sim.sams.push(sam);
self.sim.settle(id); self.sim.settle(id);
self.dirty = true; self.dirty = true;
Ok(format!("{} развёрнут ({}, {})", kind.name(), mode.key(), role.key())) id
}
fn deploy_configured(&mut self, key: &str) -> Result<String, String> {
let (kind, mode, role) = deploy_configuration(key).ok_or("Неизвестный вид техники")?;
let p = player().ok_or("Нет игрока")?;
let d = view(&p);
let flat = DVec3::new(d.x, 0.0, d.z).normalize_or(DVec3::NEG_Z);
let at = DVec3::new(p.x, p.y, p.z) + flat * 8.0;
self.place(kind, mode, role, at, (-flat.x).atan2(-flat.z));
let profile = if kind == SamKind::Radar { format!(", профиль {}", role.profile().id) } else { String::new() };
Ok(format!("{} развёрнут ({}, {}{profile})", kind.name(), mode.key(), role.key()))
} }
fn open_menu(&mut self, page: Page) { fn open_menu(&mut self, page: Page) {
@@ -1580,19 +1650,14 @@ impl AirDef {
.collect(); .collect();
widgets.push(Widget::List(ListWidget { id: MENU_KINDS, rows, selected: None })); widgets.push(Widget::List(ListWidget { id: MENU_KINDS, rows, selected: None }));
let _ = &self.monitor; let _ = &self.monitor;
widgets.push(Widget::Button(ButtonWidget { id: BTN_BATTERY, label: "Разместить элементы батареи…".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_GRID, label: "Командный пункт: все комплексы (J)".into() })); widgets.push(Widget::Button(ButtonWidget { id: BTN_GRID, label: "Командный пункт: все комплексы (J)".into() }));
let custom = self.sim.sams.iter().filter(|s| !s.doctrine.is_default()).count(); let custom = self.sim.sams.iter().filter(|s| !s.doctrine.is_default()).count();
widgets.push(Widget::Button(ButtonWidget { id: BTN_DOCTRINE, label: format!("Доктрины: охрана, сектор, резерв (особых: {custom})…") })); widgets.push(Widget::Button(ButtonWidget { id: BTN_DOCTRINE, label: format!("Доктрины: охрана, сектор, резерв (особых: {custom})…") }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_WAVE, label: "Налёт: состав и запуск…".into() })); widgets.push(Widget::Button(ButtonWidget { id: BTN_WAVE, label: "Налёт: состав и запуск…".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_REPLAYS, label: "Повторы…".into() })); widgets.push(Widget::Button(ButtonWidget { id: BTN_REPLAYS, label: "Повторы…".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_RECON, label: "Разведка противника (разбор)…".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_MORE, label: "Огонь, ремонт, эффекты…".into() })); widgets.push(Widget::Button(ButtonWidget { id: BTN_MORE, label: "Огонь, ремонт, эффекты…".into() }));
} }
Page::BatteryDeploy => {
title = "Размещение батареи — клик создаёт технику перед игроком".into();
widgets.push(Widget::List(ListWidget { id: BATTERY_ROWS, rows: BATTERY_DEPLOY.iter().map(|(_, name)| (*name).to_string()).collect(), selected: None }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
}
Page::Replays => { Page::Replays => {
match self.sim.replays.last() { match self.sim.replays.last() {
Some(rec) => { Some(rec) => {
@@ -1603,6 +1668,8 @@ impl AirDef {
widgets.push(Widget::Button(ButtonWidget { id: BTN_MAP, label: "Карта налёта (R)".into() })); widgets.push(Widget::Button(ButtonWidget { id: BTN_MAP, label: "Карта налёта (R)".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_FULL, label: "Полный повтор".into() })); widgets.push(Widget::Button(ButtonWidget { id: BTN_FULL, label: "Полный повтор".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_REEL, label: format!("Лучшие моменты ({})", replay::reel(rec).len()) })); widgets.push(Widget::Button(ButtonWidget { id: BTN_REEL, label: format!("Лучшие моменты ({})", replay::reel(rec).len()) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_CHAINS, label: format!("Цепочки боя (разбор): {}", rec.chains(None).len()) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_RECON, label: "Разведка противника (разбор)".into() }));
} }
None => { None => {
title = "Повторы".into(); title = "Повторы".into();
@@ -1611,10 +1678,46 @@ impl AirDef {
text: "Повторов пока нет: налёт записывается сам и появится здесь, когда небо очистится".into(), text: "Повторов пока нет: налёт записывается сам и появится здесь, когда небо очистится".into(),
color: 0, color: 0,
})); }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_CHAINS, label: "Цепочки боя (разбор)".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_RECON, label: "Разведка противника (разбор)".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() })); widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
} }
} }
} }
Page::Chains => {
match self.sim.replays.last() {
Some(rec) => {
let rows = replay::chain_rows(rec, self.chain_filter);
let filter = self.chain_filter.and_then(|id| {
rec.sams.iter().position(|s| s.0 == id).map(|i| format!("№{} {}", i + 1, rec.sam(id).map_or("ПВО", |(k, _)| k.name())))
});
title = format!(
"Цепочки боя: отметка → передача → захват → пуск → исход · {} · фильтр: {} · клик: кадр повтора",
if rows.is_empty() { "нет цепочек".to_string() } else { format!("{}", rows.len()) },
filter.unwrap_or_else(|| "все батареи".into()),
);
let rows = rows.into_iter().take(200).map(|r| r.text).collect();
widgets.push(Widget::List(ListWidget { id: CHAIN_ROWS, rows, selected: None }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_CHAIN_FILTER, label: "Фильтр по батарее".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← К повторам".into() }));
}
None => {
title = "Цепочки боя".into();
widgets.push(Widget::Text(horizon_mod_sdk::ui::TextWidget {
id: 0,
text: "Повторов пока нет: цепочки появятся после первого налёта".into(),
color: 0,
}));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← К повторам".into() }));
}
}
}
Page::Recon => {
title = "Разведка противника — разбор (debug): что враг запомнил и почему".into();
let rows: Vec<String> = recon_view::picture_lines(&self.sim.enemy_picture()).into_iter().take(200).collect();
widgets.push(Widget::List(ListWidget { id: RECON_ROWS, rows, selected: None }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
}
Page::More => { Page::More => {
title = "AirDef — управление".to_string(); title = "AirDef — управление".to_string();
widgets.push(Widget::Button(ButtonWidget { widgets.push(Widget::Button(ButtonWidget {
@@ -1628,6 +1731,18 @@ impl AirDef {
widgets.push(Widget::Button(ButtonWidget { id: BTN_DAMAGE, label: format!("Разрушения: {}", onoff(self.sim.damage)) })); widgets.push(Widget::Button(ButtonWidget { id: BTN_DAMAGE, label: format!("Разрушения: {}", onoff(self.sim.damage)) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_FAR, label: format!("Дальний ландшафт: {}", onoff(self.far)) })); widgets.push(Widget::Button(ButtonWidget { id: BTN_FAR, label: format!("Дальний ландшафт: {}", onoff(self.far)) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_ACOUSTICS, label: format!("Акустика (преграды, эхо): {}", onoff(self.acoustics_on())) })); widgets.push(Widget::Button(ButtonWidget { id: BTN_ACOUSTICS, label: format!("Акустика (преграды, эхо): {}", onoff(self.acoustics_on())) }));
// DLSS: the request shows at once; the engine's live state
// answers availability. Without a DLSS device an on-request
// applies at the next launch.
let dlss = render::dlss_status();
let dlss_label = if dlss.available {
format!("DLSS (сглаживание NVIDIA): {}", onoff(self.dlss_on()))
} else if self.dlss_on() {
"DLSS (NVIDIA): вкл — применится при перезапуске".to_string()
} else {
"DLSS (NVIDIA): выкл (недоступен на этом устройстве)".to_string()
};
widgets.push(Widget::Button(ButtonWidget { id: BTN_DLSS, label: dlss_label }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() })); widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
} }
Page::Wave => { Page::Wave => {
@@ -1819,6 +1934,10 @@ fn help() -> String {
impl Mod for AirDef { impl Mod for AirDef {
fn init() -> Result<(Self, Registration), String> { fn init() -> Result<(Self, Registration), String> {
// The CPU profile's clock (#147 step 3.1): the host's monotonic import.
// Native tests keep the process clock (the import is a wasm-only stub).
#[cfg(target_arch = "wasm32")]
sim::profile::set_clock(game::monotonic_nanos);
let seed = game::get_clock().map_or(0x5eed, |c| c.game_time.wrapping_mul(2654435761) ^ 0x9e37); let seed = game::get_clock().map_or(0x5eed, |c| c.game_time.wrapping_mul(2654435761) ^ 0x9e37);
let mut me = AirDef { let mut me = AirDef {
sim: Sim::new(seed), sim: Sim::new(seed),
@@ -1838,11 +1957,13 @@ impl Mod for AirDef {
smoke: Default::default(), smoke: Default::default(),
far: true, far: true,
acoustics: None, acoustics: None,
dlss: None,
moving: None, moving: None,
hd: false, hd: false,
world: None, world: None,
health_mark: 0, health_mark: 0,
menu: None, menu: None,
chain_filter: None,
listener: DVec3::ZERO, listener: DVec3::ZERO,
punch: 0.0, punch: 0.0,
pending: Vec::new(), pending: Vec::new(),
@@ -1853,8 +1974,12 @@ impl Mod for AirDef {
model_generation: u32::MAX, model_generation: u32::MAX,
by_id: Vec::new(), by_id: Vec::new(),
map: map::MapUi::default(), map: map::MapUi::default(),
overlay_held: false,
overlay_shown: false,
}; };
let _ = input::register_key("map", "Карта: командная, расстановка", "key.keyboard.m"); let _ = input::register_key("map", "Карта: командная, расстановка", "key.keyboard.m");
// C is free in vanilla's bindings and the mod's own; the player may rebind it.
let _ = input::register_key("overlay", "Обзор: метки целей вокруг видимых дронов и ракет (удерживать)", "key.keyboard.c");
let _ = input::register_key("menu", "Меню AirDef", "key.keyboard.n"); let _ = input::register_key("menu", "Меню AirDef", "key.keyboard.n");
let _ = input::register_key("monitor", "Монитор ПВО: следующий комплекс", "key.keyboard.k"); let _ = input::register_key("monitor", "Монитор ПВО: следующий комплекс", "key.keyboard.k");
let _ = input::register_key("grid", "Командный пункт: все комплексы", "key.keyboard.j"); let _ = input::register_key("grid", "Командный пункт: все комплексы", "key.keyboard.j");
@@ -1891,6 +2016,9 @@ impl Mod for AirDef {
for event in input::poll() { for event in input::poll() {
match event { match event {
Event::UseStart(u) => self.use_item(&u.item.id), Event::UseStart(u) => self.use_item(&u.item.id),
// The overlay is a hold, not a toggle (#132): down draws, up clears.
Event::KeyDown(k) if k == "overlay" => self.overlay_held = true,
Event::KeyUp(k) if k == "overlay" => self.overlay_held = false,
Event::KeyDown(k) if k == "map" => self.map_toggle(), Event::KeyDown(k) if k == "map" => self.map_toggle(),
Event::KeyDown(k) if k == "menu" => { Event::KeyDown(k) if k == "menu" => {
if self.presentation.playback().is_some() { if self.presentation.playback().is_some() {
@@ -2087,6 +2215,15 @@ impl Mod for AirDef {
render::set_views(&[]); render::set_views(&[]);
self.monitor_shown = false; self.monitor_shown = false;
} }
// The world overlay owns the HUD while its key is held over normal gameplay;
// the frame hook redraws it every frame, the tick keeps the ownership honest.
if self.overlay_active() {
self.draw_overlay();
self.overlay_shown = true;
} else if self.overlay_shown {
render::set_hud(&[]);
self.overlay_shown = false;
}
} }
} }
} }
@@ -2111,23 +2248,6 @@ impl Mod for AirDef {
} }
return; return;
} }
(Page::Main, BTN_BATTERY) => {
self.open_menu(Page::BatteryDeploy);
return;
}
(Page::BatteryDeploy, BATTERY_ROWS) => {
if let Some((key, _)) = BATTERY_DEPLOY.get(row as usize) {
match self.deploy_configured(key) {
Ok(message) => say(&message),
Err(error) => say(&error),
}
}
return;
}
(Page::BatteryDeploy, BTN_BACK) => {
self.open_menu(Page::Main);
return;
}
(Page::Main, BTN_DOCTRINE) => { (Page::Main, BTN_DOCTRINE) => {
self.open_menu(Page::Fleet); self.open_menu(Page::Fleet);
return; return;
@@ -2262,6 +2382,47 @@ impl Mod for AirDef {
self.open_menu(Page::Main); self.open_menu(Page::Main);
return; return;
} }
(Page::Replays, BTN_CHAINS) => {
self.open_menu(Page::Chains);
return;
}
(Page::Chains, CHAIN_ROWS) => {
let Some(rec) = self.sim.replays.last() else { return };
let Some(row) = replay::chain_rows(rec, self.chain_filter).into_iter().nth(row as usize) else { return };
match self.start_chain(row) {
Ok(()) => {
self.menu = None;
ui::close_screen();
}
Err(e) => say(&e),
}
return;
}
(Page::Chains, BTN_CHAIN_FILTER) => {
// All → each battery → all. Only systems are offered; a battery with no chains
// still narrows the list to "nothing", which is the honest answer.
let ids: Vec<u32> = self.sim.sams.iter().map(|s| s.id).collect();
self.chain_filter = match self.chain_filter {
None => ids.first().copied(),
Some(id) => ids.iter().position(|x| *x == id).and_then(|i| ids.get(i + 1).copied()),
};
self.open_menu(Page::Chains);
return;
}
(Page::Chains, BTN_BACK) => {
self.open_menu(Page::Replays);
return;
}
(Page::Main, BTN_RECON) | (Page::Replays, BTN_RECON) => {
self.open_menu(Page::Recon);
return;
}
(Page::Recon, BTN_BACK) => {
self.open_menu(Page::Main);
return;
}
// The review is read-only: a row click changes nothing.
(Page::Recon, RECON_ROWS) => return,
(Page::Main, BTN_MORE) => { (Page::Main, BTN_MORE) => {
self.open_menu(Page::More); self.open_menu(Page::More);
return; return;
@@ -2292,6 +2453,20 @@ impl Mod for AirDef {
render::set_acoustics(on); render::set_acoustics(on);
self.dirty = true; self.dirty = true;
} }
(Page::More, BTN_DLSS) => {
// The request is always kept (the engine persists it too);
// without a DLSS device it is a graceful no-op until a start
// that can open one. Resolution stays the player's own choice
// in Horizon's settings — this toggle is graphics-only.
let status = render::dlss_status();
let on = !self.dlss_on();
self.dlss = Some(on);
render::set_dlss(on);
self.dirty = true;
if on && !status.available {
say("DLSS сохранён: включится при следующем запуске, если устройство его поддерживает");
}
}
(Page::More, BTN_DAMAGE) => { (Page::More, BTN_DAMAGE) => {
self.sim.damage = !self.sim.damage; self.sim.damage = !self.sim.damage;
self.dirty = true; self.dirty = true;
@@ -2320,6 +2495,12 @@ impl Mod for AirDef {
/// export still active there is ended, so its capture cannot go on recording the title. /// export still active there is ended, so its capture cannot go on recording the title.
fn frame(&mut self, _seconds: f32) { fn frame(&mut self, _seconds: f32) {
if self.presentation.is_live() { if self.presentation.is_live() {
// The overlay tracks the drawn camera frame by frame (`render.project` is at most a
// frame behind); the other screens own the HUD at the tick's pace, as before.
if self.overlay_active() {
self.draw_overlay();
self.overlay_shown = true;
}
return; return;
} }
if let Some(cleanup) = self.presentation.world_left(world_identity().as_deref()) { if let Some(cleanup) = self.presentation.world_left(world_identity().as_deref()) {
@@ -2352,7 +2533,7 @@ impl Mod for AirDef {
["battery"] => { ["battery"] => {
let status = self.sim.battery_status(); let status = self.sim.battery_status();
for entry in status { say(&battery_view::status(entry)); } for entry in status { say(&battery_view::status(entry)); }
Some("/airdef battery <номер> integrated|launcher; /airdef radar <номер> on|off|multi|search|engagement|height".into()) Some("/airdef battery <номер> integrated|launcher; /airdef radar <номер> on|off; профиль задаётся deploy radar_search|radar_track|radar_height".into())
} }
["battery", n, mode] => { ["battery", n, mode] => {
let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("Нужен номер комплекса")?; let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("Нужен номер комплекса")?;
@@ -2370,13 +2551,12 @@ impl Mod for AirDef {
self.dirty = true; self.dirty = true;
Some(format!("№{} {}: излучение РЛС {}", i + 1, sam.kind.name(), state)) Some(format!("№{} {}: излучение РЛС {}", i + 1, sam.kind.name(), state))
} }
["radar", n, role] => { ["radar", _n, role] => {
let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("Нужен номер РЛС")?;
let role = sim::battery::RadarRole::from_key(role).ok_or("Роль: multi, search, engagement или height")?; let role = sim::battery::RadarRole::from_key(role).ok_or("Роль: multi, search, engagement или height")?;
let sam = self.sim.sams.get_mut(i).ok_or("Нет такого комплекса")?; return Err(format!(
if !sam.set_radar_role(role) { return Err("Нужна отдельная РЛС".into()); } "Профиль РЛС задаётся при размещении (deploy radar_search|radar_track|radar_height); переключение в {} не меняет оборудование. Доступно on/off.",
self.dirty = true; role.key()
Some(format!("№{} РЛС: роль {}", i + 1, role.key())) ));
} }
["wave", kind, rest @ ..] => { ["wave", kind, rest @ ..] => {
let count = rest.first().and_then(|v| v.parse().ok()).unwrap_or(5u32).clamp(1, 80); let count = rest.first().and_then(|v| v.parse().ok()).unwrap_or(5u32).clamp(1, 80);
@@ -2418,11 +2598,53 @@ impl Mod for AirDef {
if i >= self.sim.sams.len() { if i >= self.sim.sams.len() {
return Err("Нет такой техники".into()); return Err("Нет такой техники".into());
} }
// `/airdef why <n> source`: move the monitor to the station that measured the mark.
if rest.get(1).is_some_and(|w| *w == "source") {
let mark = self.sim.battle_reason(i).and_then(|r| r.mark);
let Some(mark) = mark else { return Err("У комплекса нет отметки: источник неизвестен".into()) };
if mark.own {
return Err("Отметка своя: источник — сама батарея".into());
}
let Some(source) = mark.source else { return Err("Источник отметки неизвестен".into()) };
self.monitor = Some(source);
let name = self.sim.sams.get(source).map_or("РЛС", |s| s.kind.name());
return Ok(Some(format!(
"Переход к источнику отметки: №{} {}, возраст {:.1} с",
source + 1,
name,
mark.age as f64 / 20.0
)));
}
for c in self.sim.why(i) { for c in self.sim.why(i) {
say(&format!("{} {}", if c.ok { "+" } else { "-" }, why_view::reason(&c.reason))); say(&format!("{} {}", if c.ok { "+" } else { "-" }, why_view::reason(&c.reason)));
} }
if let Some(mark) = self.sim.battle_reason(i).and_then(|r| r.mark)
&& !mark.own
&& mark.source.is_some()
{
say(&format!("Источник отметки: перейти — /airdef why {} source", i + 1));
}
None None
} }
["chains", rest @ ..] => {
let battery = match rest.first() {
Some(n) => {
let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("/airdef chains [номер батареи]")?;
Some(self.sim.sams.get(i).ok_or("Нет такой техники")?.id)
}
None => None,
};
let Some(rec) = self.sim.replays.last() else { return Err("Повторов пока нет: запишется первый же налёт".into()) };
let rows = replay::chain_rows(rec, battery);
if rows.is_empty() {
say("Цепочек нет: в записи не было ни одной отметки (или формат старый)");
} else {
for row in rows.iter().take(200) {
say(&row.text);
}
}
Some("Клик по строке в меню N → «Повторы…» → «Цепочки боя» открывает кадр повтора".into())
}
["raid"] => { ["raid"] => {
self.launch_wave(&mut out)?; self.launch_wave(&mut out)?;
None None
@@ -2588,7 +2810,21 @@ impl Mod for AirDef {
self.set_effects(*v != "off", *v == "hd"); self.set_effects(*v != "off", *v == "hd");
Some(format!("Эффекты: {}", match *v { "off" => "выкл", "hd" => "HD", _ => "обычные" })) Some(format!("Эффекты: {}", match *v { "off" => "выкл", "hd" => "HD", _ => "обычные" }))
} }
["stats"] => Some(format!( ["recon"] => {
// The enemy's partial picture and why it prices each mark: explicit debug, never the
// normal HUD (#135). The same lines fill the after-action review page.
for l in recon_view::picture_lines(&self.sim.enemy_picture()) {
say(&l);
}
None
}
["stats"] => {
// The CPU profile's per-phase wall time (#147 step 3.1), as its
// own chat lines so the bench can read them from the log.
for l in sim::profile::report() {
say(&l);
}
Some(format!(
"В воздухе: {}, ракет: {}, ПВО: {}, сбито: {}, поражений: {}, разбились о препятствия: {}; удары по ПУ: пущено {}, уничтожено {}, подавлено {}, промахов {}, сбито ПВО {}; {}", "В воздухе: {}, ракет: {}, ПВО: {}, сбито: {}, поражений: {}, разбились о препятствия: {}; удары по ПУ: пущено {}, уничтожено {}, подавлено {}, промахов {}, сбито ПВО {}; {}",
self.sim.drones.iter().filter(|d| d.alive()).count(), self.sim.drones.iter().filter(|d| d.alive()).count(),
self.sim.missiles.len(), self.sim.missiles.len(),
@@ -2602,7 +2838,8 @@ impl Mod for AirDef {
self.sim.strikes.missed, self.sim.strikes.missed,
self.sim.strikes.shot_down, self.sim.strikes.shot_down,
world_view::text(&self.ground.world) world_view::text(&self.ground.world)
)), ))
}
_ => return Err(help()), _ => return Err(help()),
}; };
self.emit(out); self.emit(out);
@@ -2615,14 +2852,19 @@ horizon_mod_sdk::export_mod!(AirDef);
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
#[test] #[test]
fn battery_menu_presets_leave_existing_catalog_indices_intact() { fn deploy_presets_and_remotes_resolve_the_same_configuration() {
use super::*; use super::*;
assert_eq!(sim::catalog::INVENTORY[0], "airdef:designator"); assert_eq!(sim::catalog::INVENTORY[0], "airdef:designator");
assert_eq!(sim::catalog::UNITS[3].kind, SamKind::S400); assert_eq!(sim::catalog::UNITS[3].kind, SamKind::S400);
assert_eq!(sim::catalog::UNITS[4].kind, SamKind::S500); assert_eq!(sim::catalog::UNITS[4].kind, SamKind::S500);
assert_eq!(sim::catalog::UNITS[10].kind, SamKind::Radar); assert_eq!(sim::catalog::UNITS[10].kind, SamKind::Radar);
for (key, _) in BATTERY_DEPLOY { for v in sim::catalog::VARIANTS {
assert!(deploy_configuration(key).is_some()); let (actual, mode, role) = deploy_configuration(v.id).unwrap();
assert_eq!((actual, mode, role), (v.kind, v.mode, v.role));
// The variant's own remote deploys exactly the same configuration.
let (actual, mode, role) = deploy_configuration(v.deploy_item).unwrap();
assert_eq!((actual, mode, role), (v.kind, v.mode, v.role));
assert!(sim::catalog::INVENTORY.contains(&v.deploy_item));
} }
for kind in SamKind::ALL { for kind in SamKind::ALL {
let (actual, mode, role) = deploy_configuration(kind.key()).unwrap(); let (actual, mode, role) = deploy_configuration(kind.key()).unwrap();
@@ -2632,8 +2874,54 @@ mod tests {
} }
} }
/// A variant remote places its own kind, mode and role; a base remote stays
/// the ordinary integrated multifunction system.
#[test]
fn placing_a_remote_deploys_its_configuration() {
let mut game = test_mod();
for (item, kind, mode, role) in [
("airdef:deploy_radar", SamKind::Radar, sim::battery::SamMode::Integrated, sim::battery::RadarRole::Multifunction),
("airdef:deploy_radar_search", SamKind::Radar, sim::battery::SamMode::Integrated, sim::battery::RadarRole::Search),
("airdef:deploy_radar_track", SamKind::Radar, sim::battery::SamMode::Integrated, sim::battery::RadarRole::Engagement),
("airdef:deploy_radar_height", SamKind::Radar, sim::battery::SamMode::Integrated, sim::battery::RadarRole::Height),
("airdef:deploy_s400_launcher", SamKind::S400, sim::battery::SamMode::LauncherOnly, sim::battery::RadarRole::Multifunction),
("airdef:deploy_s500_launcher", SamKind::S500, sim::battery::SamMode::LauncherOnly, sim::battery::RadarRole::Multifunction),
] {
let (k, m, r) = sim::catalog::deploy_item_configuration(item).expect(item);
assert_eq!((k, m, r), (kind, mode, role), "{item}");
let id = game.place(k, m, r, DVec3::new(game.sim.sams.len() as f64 * 10.0, 70.0, 0.0), 0.0);
let sam = game.sim.sams.iter().find(|s| s.id == id).unwrap();
assert_eq!((sam.kind, sam.mode, sam.radar_role), (kind, mode, role), "{item}");
if kind == SamKind::Radar {
assert_eq!(sam.radar_profile().role(), role);
if let Some(v) = sim::catalog::VARIANTS.iter().find(|v| v.deploy_item == item) {
assert_eq!(sam.radar_profile().id, v.id);
}
}
}
}
use super::*; use super::*;
#[test]
fn radar_profile_survives_a_state_round_trip() {
let mut game = test_mod();
for role in [sim::battery::RadarRole::Search, sim::battery::RadarRole::Height, sim::battery::RadarRole::Engagement] {
let id = game.sim.id();
let mut radar = Sam::new(id, SamKind::Radar, DVec3::new(role as i32 as f64 * 10.0, 70.0, 0.0), 0.0);
radar.set_radar_role(role);
game.sim.sams.push(radar);
}
let saved = game.state_text(false, false);
assert!(saved.contains("radar_search") && saved.contains("radar_height") && saved.contains("radar_track"));
let mut restored = test_mod();
restored.apply_state(&saved).unwrap();
assert_eq!(
restored.sim.sams.iter().map(|s| s.radar_profile().id).collect::<Vec<_>>(),
vec!["radar_search", "radar_height", "radar_track"]
);
}
fn test_mod() -> AirDef { fn test_mod() -> AirDef {
AirDef { AirDef {
sim: Sim::new(1), sim: Sim::new(1),
@@ -2653,11 +2941,13 @@ mod tests {
smoke: Default::default(), smoke: Default::default(),
far: true, far: true,
acoustics: None, acoustics: None,
dlss: None,
moving: None, moving: None,
hd: false, hd: false,
world: None, world: None,
health_mark: 0, health_mark: 0,
menu: None, menu: None,
chain_filter: None,
listener: DVec3::ZERO, listener: DVec3::ZERO,
punch: 0.0, punch: 0.0,
pending: Vec::new(), pending: Vec::new(),
@@ -2668,6 +2958,8 @@ mod tests {
model_generation: u32::MAX, model_generation: u32::MAX,
by_id: Vec::new(), by_id: Vec::new(),
map: map::MapUi::default(), map: map::MapUi::default(),
overlay_held: false,
overlay_shown: false,
} }
} }
+591 -81
View File
@@ -7,7 +7,7 @@
//! comes from the game as tiles (`render::TerrainShape`): the mod only says which, and the game scans the //! comes from the game as tiles (`render::TerrainShape`): the mod only says which, and the game scans the
//! loaded chunks within a budget; land it hasn't got is drawn as unknown. //! loaded chunks within a budget; land it hasn't got is drawn as unknown.
use crate::panel::distance; use crate::panel::distance;
use crate::sim::{self, Class, LowSensor, Sam, SamKind, Sim, doctrine::Doctrine, Track, strike::SiteState}; use crate::sim::{self, Class, Drone, LowSensor, Sam, SamKind, Sim, doctrine::Doctrine, Track, strike::SiteState};
use crate::{AirDef, say}; use crate::{AirDef, say};
use glam::DVec3; use glam::DVec3;
use horizon_mod_sdk::render::{self, CanvasEvent, FillShape, Point, QuadShape, Rect, Shape, TerrainShape, TextShape}; use horizon_mod_sdk::render::{self, CanvasEvent, FillShape, Point, QuadShape, Rect, Shape, TerrainShape, TextShape};
@@ -27,15 +27,23 @@ const F_TINT: usize = 8;
/// Classes of systems for the filter: missile systems, guns, radars, the rear. /// Classes of systems for the filter: missile systems, guns, radars, the rear.
const SYS_CLASSES: [&str; 4] = ["ЗРК", "ЗАК", "РЛС", "тыл"]; const SYS_CLASSES: [&str; 4] = ["ЗРК", "ЗАК", "РЛС", "тыл"];
/// Classes of the network's targets, by the speed of the track (the network doesn't know what a target is). /// Classes of the network's targets: the class the tracks were *estimated* (#133), not what the
/// targets are; the unidentified are always shown — they cannot be filtered by a class they don't have yet.
const TGT_CLASSES: [&str; 5] = ["Д", "Г", "К", "С", "Б"]; const TGT_CLASSES: [&str; 5] = ["Д", "Г", "К", "С", "Б"];
/// Speed (blocks a tick) below which a track is of the class: drones, jets, cruise, supersonic, the rest ballistic.
const TGT_SPEED: [f64; 4] = [0.8, 1.8, 3.0, 6.5]; /// Whether the track passes the class filter: its estimated class is switched on, or it has none yet.
fn tclass_shown(t: &Track, on: &[bool; 5]) -> bool {
t.class.class().is_none_or(|c| on[c as usize])
}
/// A label line's height, pixels the markers merge within, how far from the pointer labels are kept at /// A label line's height, pixels the markers merge within, how far from the pointer labels are kept at
/// a low zoom, and the most labels at once. /// a low zoom, and the most labels at once.
const LH: f32 = 9.0; const LH: f32 = 9.0;
const CLUSTER_R: f32 = 9.0; const CLUSTER_R: f32 = 9.0;
/// Tracks merge within this many pixels: their markers are bigger than the systems' (#132).
const TRACK_CLUSTER_R: f32 = 11.0;
/// A track marker's half-size, and the room its label keeps clear of it.
const TRACK_R: f32 = 6.0;
const MAX_LABELS: usize = 70; const MAX_LABELS: usize = 70;
/// Ticks a radar's computed coverage edge lives, and how many are recomputed in a redraw. /// Ticks a radar's computed coverage edge lives, and how many are recomputed in a redraw.
const RIM_REFRESH: u64 = 100; const RIM_REFRESH: u64 = 100;
@@ -121,6 +129,15 @@ enum Act {
SaveScn, SaveScn,
LoadScn(usize), LoadScn(usize),
ScnPage(i32), ScnPage(i32),
/// Switches the map between the network's data and the sandbox's truth (#132).
Truth,
}
/// What the pointer hovers: a network track, or a true drone in the truth mode.
#[derive(Clone, Copy, PartialEq, Debug)]
enum Hover {
Track(u32),
Drone(u32),
} }
/// A system in the draft layout: an existing one (by id) or one to be built. /// A system in the draft layout: an existing one (by id) or one to be built.
@@ -222,7 +239,11 @@ pub struct MapUi {
blocked: Vec<[f32; 4]>, blocked: Vec<[f32; 4]>,
widths: HashMap<String, f32>, widths: HashMap<String, f32>,
trails: HashMap<u32, Vec<(f32, f32)>>, trails: HashMap<u32, Vec<(f32, f32)>>,
/// The true places sampled while the sandbox's truth mode is on (#132), apart from the network's.
truth_trails: HashMap<u32, Vec<(f32, f32)>>,
seen: HashMap<u32, u64>, seen: HashMap<u32, u64>,
/// When a true drone was last seen, kept apart from the network's `seen` (#132).
truth_seen: HashMap<u32, u64>,
sampled: u64, sampled: u64,
draft: Draft, draft: Draft,
history: Vec<Draft>, history: Vec<Draft>,
@@ -273,7 +294,9 @@ impl Default for MapUi {
blocked: Vec::new(), blocked: Vec::new(),
widths: HashMap::new(), widths: HashMap::new(),
trails: HashMap::new(), trails: HashMap::new(),
truth_trails: HashMap::new(),
seen: HashMap::new(), seen: HashMap::new(),
truth_seen: HashMap::new(),
sampled: 0, sampled: 0,
draft: Draft::default(), draft: Draft::default(),
history: Vec::new(), history: Vec::new(),
@@ -350,7 +373,9 @@ impl MapUi {
pub fn sample(&mut self, sim: &Sim) { pub fn sample(&mut self, sim: &Sim) {
if sim.tick < self.sampled { if sim.tick < self.sampled {
self.trails.clear(); self.trails.clear();
self.truth_trails.clear();
self.seen.clear(); self.seen.clear();
self.truth_seen.clear();
} }
if sim.tick < self.sampled + SAMPLE { if sim.tick < self.sampled + SAMPLE {
return; return;
@@ -371,10 +396,27 @@ impl MapUi {
} }
self.seen.insert(id, sim.tick); self.seen.insert(id, sim.tick);
} }
// The truth mode keeps its own trail of the real places, never mixed into the network's (#132).
if sim.truth {
for d in sim.drones.iter().filter(|d| d.alive()) {
let trail = self.truth_trails.entry(d.id).or_default();
let p = (d.pos.x as f32, d.pos.z as f32);
if trail.last().is_none_or(|l| (l.0 - p.0).hypot(l.1 - p.1) > 4.0) {
trail.push(p);
if trail.len() > TRAIL_POINTS {
trail.remove(0);
}
}
self.truth_seen.insert(d.id, sim.tick);
}
}
let now = sim.tick; let now = sim.tick;
self.seen.retain(|_, t| now.saturating_sub(*t) < 1200); self.seen.retain(|_, t| now.saturating_sub(*t) < 1200);
self.truth_seen.retain(|_, t| now.saturating_sub(*t) < 1200);
let seen = &self.seen; let seen = &self.seen;
self.trails.retain(|id, _| seen.contains_key(id)); self.trails.retain(|id, _| seen.contains_key(id));
let truth_seen = &self.truth_seen;
self.truth_trails.retain(|id, _| truth_seen.contains_key(id));
} }
fn enter_editor(&mut self) { fn enter_editor(&mut self) {
@@ -423,7 +465,7 @@ impl MapUi {
fn sys_class(k: SamKind) -> usize { fn sys_class(k: SamKind) -> usize {
if k.armed() { if k.armed() {
if k == SamKind::Gepard { 1 } else { 0 } if k == SamKind::Gepard { 1 } else { 0 }
} else if k.spec().sensor > 0.0 { } else if k == SamKind::Optical || k.spec().sensor > 0.0 {
2 2
} else { } else {
3 3
@@ -438,6 +480,7 @@ fn short_name(k: SamKind) -> &'static str {
SamKind::Tzm => "ТЗМ", SamKind::Tzm => "ТЗМ",
SamKind::Ew => "РЭБ", SamKind::Ew => "РЭБ",
SamKind::Light => "Прож.", SamKind::Light => "Прож.",
SamKind::Optical => "Опт.",
SamKind::Pantsir => "Панцирь", SamKind::Pantsir => "Панцирь",
SamKind::IrisT => "IRIS-T", SamKind::IrisT => "IRIS-T",
SamKind::S400 => "С-400", SamKind::S400 => "С-400",
@@ -449,14 +492,8 @@ fn short_name(k: SamKind) -> &'static str {
} }
} }
/// The class of a track by its speed.
fn tgt_class(t: &Track) -> usize {
let v = t.vel.length();
TGT_SPEED.iter().position(|&m| v < m).unwrap_or(TGT_SPEED.len())
}
/// Markers within `r` pixels of the first of a group go with it: the groups, as indices into `pos`. /// Markers within `r` pixels of the first of a group go with it: the groups, as indices into `pos`.
fn group(pos: &[(f32, f32)], r: f32) -> Vec<Vec<usize>> { pub(crate) fn group(pos: &[(f32, f32)], r: f32) -> Vec<Vec<usize>> {
let r2 = r * r; let r2 = r * r;
let mut g: Vec<Vec<usize>> = Vec::new(); let mut g: Vec<Vec<usize>> = Vec::new();
'next: for (i, p) in pos.iter().enumerate() { 'next: for (i, p) in pos.iter().enumerate() {
@@ -567,6 +604,279 @@ fn class_name(c: sim::sites::SiteClass) -> &'static str {
} }
} }
/// What the pointer is over, in the view: a network track, or a true drone while the sandbox's truth mode is on.
/// The network's tracks come from `Sim::picture` only; a drone the network has not measured is not hoverable
/// outside the truth mode (#132). Panels and cards take the pointer first.
fn hover_at(sim: &Sim, ui: &MapUi) -> Option<Hover> {
let p = ui.cursor;
if ui.blocked.iter().any(|r| p.0 >= r[0] && p.1 >= r[1] && p.0 <= r[0] + r[2] && p.1 <= r[1] + r[3]) {
return None;
}
let near = PICK_R + 2.0;
let mut best: Option<(f32, Hover)> = None;
if ui.filters[F_TRACKS] {
let now = sim.tick;
for (id, t) in sim.picture() {
if !tclass_shown(&t, &ui.tclass) {
continue;
}
let e = t.est(now);
let c = ui.to_screen(e.x, e.z);
if !ui.on_screen(c, 6.0) {
continue;
}
let d = (c.0 - p.0).hypot(c.1 - p.1);
if d <= near && best.is_none_or(|b| d < b.0) {
best = Some((d, Hover::Track(id)));
}
}
}
// The true place wins over its own track: the mode is explicit and the card says so.
if sim.truth {
for d in sim.drones.iter().filter(|d| d.alive()) {
let c = ui.to_screen(d.pos.x, d.pos.z);
if !ui.on_screen(c, 6.0) {
continue;
}
let dist = (c.0 - p.0).hypot(c.1 - p.1);
if dist <= near && best.is_none_or(|b| dist <= b.0 + 0.5) {
best = Some((dist, Hover::Drone(d.id)));
}
}
}
best.map(|b| b.1)
}
/// The network's knowledge of one track: type, status, source, distance, speed, whatever holds or intercepts it.
/// The target and the route are never known to the network unless the sandbox's truth mode adds them (#132).
fn track_lines(sim: &Sim, t: &Track, player: Option<DVec3>, lines: &mut Vec<(String, u32)>) {
let now = sim.tick;
let age = t.age(now);
let forecast = t.forecast(now);
lines.push((format!("Трек №{} · {}", t.id, t.class.name()), RED));
lines.push((
format!("Статус: {}{}", t.ident().name(), if forecast { format!(" · прогноз {} с", age / 20) } else { format!(" · измерение {} с назад", age / 20) }),
if forecast { YELLOW } else { GREEN },
));
let source = sim.sams.iter().enumerate().find(|(_, s)| s.id == t.source).map_or(
if t.source == 0 { "неизвестен".to_string() } else { format!("№? ({})", t.source) },
|(n, s)| format!("№{} {} ({})", n + 1, s.kind.name(), s.radar_profile().id),
);
lines.push((format!("Источник: {} · измерил {}", if t.own_within(now, t.ttl as u64) { "своя РЛС" } else { "сеть (чужое измерение)" }, source), WHITE));
lines.push((format!("Продукт: {} · качество {}%", t.product.name(), t.quality), WHITE));
let authority = if t.own_authorizes(now) {
"у измерившей станции пригодно для пуска".to_string()
} else if t.own_tick > 0 {
format!("измерение станции {} с назад, для пуска не пригодно", now.saturating_sub(t.own_tick) / 20)
} else {
"передано сетью: собственного измерения нет, нужен огневой трек станции".to_string()
};
lines.push((format!("Пуск: {authority}"), if t.own_authorizes(now) { GREEN } else { YELLOW }));
if t.locked {
lines.push(("Огневой захват: да".into(), YELLOW));
}
let e = t.est(now);
if let Some(p) = player {
lines.push((format!("Дистанция: {} · высота {:.0} м", distance(e.distance(p)), e.y), WHITE));
}
lines.push((
format!("Скорость: {:.0} км/ч · погрешность места {}", t.vel.length() * 20.0 * 3.6, distance(t.uncertainty(now))),
WHITE,
));
let missiles = sim.missiles.iter().filter(|m| m.target() == t.id).count();
lines.push((
if missiles > 0 { format!("Перехват: {missiles} ракет в полёте") } else { "Перехват: ракет нет".into() },
if missiles > 0 { GREEN } else { GREY },
));
let who = who_tracks(sim, t);
if !who.is_empty() {
lines.push((format!("Держат: {who}"), WHITE));
}
}
/// The systems whose tracks hold this one, by name (the network's own bookkeeping, not the drone's).
fn who_tracks(sim: &Sim, t: &Track) -> String {
let n = sim.sams.iter().filter(|s| s.tracks.iter().any(|x| x.id == t.id)).count();
if n == 0 { String::new() } else { format!("{n} комплексов") }
}
/// What a true drone is aimed at, in the sandbox's words: a unit, a marked object, or a bare point (#132).
fn aim_text(sim: &Sim, d: &Drone) -> String {
let unit = d.aim_unit();
if unit != 0 {
return match sim.sams.iter().position(|s| s.id == unit) {
Some(i) => format!("{} №{}", sim.sams[i].kind.name(), i + 1),
None => format!("комплекс №{unit}"),
};
}
let aim = d.aim_pos();
match sim.targets.iter().position(|p| p.distance(aim) < 8.0) {
Some(i) => format!("объект №{}", i + 1),
None => format!("точка {:.0} {:.0}", aim.x, aim.z),
}
}
/// The truth's lines for one drone: what it is, whether the network holds it, where it goes, what it is sent at,
/// and who is shooting at it. Only the sandbox's truth mode asks for these (#132).
fn truth_lines(sim: &Sim, d: &Drone, player: Option<DVec3>, lines: &mut Vec<(String, u32)>) {
let tracked = sim.picture().contains_key(&d.id);
lines.push((format!("ИСТИНА · {} ({}) №{}", d.kind.spec().name, d.kind.spec().class.name(), d.id), YELLOW));
lines.push((
format!("Статус: {}{}", if d.jammed { "в воздухе, навигация подавлена" } else { "в воздухе" }, if tracked { ", в картине сети" } else { ", вне картины сети" }),
if tracked { WHITE } else { ORANGE },
));
if d.kind.spec().decoy {
lines.push(("Ложная цель: без боевой части".into(), GREY));
}
if let Some(p) = player {
lines.push((format!("Дистанция: {} · высота {:.0} м", distance(d.pos.distance(p)), d.pos.y), WHITE));
}
lines.push((format!("Скорость: {:.0} км/ч", d.vel.length() * 20.0 * 3.6), WHITE));
lines.push((format!("Цель: {}", aim_text(sim, d)), YELLOW));
let route = d.route();
if route.is_empty() {
lines.push(("Маршрут: прямо на цель".into(), YELLOW));
} else {
lines.push((format!("Маршрут: {} точек, следующая через {}", route.len(), distance(d.pos.distance(route[0]))), YELLOW));
}
let aim = d.aim_pos();
let speed = d.vel.length().max(0.001);
lines.push((format!("До цели: {} (~{:.0} с)", distance(d.pos.distance(aim)), d.pos.distance(aim) / speed / 20.0), WHITE));
let missiles = sim.missiles.iter().filter(|m| m.target() == d.id).count();
lines.push((
if missiles > 0 || d.engaged > 0 {
format!("Перехват: {missiles} ракет в полёте, наведено {}", d.engaged)
} else {
"Перехват: никто не ведёт".into()
},
if missiles > 0 || d.engaged > 0 { GREEN } else { GREY },
));
}
/// The truth layer: the real drones as white frames, their sampled path, the route and aim ahead in yellow, marked
/// apart from the network's red tracks. Drawn only while the sandbox's truth mode is on (#132).
fn map_truth(sim: &Sim, ui: &mut MapUi, hover: Option<Hover>, s: &mut Vec<Shape>, labs: &mut Vec<Lab>, taken: &mut Vec<[f32; 4]>) {
for d in sim.drones.iter().filter(|d| d.alive()) {
let c = ui.to_screen(d.pos.x, d.pos.z);
if ui.filters[F_TRAILS]
&& let Some(trail) = ui.truth_trails.get(&d.id)
{
let mut prev: Option<(f32, f32)> = None;
for p in trail {
let q = ui.to_screen(p.0 as f64, p.1 as f64);
if let Some(a) = prev
&& (ui.on_screen(a, 0.0) || ui.on_screen(q, 0.0))
{
s.push(line(a, q, 1.4, alpha(WHITE, 0.45)));
}
prev = Some(q);
}
}
if !ui.on_screen(c, 20.0) {
continue;
}
// The way ahead: the route's points, then the aim. Dashes, because a plan is not a measurement.
let aim = ui.to_screen(d.aim_pos().x, d.aim_pos().z);
let mut prev = c;
for p in d.route().iter().map(|p| ui.to_screen(p.x, p.z)).chain(std::iter::once(aim)) {
if ui.on_screen(prev, 0.0) || ui.on_screen(p, 0.0) {
route_dashed(s, prev, p, alpha(0xFFE070, 0.55));
}
prev = p;
}
// The drone: a white frame, never the network's red diamond. A recon aircraft has a
// sign of its own: an amber diamond, not the strike's frame (#135).
let recon = sim.is_recon_drone(d.id);
if recon {
let p = [(c.0, c.1 - 5.0), (c.0 + 5.0, c.1), (c.0, c.1 + 5.0), (c.0 - 5.0, c.1)];
for i in 0..4 {
s.push(line(p[i], p[(i + 1) % 4], 1.2, alpha(0xFFC040, 0.95)));
}
} else {
s.extend(frame(c.0 - 5.0, c.1 - 5.0, 10.0, 10.0, 1.2, alpha(WHITE, 0.95)));
}
s.push(fill(c.0 - 1.0, c.1 - 1.0, 2.0, 2.0, if recon { alpha(0xFFC040, 0.95) } else { WHITE }));
if ui.on_screen(aim, 6.0) {
s.push(diamond(aim.0, aim.1, 4.5, alpha(0xFFE070, 0.85)));
s.push(fill(aim.0 - 1.0, aim.1 - 1.0, 2.0, 2.0, alpha(0xFFE070, 0.9)));
}
taken.push([c.0 - 6.0, c.1 - 6.0, 12.0, 12.0]);
let chosen = hover == Some(Hover::Drone(d.id));
let name = if recon { format!("разведчик №{}", d.id) } else { format!("{} №{}", d.kind.spec().name, d.id) };
add_lab(ui, labs, name, c, 7.0, alpha(YELLOW, 0.95), chosen);
if chosen {
s.extend(frame(c.0 - 8.0, c.1 - 8.0, 16.0, 16.0, 1.0, GREEN));
}
}
}
/// The hover card: beside the pointer, over the picture. A network track's card never claims its target or route;
/// in the truth mode the true drone's card adds the route, the aim and the interception (#132).
fn hover_card(sim: &Sim, ui: &mut MapUi, h: Hover, player: Option<DVec3>, out: &mut Vec<Shape>, taken: &mut Vec<[f32; 4]>) {
let mut lines: Vec<(String, u32)> = Vec::new();
let border;
match h {
Hover::Track(id) => {
let pic = sim.picture();
let Some(t) = pic.get(&id) else { return };
border = RED;
track_lines(sim, t, player, &mut lines);
lines.push(("Цель и маршрут сети неизвестны".into(), GREY));
if sim.truth && let Some(d) = sim.drones.iter().find(|d| d.id == id && d.alive()) {
lines.push(("Истина (песочница):".into(), YELLOW));
lines.push((format!("Тип: {} · {}", d.kind.spec().name, aim_text(sim, d)), YELLOW));
}
}
Hover::Drone(id) => {
let Some(d) = sim.drones.iter().find(|d| d.id == id && d.alive()) else { return };
border = YELLOW;
truth_lines(sim, d, player, &mut lines);
lines.push(("Жёлтый пунктир — маршрут и цель; белые рамки — истина.".into(), GREY));
}
}
if lines.is_empty() {
return;
}
let (w, h) = ui.size;
let card_w = 250.0f32.min(w - 16.0);
let lines = wrap_lines(ui, lines, card_w);
let lh = (11.0 * ui.u).round();
let total = lines.len() as f32 * lh + 8.0;
let mut x = ui.cursor.0 + 14.0;
if x + card_w + 4.0 > w {
x = ui.cursor.0 - card_w - 14.0;
}
let x = x.clamp(4.0, (w - card_w - 4.0).max(4.0));
let y = (ui.cursor.1 - 10.0).clamp(4.0, (h - total - 4.0).max(4.0));
out.push(fill(x - 3.0, y - 3.0, card_w + 6.0, total + 6.0, 0xE8101814));
out.extend(frame(x - 3.0, y - 3.0, card_w + 6.0, total + 6.0, 1.0, border));
let mut ty = y;
for (l, c) in &lines {
out.push(text(l.as_str(), x + 2.0, ty, *c));
ty += lh;
}
taken.push([x - 3.0, y - 3.0, card_w + 6.0, total + 6.0]);
}
/// Long lines broken at the card's width.
fn wrap_lines(ui: &mut MapUi, lines: Vec<(String, u32)>, width: f32) -> Vec<(String, u32)> {
let mut wrapped: Vec<(String, u32)> = Vec::new();
for (l, c) in lines {
let mut cur = String::new();
for word in l.split(' ') {
let try_ = if cur.is_empty() { word.to_string() } else { format!("{cur} {word}") };
if ui.tw(&try_) > width - 8.0 && !cur.is_empty() {
wrapped.push((std::mem::take(&mut cur), c));
cur = word.to_string();
} else {
cur = try_;
}
}
wrapped.push((cur, c));
}
wrapped
}
impl AirDef { impl AirDef {
/// Opens the map (the key, or the menu). /// Opens the map (the key, or the menu).
pub(crate) fn map_toggle(&mut self) { pub(crate) fn map_toggle(&mut self) {
@@ -810,6 +1120,7 @@ impl AirDef {
"key.keyboard.r" if ui.mode == Mode::Editor => self.map_act(ui, Act::Rotate), "key.keyboard.r" if ui.mode == Mode::Editor => self.map_act(ui, Act::Rotate),
"key.keyboard.delete" | "key.keyboard.backspace" if ui.mode == Mode::Editor => self.map_act(ui, Act::Delete), "key.keyboard.delete" | "key.keyboard.backspace" if ui.mode == Mode::Editor => self.map_act(ui, Act::Delete),
"key.keyboard.f" => self.map_act(ui, Act::Follow), "key.keyboard.f" => self.map_act(ui, Act::Follow),
"key.keyboard.t" => self.map_act(ui, Act::Truth),
k if k.len() == 14 && k.starts_with("key.keyboard.") && k.as_bytes()[13].is_ascii_digit() && k.as_bytes()[13] != b'0' => { k if k.len() == 14 && k.starts_with("key.keyboard.") && k.as_bytes()[13].is_ascii_digit() && k.as_bytes()[13] != b'0' => {
let n = (k.as_bytes()[13] - b'1') as usize; let n = (k.as_bytes()[13] - b'1') as usize;
if n < FILTERS.len() { if n < FILTERS.len() {
@@ -915,6 +1226,8 @@ impl AirDef {
ui.pick = Pick::None; ui.pick = Pick::None;
ui.ed_sel = None; ui.ed_sel = None;
ui.trails.clear(); ui.trails.clear();
ui.truth_trails.clear();
ui.truth_seen.clear();
ui.rims.clear(); ui.rims.clear();
ui.note(tick, m); ui.note(tick, m);
} }
@@ -929,6 +1242,17 @@ impl AirDef {
} }
} }
Act::Filter(i) => ui.filters[i] = !ui.filters[i], Act::Filter(i) => ui.filters[i] = !ui.filters[i],
Act::Truth => {
self.sim.truth = !self.sim.truth;
// The two pictures are kept apart: a mode switch starts its trails afresh (#132).
ui.truth_trails.clear();
ui.truth_seen.clear();
ui.note(tick, if self.sim.truth {
"Режим ИСТИНА (песочница): настоящие дроны, их цели и маршруты. Треки сети остаются на карте."
} else {
"Режим данных сети РЛС: только то, что засекли радары."
});
}
Act::Close => { Act::Close => {
ui.close = true; ui.close = true;
} }
@@ -1115,7 +1439,7 @@ impl AirDef {
let pic = self.sim.picture(); let pic = self.sim.picture();
let mut best: Option<(f32, u32)> = None; let mut best: Option<(f32, u32)> = None;
for (id, t) in &pic { for (id, t) in &pic {
if !ui.tclass[tgt_class(t)] { if !tclass_shown(t, &ui.tclass) {
continue; continue;
} }
let e = t.est(now); let e = t.est(now);
@@ -1363,9 +1687,16 @@ impl AirDef {
// The panels first: the labels keep clear of them. They are drawn last, over the picture. // The panels first: the labels keep clear of them. They are drawn last, over the picture.
let mut panels: Vec<Shape> = Vec::with_capacity(400); let mut panels: Vec<Shape> = Vec::with_capacity(400);
self.map_panels(ui, &mut panels, &draft); self.map_panels(ui, &mut panels, &draft);
// The hover card (#132): beside the pointer, over the picture; the labels keep clear of it too.
let hover = if !editing && ui.drag.is_none() { hover_at(&self.sim, ui) } else { None };
let mut hover_taken: Vec<[f32; 4]> = Vec::new();
if let Some(h) = hover {
hover_card(&self.sim, ui, h, crate::player().map(|p| DVec3::new(p.x, p.y, p.z)), &mut panels, &mut hover_taken);
}
let mut s: Vec<Shape> = Vec::with_capacity(2048); let mut s: Vec<Shape> = Vec::with_capacity(2048);
let mut labs: Vec<Lab> = Vec::new(); let mut labs: Vec<Lab> = Vec::new();
let mut taken: Vec<[f32; 4]> = ui.blocked.clone(); let mut taken: Vec<[f32; 4]> = ui.blocked.clone();
taken.extend(hover_taken);
// Terrain. // Terrain.
if ui.filters[F_TERRAIN] { if ui.filters[F_TERRAIN] {
self.map_terrain(ui, &mut s); self.map_terrain(ui, &mut s);
@@ -1458,14 +1789,13 @@ impl AirDef {
if ui.filters[F_TRACKS] || ui.filters[F_TRAILS] { if ui.filters[F_TRACKS] || ui.filters[F_TRAILS] {
self.map_tracks(ui, &mut s, &mut labs, &mut taken); self.map_tracks(ui, &mut s, &mut labs, &mut taken);
} }
// The truth, when the sandbox shows it, marked as such. // The optical posts and the contacts they watch (#136): a line to a contact last seen in clear sight.
if ui.filters[F_SAMS] || ui.filters[F_TRACKS] {
self.map_optical(ui, &mut s, &mut labs);
}
// The truth, when the sandbox shows it, marked as such: the real drones, their routes and aims.
if self.sim.truth { if self.sim.truth {
for d in &self.sim.drones { map_truth(&self.sim, ui, hover, &mut s, &mut labs, &mut taken);
let c = ui.to_screen(d.pos.x, d.pos.z);
if ui.on_screen(c, 4.0) {
s.extend(frame(c.0 - 3.0, c.1 - 3.0, 6.0, 6.0, 1.0, alpha(0xFF4040, 0.9)));
}
}
} }
// The ghost under the pointer while placing. // The ghost under the pointer while placing.
if editing && let Some(y) = self.ground_y(cur_world.0, cur_world.1) { if editing && let Some(y) = self.ground_y(cur_world.0, cur_world.1) {
@@ -1587,6 +1917,51 @@ impl AirDef {
} }
} }
/// The optical posts (#136): a short status by each, and a line to the contact it has in clear
/// sight (or last saw), never to a radar's measurement. At most a screenful, so a crowd stays cheap.
fn map_optical(&self, ui: &mut MapUi, s: &mut Vec<Shape>, labs: &mut Vec<Lab>) {
let now = self.sim.tick;
let picture = self.sim.picture();
let mut drawn = 0usize;
for (i, sam) in self.sim.sams.iter().enumerate().filter(|(_, sam)| sam.kind == SamKind::Optical && sam.alive()) {
if drawn >= 16 {
break;
}
let c = ui.to_screen(sam.pos.x, sam.pos.z);
if !ui.on_screen(c, 30.0) {
continue;
}
drawn += 1;
let Some(report) = self.sim.optical_report(sam.id) else { continue };
let chosen = ui.sel == Some(Sel::Sam(sam.id));
let color = match report.state {
sim::OpticalState::Observing => GREEN,
sim::OpticalState::Holding => CYAN,
sim::OpticalState::NoSight => ORANGE,
sim::OpticalState::Searching => GREY,
};
add_lab(ui, labs, format!("Опт. №{}: {}", i + 1, report.status()), c, 7.0, alpha(color, 0.95), chosen);
if chosen {
s.extend(frame(c.0 - 8.0, c.1 - 8.0, 16.0, 16.0, 1.0, GREEN));
}
// The contact it watches: its own last clear sighting, else the network cue's forecast.
let own = report.seen.is_some();
let point = report
.seen
.or_else(|| report.target.and_then(|id| picture.get(&id).map(|t| t.est(now))));
if let Some(p) = point {
let pc = ui.to_screen(p.x, p.z);
s.push(line(c, pc, 1.0, alpha(color, if chosen { 0.9 } else if own { 0.55 } else { 0.3 })));
let label = match (own, report.observation) {
(true, Some(o)) => format!("вероятно {} · {:.0}%", o.class.name(), (1.0 - o.uncertainty) * 100.0),
(true, None) => "контакт в поле зрения".into(),
(false, _) => "цель по подсказке".into(),
};
add_lab(ui, labs, label, pc, 5.0, alpha(color, 0.95), chosen);
}
}
}
/// The radars' coverage edges. A radar's edge is where the land first hides a low flyer along each ray round it; /// The radars' coverage edges. A radar's edge is where the land first hides a low flyer along each ray round it;
/// each is worked out from the sim's own horizon (`low_rim`), a few a redraw, and kept a while. The selected /// each is worked out from the sim's own horizon (`low_rim`), a few a redraw, and kept a while. The selected
/// one shows its dead zones filled. /// one shows its dead zones filled.
@@ -1922,21 +2297,21 @@ impl AirDef {
fn map_tracks(&self, ui: &mut MapUi, s: &mut Vec<Shape>, labs: &mut Vec<Lab>, taken: &mut Vec<[f32; 4]>) { fn map_tracks(&self, ui: &mut MapUi, s: &mut Vec<Shape>, labs: &mut Vec<Lab>, taken: &mut Vec<[f32; 4]>) {
let now = self.sim.tick; let now = self.sim.tick;
let pic = self.sim.picture(); let pic = self.sim.picture();
// Only the classes asked for (the selected one always). // Only the classes asked for (the selected one and the unidentified always).
let shown: Vec<(&u32, &Track)> = pic.iter().filter(|(id, t)| ui.tclass[tgt_class(t)] || ui.sel == Some(Sel::Track(**id))).collect(); let shown: Vec<(&u32, &Track)> = pic.iter().filter(|(id, t)| tclass_shown(t, &ui.tclass) || ui.sel == Some(Sel::Track(**id))).collect();
for (id, t) in &shown { for (id, t) in &shown {
let chosen = ui.sel == Some(Sel::Track(**id)); let chosen = ui.sel == Some(Sel::Track(**id));
if ui.filters[F_TRAILS] if ui.filters[F_TRAILS]
&& let Some(trail) = ui.trails.get(*id) && let Some(trail) = ui.trails.get(*id)
{ {
let col = alpha(0xFF6060, if chosen { 0.95 } else { 0.5 }); let col = alpha(0xFF6060, if chosen { 1.0 } else { 0.7 });
let mut prev: Option<(f32, f32)> = None; let mut prev: Option<(f32, f32)> = None;
for p in trail { for p in trail {
let c = ui.to_screen(p.0 as f64, p.1 as f64); let c = ui.to_screen(p.0 as f64, p.1 as f64);
if let Some(a) = prev if let Some(a) = prev
&& (ui.on_screen(a, 0.0) || ui.on_screen(c, 0.0)) && (ui.on_screen(a, 0.0) || ui.on_screen(c, 0.0))
{ {
s.push(line(a, c, 1.0, col)); s.push(line(a, c, if chosen { 2.2 } else { 1.6 }, col));
} }
prev = Some(c); prev = Some(c);
} }
@@ -1950,7 +2325,7 @@ impl AirDef {
let m = ui.to_screen(t.pos.x, t.pos.z); let m = ui.to_screen(t.pos.x, t.pos.z);
// The last measurement and the forecast from it: dashes, never drawn as a certainty. // The last measurement and the forecast from it: dashes, never drawn as a certainty.
if forecast { if forecast {
s.push(line(m, c, 1.0, alpha(0xFFB0B0, 0.4))); s.push(line(m, c, 1.4, alpha(0xFFB0B0, 0.45)));
let r = (t.uncertainty(now) * ui.scale) as f32; let r = (t.uncertainty(now) * ui.scale) as f32;
ring(ui, s, c, r.min(300.0), 1.0, alpha(0xFFB0B0, 0.5)); ring(ui, s, c, r.min(300.0), 1.0, alpha(0xFFB0B0, 0.5));
} }
@@ -1958,7 +2333,7 @@ impl AirDef {
// Ahead along the course for 30 s, dashed. // Ahead along the course for 30 s, dashed.
let v = t.vel; let v = t.vel;
let ahead = ui.to_screen(e.x + v.x * 600.0, e.z + v.z * 600.0); let ahead = ui.to_screen(e.x + v.x * 600.0, e.z + v.z * 600.0);
dashed(s, c, ahead, alpha(0xFF8080, 0.8)); dashed(s, c, ahead, 1.5, alpha(0xFF8080, 0.85));
} }
} }
if !ui.filters[F_TRACKS] { if !ui.filters[F_TRACKS] {
@@ -1974,7 +2349,7 @@ impl AirDef {
.collect(); .collect();
let pos: Vec<(f32, f32)> = vis.iter().map(|v| v.2).collect(); let pos: Vec<(f32, f32)> = vis.iter().map(|v| v.2).collect();
let solo: Vec<bool> = vis.iter().map(|v| ui.sel == Some(Sel::Track(v.0))).collect(); let solo: Vec<bool> = vis.iter().map(|v| ui.sel == Some(Sel::Track(v.0))).collect();
for grp in groups_of(&pos, &solo, CLUSTER_R * 0.8, true) { for grp in groups_of(&pos, &solo, TRACK_CLUSTER_R, true) {
if grp.len() > 1 { if grp.len() > 1 {
let members: Vec<(f32, f32)> = grp.iter().map(|&k| vis[k].2).collect(); let members: Vec<(f32, f32)> = grp.iter().map(|&k| vis[k].2).collect();
draw_cluster(ui, s, taken, &members, RED); draw_cluster(ui, s, taken, &members, RED);
@@ -1984,16 +2359,36 @@ impl AirDef {
let chosen = ui.sel == Some(Sel::Track(id)); let chosen = ui.sel == Some(Sel::Track(id));
let forecast = t.forecast(now); let forecast = t.forecast(now);
let age = t.age(now); let age = t.age(now);
let col = if forecast { alpha(0xFFB0B0, 0.65) } else { 0xFFFF5050 }; // A recon aircraft is a role of its own: a yellow hollow diamond and a named label, so
s.push(diamond(c.0, c.1, 4.0, col)); // the player tells it from a strike drone the network tracks the same way (#135).
if !forecast { let recon = sim::is_drone_id(id);
s.push(diamond(c.0, c.1, 2.0, 0xFF200808)); let r = if recon { 5.0 } else { TRACK_R };
let col = if recon { YELLOW } else if forecast { alpha(0xFFB0B0, 0.65) } else { 0xFFFF5050 };
s.push(diamond(c.0, c.1, r, col));
if recon || !forecast {
s.push(diamond(c.0, c.1, if recon { 2.0 } else { 3.0 }, 0xFF200808));
} }
taken.push([c.0 - 5.0, c.1 - 5.0, 10.0, 10.0]); // Its measured course, a tick out of the marker.
let txt = format!("{}{}", if forecast { "~" } else { "" }, if age < 20 { "сейчас".to_string() } else { format!("{} с", age / 20) }); let v = t.vel.normalize_or_zero();
add_lab(ui, labs, txt, c, 5.0, col, chosen); if v != DVec3::ZERO {
s.push(line(c, (c.0 + v.x as f32 * 10.0, c.1 + v.z as f32 * 10.0), 1.5, col));
}
taken.push([c.0 - r - 1.0, c.1 - r - 1.0, r * 2.0 + 2.0, r * 2.0 + 2.0]);
let age_txt = if age < 20 { "сейчас".to_string() } else { format!("{} с", age / 20) };
let txt = if recon {
format!("разведчик {age_txt}")
} else {
let mark = t.class.mark();
match (mark.is_empty(), forecast) {
(true, true) => format!("~{age_txt}"),
(true, false) => age_txt,
(false, true) => format!("{mark} ~{age_txt}"),
(false, false) => format!("{mark} {age_txt}"),
}
};
add_lab(ui, labs, txt, c, r + 1.0, col, chosen);
if chosen { if chosen {
s.extend(frame(c.0 - 8.0, c.1 - 8.0, 16.0, 16.0, 1.0, GREEN)); s.extend(frame(c.0 - 10.0, c.1 - 10.0, 20.0, 20.0, 1.0, GREEN));
} }
} }
} }
@@ -2018,7 +2413,7 @@ impl AirDef {
}; };
let tail_w = ui.tw(&tail); let tail_w = ui.tw(&tail);
let heads: [&str; 2] = if self.sim.truth { let heads: [&str; 2] = if self.sim.truth {
["КАРТА · ИСТИНА (песочница): красные рамки — настоящие дроны", "КАРТА · ИСТИНА"] ["КАРТА · ИСТИНА (песочница): белые рамки — дроны, жёлтое — их цели и маршруты", "КАРТА · ИСТИНА (песочница)"]
} else { } else {
["КАРТА · режим: данные сети РЛС", "КАРТА · сеть РЛС"] ["КАРТА · режим: данные сети РЛС", "КАРТА · сеть РЛС"]
}; };
@@ -2069,9 +2464,14 @@ impl AirDef {
for x in &self.sim.sams { for x in &self.sim.sams {
sc[sys_class(x.kind)] += 1; sc[sys_class(x.kind)] += 1;
} }
// By the estimated class; the unidentified are counted apart.
let mut tc = [0usize; 5]; let mut tc = [0usize; 5];
let mut unknown = 0usize;
for t in self.sim.picture().values() { for t in self.sim.picture().values() {
tc[tgt_class(t)] += 1; match t.class.class() {
Some(c) => tc[c as usize] += 1,
None => unknown += 1,
}
} }
inner.push(text("Системы по классу", x0, y, GREY)); inner.push(text("Системы по классу", x0, y, GREY));
y += lh; y += lh;
@@ -2086,7 +2486,7 @@ impl AirDef {
x += draw_btn(ui, &mut inner, &label, Act::SysClass(i), ui.sclass[i], x, y, bh); x += draw_btn(ui, &mut inner, &label, Act::SysClass(i), ui.sclass[i], x, y, bh);
} }
y += bh + 6.0; y += bh + 6.0;
inner.push(text("Цели сети по скорости", x0, y, GREY)); inner.push(text("Цели сети по классу", x0, y, GREY));
y += lh; y += lh;
x = x0; x = x0;
for i in 0..TGT_CLASSES.len() { for i in 0..TGT_CLASSES.len() {
@@ -2098,11 +2498,16 @@ impl AirDef {
} }
x += draw_btn(ui, &mut inner, &label, Act::TgtClass(i), ui.tclass[i], x, y, bh); x += draw_btn(ui, &mut inner, &label, Act::TgtClass(i), ui.tclass[i], x, y, bh);
} }
// The unidentified: a count, not a filter (they are always shown).
inner.push(text(format!("? {unknown} (не опознано)"), x, y + 2.0, GREY));
y += bh + 5.0; y += bh + 5.0;
for l in ["ЗРК ракеты · ЗАК пушки · тыл", "Д дроны · Г реактивные · К крылатые", "С сверхзвук · Б баллистика"] { for l in ["ЗРК ракеты · ЗАК пушки · тыл", "Д дроны · Г реактивные · К крылатые", "С сверхзвук · Б баллистика"] {
inner.push(text(l, x0, y, GREY)); inner.push(text(l, x0, y, GREY));
y += lh - 1.0; y += lh - 1.0;
} }
let rn = self.sim.picture().values().filter(|t| sim::is_drone_id(t.id)).count();
inner.push(text(format!("жёлтый ромб — разведчик ({rn})"), x0, y, GREY));
y += lh - 1.0;
} }
_ => { _ => {
inner.push(text("Имя сценария", x0, y, GREY)); inner.push(text("Имя сценария", x0, y, GREY));
@@ -2151,7 +2556,7 @@ impl AirDef {
y += 6.0; y += 6.0;
// The mode buttons, in rows that wrap. // The mode buttons, in rows that wrap.
let mut bx = x0 - 2.0; let mut bx = x0 - 2.0;
for (label, act, on) in [("Правка (E)", Act::Editor, editing), ("Игрок (C)", Act::Player, false), ("Выход (M)", Act::Close, false)] { for (label, act, on) in [("Правка (E)", Act::Editor, editing), ("Истина (T)", Act::Truth, self.sim.truth), ("Игрок (C)", Act::Player, false), ("Выход (M)", Act::Close, false)] {
let bw = ui.tw(label) + 10.0; let bw = ui.tw(label) + 10.0;
if bx + bw > lw + 2.0 { if bx + bw > lw + 2.0 {
bx = x0 - 2.0; bx = x0 - 2.0;
@@ -2169,7 +2574,7 @@ impl AirDef {
let helps: [&str; 3] = if editing { let helps: [&str; 3] = if editing {
["ЛКМ: ставить/переносить · ПКМ: убрать · R · Z · Enter · Esc", "ЛКМ ставить · ПКМ убрать · Enter · Esc", "Enter · Esc"] ["ЛКМ: ставить/переносить · ПКМ: убрать · R · Z · Enter · Esc", "ЛКМ ставить · ПКМ убрать · Enter · Esc", "Enter · Esc"]
} else { } else {
["ЛКМ: выбор, тянуть: сдвиг · колесо: масштаб · ПКМ: марш · Esc", "ЛКМ выбор · колесо масштаб · Esc", "Esc"] ["ЛКМ: выбор, тянуть: сдвиг · колесо: масштаб · T: данные · Esc", "ЛКМ выбор · колесо масштаб · T данные · Esc", "Esc"]
}; };
for help in helps { for help in helps {
let hw = ui.tw(help); let hw = ui.tw(help);
@@ -2204,21 +2609,7 @@ impl AirDef {
self.sel_card(ui, &mut lines, &mut btns); self.sel_card(ui, &mut lines, &mut btns);
} }
// Long lines break at the card's width. // Long lines break at the card's width.
let mut wrapped: Vec<(String, u32)> = Vec::new(); let lines = wrap_lines(ui, lines, card_w);
for (l, c) in lines {
let mut cur = String::new();
for word in l.split(' ') {
let try_ = if cur.is_empty() { word.to_string() } else { format!("{cur} {word}") };
if ui.tw(&try_) > card_w - 8.0 && !cur.is_empty() {
wrapped.push((std::mem::take(&mut cur), c));
cur = word.to_string();
} else {
cur = try_;
}
}
wrapped.push((cur, c));
}
let lines = wrapped;
if !lines.is_empty() || !btns.is_empty() { if !lines.is_empty() || !btns.is_empty() {
let mut y = top; let mut y = top;
let ch = lines.len() as f32 * lh + 10.0; let ch = lines.len() as f32 * lh + 10.0;
@@ -2311,7 +2702,14 @@ impl AirDef {
lines.push((if bare == 0 { "Все объекты в зоне поражения".into() } else { format!("Без прикрытия: объектов {bare} (красные)") }, if bare == 0 { GREEN } else { RED })); lines.push((if bare == 0 { "Все объекты в зоне поражения".into() } else { format!("Без прикрытия: объектов {bare} (красные)") }, if bare == 0 { GREEN } else { RED }));
lines.push(("Зелёное: зона огня, тёмное: дыра".into(), GREY)); lines.push(("Зелёное: зона огня, тёмное: дыра".into(), GREY));
match ui.pick { match ui.pick {
Pick::Sam(k) => lines.push((format!("В руке: {}, дальность {}", k.name(), distance(k.range())), YELLOW)), Pick::Sam(k) => {
let reach = if k == SamKind::Optical {
format!("оптика {}", distance(sim::OPTICAL_RANGE))
} else {
format!("дальность {}", distance(k.range()))
};
lines.push((format!("В руке: {}, {reach}", k.name()), YELLOW));
}
Pick::Object => lines.push(("В руке: объект (его будут защищать)".into(), YELLOW)), Pick::Object => lines.push(("В руке: объект (его будут защищать)".into(), YELLOW)),
Pick::None => lines.push(("Выберите тип внизу".into(), GREY)), Pick::None => lines.push(("Выберите тип внизу".into(), GREY)),
} }
@@ -2330,7 +2728,11 @@ impl AirDef {
let k = sam.kind; let k = sam.kind;
lines.push((format!("{} №{}", k.name(), n + 1), CYAN)); lines.push((format!("{} №{}", k.name(), n + 1), CYAN));
if k == SamKind::Radar { if k == SamKind::Radar {
lines.push((format!("Роль РЛС: {}", crate::battery_view::radar_role_name(sam.radar_role)), WHITE)); let profile = sam.radar_profile();
lines.push((format!("Профиль РЛС: {} [{}]", profile.name, profile.id), WHITE));
lines.push((crate::battery_view::radar_profile_line(profile), GREY));
lines.push((format!("Ограничение: {}", profile.limit), GREY));
lines.push((format!("Каналы: {}/{} · профиль задан при размещении", sam.own_channels_used(now), profile.channels), GREY));
} else if sam.mode == sim::battery::SamMode::LauncherOnly { } else if sam.mode == sim::battery::SamMode::LauncherOnly {
lines.push(("Отдельная пусковая: внешняя РЛС сопровождения".into(), WHITE)); lines.push(("Отдельная пусковая: внешняя РЛС сопровождения".into(), WHITE));
} }
@@ -2338,7 +2740,19 @@ impl AirDef {
lines.push((format!("Излучение РЛС: {}", if sam.radar_on { "вкл" } else { "выкл" }), WHITE)); lines.push((format!("Излучение РЛС: {}", if sam.radar_on { "вкл" } else { "выкл" }), WHITE));
btns.push((if sam.radar_on { "Выключить РЛС" } else { "Включить РЛС" }.into(), Act::RadarEmission, sam.radar_on)); btns.push((if sam.radar_on { "Выключить РЛС" } else { "Включить РЛС" }.into(), Act::RadarEmission, sam.radar_on));
} }
lines.push((sam.status(), WHITE)); lines.push((crate::battery_view::sam_status(sam, now), WHITE));
if k == SamKind::Optical
&& let Some(r) = self.sim.optical_report(sam.id)
{
lines.push((r.line(), WHITE));
if let Some(o) = r.observation {
lines.push((format!("Последнее наблюдение: {} · {} с назад", o.class.name(), o.age(now) / 20), WHITE));
}
lines.push(("Пассивный пост: не излучает и не ведёт огневой трек".into(), GREY));
if r.target.is_some() {
lines.push(("Выбранный контакт показан линией".into(), GREY));
}
}
lines.push((format!("Исправен {:.0}% · {:.0} {:.0}", sam.health * 100.0, sam.pos.x, sam.pos.z), GREY)); lines.push((format!("Исправен {:.0}% · {:.0} {:.0}", sam.health * 100.0, sam.pos.x, sam.pos.z), GREY));
if k == SamKind::Depot { if k == SamKind::Depot {
lines.push((format!("Ударные RM48U: {} · снятые 48Н6: {}", sam.ground_stock, sam.air_48n6_stock), WHITE)); lines.push((format!("Ударные RM48U: {} · снятые 48Н6: {}", sam.ground_stock, sam.air_48n6_stock), WHITE));
@@ -2434,24 +2848,17 @@ impl AirDef {
lines.push((format!("Трек №{id}: потерян сетью"), GREY)); lines.push((format!("Трек №{id}: потерян сетью"), GREY));
return; return;
}; };
lines.push((format!("Трек сети №{id}"), 0xFFFF8080)); if sim::is_drone_id(id) {
lines.push((format!("Опознание: {}", t.ident().name()), WHITE)); lines.push((format!("Разведчик противника №{id}"), YELLOW));
let age = t.age(now); lines.push(("Роль: разведка (без оружия) — ищет технику вокруг объектов".into(), YELLOW));
lines.push(( }
if t.forecast(now) { format!("ПРОГНОЗ: последнее измерение {} с назад", age / 20) } else { format!("Измерение {} с назад", age / 20) }, let player = crate::player().map(|p| DVec3::new(p.x, p.y, p.z));
if t.forecast(now) { YELLOW } else { GREEN }, track_lines(&self.sim, t, player, lines);
)); lines.push(("Тонкая линия — пройденное по измерениям,".into(), GREY));
lines.push((format!("Высота {:.0} м, скорость {:.0} км/ч", t.pos.y, t.vel.length() * 20.0 * 3.6), WHITE)); lines.push(("пунктир — прогноз курса.".into(), GREY));
lines.push((format!("Погрешность места до {}", distance(t.uncertainty(now))), GREY));
lines.push(("Цель и маршрут неизвестны сети: тонкая линия —".into(), GREY));
lines.push(("пройденное по измерениям, пунктир — прогноз курса.".into(), GREY));
if let Some(trail) = ui.trails.get(&id) { if let Some(trail) = ui.trails.get(&id) {
lines.push((format!("Точек измерений: {}", trail.len()), GREY)); lines.push((format!("Точек измерений: {}", trail.len()), GREY));
} }
let who = self.who_tracks(t);
if !who.is_empty() {
lines.push((format!("Держат: {who}"), WHITE));
}
btns.push(("В центр".into(), Act::Centre, false)); btns.push(("В центр".into(), Act::Centre, false));
btns.push(("Следить (F)".into(), Act::Follow, ui.follow)); btns.push(("Следить (F)".into(), Act::Follow, ui.follow));
} }
@@ -2460,18 +2867,24 @@ impl AirDef {
lines.push(("Ничего не выбрано".into(), GREY)); lines.push(("Ничего не выбрано".into(), GREY));
lines.push((format!("Комплексов: {} · объектов: {}", self.sim.sams.len(), self.sim.targets.len()), WHITE)); lines.push((format!("Комплексов: {} · объектов: {}", self.sim.sams.len(), self.sim.targets.len()), WHITE));
lines.push((format!("Целей у сети: {} · известных ПУ: {live}", self.sim.picture().len()), WHITE)); lines.push((format!("Целей у сети: {} · известных ПУ: {live}", self.sim.picture().len()), WHITE));
if self.sim.truth {
lines.push(("Режим ИСТИНА: настоящие дроны, их цели и маршруты.".into(), YELLOW));
lines.push(("Это песочница, не данные сети. T — обратно.".into(), YELLOW));
}
// The recon flight's phase, only while the network actually holds a recon aircraft:
// what the visible aircraft are doing, not what the enemy learned (#135).
if self.sim.picture().values().any(|t| sim::is_drone_id(t.id)) {
let pic = self.sim.enemy_picture();
if let Some(phase) = crate::recon_view::battle_phase(&pic) {
lines.push((format!("Разведка противника: {phase} · разведчиков {}", pic.recon_sorties.len()), YELLOW));
}
}
if self.battle() { if self.battle() {
lines.push(("Идёт налёт: расстановка закрыта".into(), YELLOW)); lines.push(("Идёт налёт: расстановка закрыта".into(), YELLOW));
} }
} }
} }
} }
/// The systems whose tracks hold this one, by name (the network's own bookkeeping, not the drone's).
fn who_tracks(&self, t: &Track) -> String {
let n = self.sim.sams.iter().filter(|s| s.tracks.iter().any(|x| x.id == t.id)).count();
if n == 0 { String::new() } else { format!("{n} комплексов") }
}
} }
fn remove_dsam(d: &mut Draft, i: usize) { fn remove_dsam(d: &mut Draft, i: usize) {
@@ -2538,13 +2951,24 @@ fn ring(ui: &MapUi, s: &mut Vec<Shape>, c: (f32, f32), r: f32, w: f32, color: u3
} }
} }
fn dashed(s: &mut Vec<Shape>, a: (f32, f32), b: (f32, f32), color: u32) { fn dashed(s: &mut Vec<Shape>, a: (f32, f32), b: (f32, f32), w: f32, color: u32) {
let (dx, dy) = (b.0 - a.0, b.1 - a.1); let (dx, dy) = (b.0 - a.0, b.1 - a.1);
let len = dx.hypot(dy); let len = dx.hypot(dy);
let n = ((len / 8.0) as usize).min(200); let n = ((len / 8.0) as usize).min(200);
for i in (0..n).step_by(2) { for i in (0..n).step_by(2) {
let (t0, t1) = (i as f32 / n as f32, (i + 1) as f32 / n as f32); let (t0, t1) = (i as f32 / n as f32, (i + 1) as f32 / n as f32);
s.push(line((a.0 + dx * t0, a.1 + dy * t0), (a.0 + dx * t1, a.1 + dy * t1), 1.0, color)); s.push(line((a.0 + dx * t0, a.1 + dy * t0), (a.0 + dx * t1, a.1 + dy * t1), w, color));
}
}
/// A coarser dash for the truth mode's routes: many drones at once, so fewer, longer dashes.
fn route_dashed(s: &mut Vec<Shape>, a: (f32, f32), b: (f32, f32), color: u32) {
let (dx, dy) = (b.0 - a.0, b.1 - a.1);
let len = dx.hypot(dy);
let n = ((len / 24.0) as usize).clamp(2, 24);
for i in (0..n).step_by(2) {
let (t0, t1) = (i as f32 / n as f32, (i + 1) as f32 / n as f32);
s.push(line((a.0 + dx * t0, a.1 + dy * t0), (a.0 + dx * t1, a.1 + dy * t1), 1.2, color));
} }
} }
@@ -2602,4 +3026,90 @@ mod tests {
let far: Vec<(f32, f32)> = (0..128).map(|i| (i as f32 * 30.0, 0.0)).collect(); let far: Vec<(f32, f32)> = (0..128).map(|i| (i as f32 * 30.0, 0.0)).collect();
assert_eq!(groups_of(&far, &vec![false; 128], CLUSTER_R, true).len(), 128); assert_eq!(groups_of(&far, &vec![false; 128], CLUSTER_R, true).len(), 128);
} }
/// A drone over the map's middle and a system that has not measured anything yet.
fn hover_fixture() -> (Sim, u32, MapUi) {
let mut sim = Sim::new(1);
sim.launch(sim::DroneKind::Shahed, DVec3::new(0.0, 64.0, 0.0), DVec3::ZERO, DVec3::ZERO, &mut sim::Out::default());
let id = sim.drones[0].id;
let sid = sim.id();
sim.sams.push(Sam::new(sid, SamKind::Buk, DVec3::new(0.0, 64.0, 500.0), 0.0));
let ui = MapUi { size: (800.0, 600.0), centre: (0.0, 0.0), scale: 1.0, cursor: (400.0, 300.0), ..Default::default() };
(sim, id, ui)
}
#[test]
fn hover_reads_the_network_and_only_the_truth_mode_adds_drones() {
let (mut sim, id, ui) = hover_fixture();
// The system holds no track: the drone is not in the network's picture and is not hoverable.
assert_eq!(hover_at(&sim, &ui), None);
sim.truth = true;
assert_eq!(hover_at(&sim, &ui), Some(Hover::Drone(id)));
// A measured track is hoverable in the honest picture too.
sim.truth = false;
let t = Track { id, class: sim::ClassEst::Firm(sim::Class::Drone), pos: DVec3::new(0.0, 64.0, 0.0), vel: DVec3::ZERO, tick: 0, own_tick: 0, source: 0, product: sim::battery::Measure::Search, quality: 40, own_product: sim::battery::Measure::Search, own_quality: 0, ttl: 200, hits: 3, locked: false };
sim.sams[0].tracks.push(t);
assert_eq!(hover_at(&sim, &ui), Some(Hover::Track(id)));
// Away from the marker there is nothing.
let mut away = ui;
away.cursor = (20.0, 20.0);
assert_eq!(hover_at(&sim, &away), None);
}
#[test]
fn the_network_card_never_claims_a_target_and_lists_its_status_and_interception() {
let (mut sim, id, _) = hover_fixture();
let t = Track { id, class: sim::ClassEst::Firm(sim::Class::Drone), pos: DVec3::new(0.0, 64.0, 0.0), vel: DVec3::new(0.0, 0.0, 0.5), tick: 0, own_tick: 0, source: 0, product: sim::battery::Measure::Search, quality: 40, own_product: sim::battery::Measure::Search, own_quality: 0, ttl: 200, hits: 3, locked: true };
sim.sams[0].tracks.push(t);
let mut lines = Vec::new();
track_lines(&sim, &t, Some(DVec3::ZERO), &mut lines);
let all: String = lines.iter().map(|l| l.0.as_str()).collect::<Vec<_>>().join(" | ");
for must in ["Трек №", "Статус:", "Источник: сеть", "Скорость:", "Дистанция:", "Огневой захват", "Перехват: ракет нет", "Держат: 1 комплексов"] {
assert!(all.contains(must), "the track card lacks {must}: {all}");
}
assert!(!all.contains("Цель:"), "the network's card claims a target: {all}");
}
#[test]
fn the_truth_card_names_the_type_aim_route_and_interception() {
let (sim, _, ui) = hover_fixture();
let mut lines = Vec::new();
truth_lines(&sim, &sim.drones[0], Some(DVec3::ZERO), &mut lines);
let all: String = lines.iter().map(|l| l.0.as_str()).collect::<Vec<_>>().join(" | ");
for must in ["ИСТИНА", "Шахед", "вне картины сети", "Цель:", "Маршрут:", "До цели:", "Перехват:"] {
assert!(all.contains(must), "the truth card lacks {must}: {all}");
}
assert_eq!(hover_at(&sim, &ui), None, "the truth-off map revealed the drone");
}
#[test]
fn the_truth_layer_draws_white_frames_and_yellow_routes() {
let (mut sim, id, mut ui) = hover_fixture();
sim.truth = true;
// The label's width is cached so the test needs no GUI host call.
let label = format!("{} №{}", sim.drones[0].kind.spec().name, id);
ui.widths.insert(label.clone(), 60.0);
let mut shapes = Vec::new();
let mut labs = Vec::new();
let mut taken = Vec::new();
map_truth(&sim, &mut ui, Some(Hover::Drone(id)), &mut shapes, &mut labs, &mut taken);
assert!(shapes.iter().any(|s| matches!(s, Shape::Fill(f) if f.color == alpha(WHITE, 0.95))), "no white frame for the true drone");
assert!(shapes.iter().any(|s| matches!(s, Shape::Quad(q) if q.color & 0xFFFFFF == 0xFFE070)), "no yellow route or aim");
assert!(labs.iter().any(|l| l.text.contains("Шахед")), "the true drone has no label");
assert!(!taken.is_empty());
}
#[test]
fn the_truth_trail_never_mixes_into_the_network_trail() {
let (mut sim, id, mut ui) = hover_fixture();
sim.tick = SAMPLE;
ui.sample(&sim);
assert!(ui.trails.is_empty() && ui.seen.is_empty(), "the network got the truth's trail");
sim.truth = true;
sim.tick = SAMPLE * 2;
ui.sample(&sim);
assert_eq!(ui.truth_trails.get(&id).map(Vec::len), Some(1));
assert!(ui.trails.is_empty(), "the truth's trail was filed as the network's");
assert!(ui.truth_seen.contains_key(&id) && !ui.seen.contains_key(&id));
}
} }
+74 -16
View File
@@ -3,7 +3,7 @@
//! renders it) locked on its target. K shows one system at a time, J all of //! renders it) locked on its target. K shows one system at a time, J all of
//! them in a grid. //! them in a grid.
use crate::panel::distance; use crate::panel::distance;
use crate::sim::{Sam, SamState, Sim, heading_of, roles_text}; use crate::sim::{ClassEst, OpticalState, Sam, SamKind, SamState, Sim, heading_of, roles_text};
use glam::DVec3; use glam::DVec3;
use horizon_mod_sdk::render::{self, CameraView, FillShape, Point, QuadShape, Rect, Shape, TextShape, ViewShape}; use horizon_mod_sdk::render::{self, CameraView, FillShape, Point, QuadShape, Rect, Shape, TextShape, ViewShape};
@@ -91,12 +91,23 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
s.push(fill(x, y, w, h, 0xC0080C0A)); s.push(fill(x, y, w, h, 0xC0080C0A));
s.push(fill(x, y, w, 12.0, 0xE0142018)); s.push(fill(x, y, w, 12.0, 0xE0142018));
let state = sam.state; let state = sam.state;
let optical = sam.kind == SamKind::Optical;
let lock = matches!(state, SamState::Lock | SamState::Launch | SamState::Fire); let lock = matches!(state, SamState::Lock | SamState::Launch | SamState::Fire);
let blink = lock && (tick / 4) % 2 == 0; let blink = lock && (tick / 4) % 2 == 0;
let label = state.name(); let label = if optical { sam.optical.state().name() } else { state.name() };
let color = if optical {
match sam.optical.state() {
OpticalState::Observing => 0xFF60FF80,
OpticalState::Holding => 0xFF9FE0FF,
OpticalState::NoSight => 0xFFFFA040,
OpticalState::Searching => 0xFFE0E0E0,
}
} else {
state.color()
};
let lw = render::text_width(label); let lw = render::text_width(label);
s.push(text(fit(format!("№{} {}", index + 1, spec.name), w - lw - 12.0), x + 3.0, y + 2.0, 0xFF9FE0FF)); s.push(text(fit(format!("№{} {}", index + 1, spec.name), w - lw - 12.0), x + 3.0, y + 2.0, 0xFF9FE0FF));
s.push(text(label, x + w - 3.0 - lw, y + 2.0, argb(state.color(), if blink { 0x80 } else { 0xFF }))); s.push(text(label, x + w - 3.0 - lw, y + 2.0, argb(color, if blink { 0x80 } else { 0xFF })));
// The radar, at the left: round the system, north up. // The radar, at the left: round the system, north up.
let rr = ((h - 28.0) / 2.0).min(w * 0.2).max(10.0); let rr = ((h - 28.0) / 2.0).min(w * 0.2).max(10.0);
@@ -114,9 +125,13 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
} }
// A system that only fires (no radar) has no reach: a radar's sensor // A system that only fires (no radar) has no reach: a radar's sensor
// range stands in, and nothing is divided by zero. // range stands in, and nothing is divided by zero.
let reach = match sam.kind.range() { let reach = if optical {
crate::sim::OPTICAL_RANGE
} else {
match sam.kind.range() {
r if r > 0.0 => r, r if r > 0.0 => r,
_ => spec.sensor, _ => spec.sensor,
}
}; };
let scale = if reach > 0.0 { rr as f64 / (reach * 1.25) } else { 0.0 }; let scale = if reach > 0.0 { rr as f64 / (reach * 1.25) } else { 0.0 };
// The beam is the radar's real one: targets are measured as it passes them. // The beam is the radar's real one: targets are measured as it passes them.
@@ -146,13 +161,17 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
seen += 1; seen += 1;
let k = scale as f32; let k = scale as f32;
let (bx, by) = (rx + rel.x as f32 * k, ry + rel.z as f32 * k); let (bx, by) = (rx + rel.x as f32 * k, ry + rel.z as f32 * k);
let allowed = sam.roles & d.kind.spec().class.bit() != 0; // By the class the track was estimated (#133): the unknown are candidates too, shown in
// their own colour — the explicit policy — never the target's own class. No roles means
// holding fire, and that greys out the unknown as well.
let color = if Some(d.id) == target.map(|t| t.id) { let color = if Some(d.id) == target.map(|t| t.id) {
0xFFFFE040 0xFFFFE040
} else if allowed { } else if !tr.class.in_roles(sam.roles) {
0xFFFF4040
} else {
0xFF808080 0xFF808080
} else if tr.class == ClassEst::Unknown {
0xFFFFA040
} else {
0xFFFF4040
}; };
if tr.forecast(tick) { if tr.forecast(tick) {
s.push(fill(bx - 1.5, by - 1.5, 3.0, 1.0, color)); s.push(fill(bx - 1.5, by - 1.5, 3.0, 1.0, color));
@@ -164,14 +183,30 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
} }
} }
s.push(fill(rx - 1.5, ry - 1.5, 3.0, 3.0, 0xFF40A0FF)); s.push(fill(rx - 1.5, ry - 1.5, 3.0, 3.0, 0xFF40A0FF));
let radar_text = if spec.sensor <= 0.0 { let radar_text = if optical {
format!("ОПТИКА · {}", sam.optical.state().name())
} else if spec.sensor <= 0.0 {
format!("сеть · {seen}") format!("сеть · {seen}")
} else if radar_up { } else if radar_up {
format!("РЛС {} · {}", distance(reach), seen) let profile = sam.radar_profile();
let channels = if profile.channels == 0 { String::new() } else { format!(" · {}/{}", sam.own_channels_used(tick), profile.channels) };
format!("{} · {} · {}{channels}", profile.name, distance(reach), seen)
} else { } else {
"РЛС ОТКАЗ".to_string() "РЛС ОТКАЗ".to_string()
}; };
s.push(text(fit(radar_text, rr * 2.0 + 4.0), x + 4.0, y + h - 10.0, if spec.sensor > 0.0 && !radar_up { 0xFFFF5040 } else { 0xFF80FF90 })); let radar_color = if optical {
match sam.optical.state() {
OpticalState::Observing => 0xFF60FF80,
OpticalState::Holding => 0xFF9FE0FF,
OpticalState::NoSight => 0xFFFFA040,
OpticalState::Searching => 0xFFB0B0B0,
}
} else if spec.sensor > 0.0 && !radar_up {
0xFFFF5040
} else {
0xFF80FF90
};
s.push(text(fit(radar_text, rr * 2.0 + 4.0), x + 4.0, y + h - 10.0, radar_color));
// Its health under the radar: a bar, red when it is low. // Its health under the radar: a bar, red when it is low.
if sam.alive() && sam.health < 1.0 { if sam.alive() && sam.health < 1.0 {
@@ -209,7 +244,7 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
// Worn or failed parts, over the picture: orange, red when one has failed. // Worn or failed parts, over the picture: orange, red when one has failed.
if !sam.comps.whole() { if !sam.comps.whole() {
let failed = crate::sim::Part::ALL.iter().any(|p| sam.part_state(*p) == crate::sim::PartState::Failed); let failed = crate::sim::Part::ALL.iter().any(|p| sam.part_state(*p) == crate::sim::PartState::Failed);
s.push(text(fit(sam.parts_text(), cw * 0.55), cx + 3.0, cy + 3.0, if failed { 0xFFFF4040 } else { 0xFFFFB030 })); s.push(text(fit(crate::why_view::parts(&sam.comps, sam.kind), cw * 0.55), cx + 3.0, cy + 3.0, if failed { 0xFFFF4040 } else { 0xFFFFB030 }));
} }
// Crosshair. // Crosshair.
s.push(fill(cx + cw / 2.0 - 0.5, cy + 3.0, 1.0, ch * 0.18, 0x90FFFFFF)); s.push(fill(cx + cw / 2.0 - 0.5, cy + 3.0, 1.0, ch * 0.18, 0x90FFFFFF));
@@ -217,6 +252,21 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
s.push(fill(cx + 3.0, cy + ch / 2.0 - 0.5, cw * 0.18, 1.0, 0x90FFFFFF)); s.push(fill(cx + 3.0, cy + ch / 2.0 - 0.5, cw * 0.18, 1.0, 0x90FFFFFF));
s.push(fill(cx + cw * 0.82 - 3.0, cy + ch / 2.0 - 0.5, cw * 0.18, 1.0, 0x90FFFFFF)); s.push(fill(cx + cw * 0.82 - 3.0, cy + ch / 2.0 - 0.5, cw * 0.18, 1.0, 0x90FFFFFF));
match target { match target {
Some(_) if optical => {
// The optical post's picture: its own class observation, never the true model name.
let (color, info) = match sam.optical.state() {
OpticalState::Observing => (0xFF60FF80, sam.optical.status_text()),
OpticalState::Holding => (0xFF9FE0FF, sam.optical.status_text()),
OpticalState::NoSight => (0xFFFFA040, sam.optical.status_text()),
OpticalState::Searching => (0xFFB0B0B0, sam.optical.status_text()),
};
let (bw, bh) = (cw * 0.3, ch * 0.34);
brackets(s, cx + cw / 2.0 - bw / 2.0, cy + ch / 2.0 - bh / 2.0, bw, bh, 6.0, color);
if ch > 50.0 {
s.push(text(fit(info.clone(), cw - 6.0), cx + 3.0, cy + ch - 20.0, color));
}
s.push(text(fit(info, cw - 6.0), cx + 3.0, cy + ch - 10.0, 0xFFC0FFC0));
}
Some(t) => { Some(t) => {
let color = if lock { if blink { 0xFFFF3030 } else { 0xFFFF8080 } } else { 0xFFFFE060 }; let color = if lock { if blink { 0xFFFF3030 } else { 0xFFFF8080 } } else { 0xFFFFE060 };
let (bw, bh) = (cw * 0.3, ch * 0.34); let (bw, bh) = (cw * 0.3, ch * 0.34);
@@ -233,9 +283,12 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
let rel = at - sam.pos; let rel = at - sam.pos;
let bearing = (heading_of(rel).to_degrees() + 180.0).rem_euclid(360.0); let bearing = (heading_of(rel).to_degrees() + 180.0).rem_euclid(360.0);
if ch > 50.0 { if ch > 50.0 {
s.push(text(fit(t.kind.spec().name.into(), cw - 6.0), cx + 3.0, cy + ch - 20.0, 0xFFFFFFFF)); // What the system knows it by: the estimated class; the sandbox's truth names the model.
let name = if sim.truth { t.kind.spec().name.to_string() } else { track.map_or_else(|| "тип не определён".into(), |tr| tr.class.name()) };
s.push(text(fit(name, cw - 6.0), cx + 3.0, cy + ch - 20.0, 0xFFFFFFFF));
} }
let mut info = format!("{} в{:.0} {:.0}км/ч", distance(rel.length()), at.y - sam.pos.y, t.vel.length() * 72.0); // The speed its own measurements showed, never the target's own figures.
let mut info = format!("{} в{:.0} {:.0}км/ч", distance(rel.length()), at.y - sam.pos.y, track.map_or(0.0, |tr| tr.vel.length()) * 72.0);
if let Some(tr) = track { if let Some(tr) = track {
if tr.forecast(tick) { if tr.forecast(tick) {
info += &format!(" прогноз {:.1}с", tr.age(tick) as f64 / 20.0); info += &format!(" прогноз {:.1}с", tr.age(tick) as f64 / 20.0);
@@ -248,19 +301,24 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
} }
s.push(text(fit(info, cw - 6.0), cx + 3.0, cy + ch - 10.0, 0xFFC0FFC0)); s.push(text(fit(info, cw - 6.0), cx + 3.0, cy + ch - 10.0, 0xFFC0FFC0));
} }
None if optical => s.push(text(fit(sam.optical.status_text(), cw - 6.0), cx + 3.0, cy + ch - 10.0, 0xFFB0B0B0)),
None => s.push(text("ПОИСК", cx + 3.0, cy + ch - 10.0, 0xFF80FF90)), None => s.push(text("ПОИСК", cx + 3.0, cy + ch - 10.0, 0xFF80FF90)),
} }
// What it carries and does. // What it carries and does.
let mut line = String::new(); let mut line = String::new();
if !matches!(sam.kind, crate::sim::SamKind::Gepard) { if optical {
line = sam.optical.status_text();
} else {
if !matches!(sam.kind, SamKind::Gepard) {
line += &format!("Р{} ", sam.missiles); line += &format!("Р{} ", sam.missiles);
if sam.kind == crate::sim::SamKind::S400 { line += &format!("У{} ", sam.ground_rounds); } if sam.kind == SamKind::S400 { line += &format!("У{} ", sam.ground_rounds); }
} }
if crate::sim::catalog::unit(sam.kind).has_gun() { if crate::sim::catalog::unit(sam.kind).has_gun() {
line += &format!("Оч{} ", sam.bursts); line += &format!("Оч{} ", sam.bursts);
} }
line += &format!("сб.{} [{}]", sam.kills, roles_text(sam.roles)); line += &format!("сб.{} [{}]", sam.kills, roles_text(sam.roles));
}
s.push(text(fit(line, cw), cx, y + h - 10.0, 0xFF9FE0FF)); s.push(text(fit(line, cw), cx, y + h - 10.0, 0xFF9FE0FF));
} }
+448
View File
@@ -0,0 +1,448 @@
//! The world overlay (#132): while the player holds the overlay key, square markers over the
//! targets they can see, each with a short line — the class the radars estimated (#133) and the
//! distance. The picture is the network's, as the radar and the map read it; the sandbox's truth
//! mode adds white markers of the real drones, labelled with their actual type, apart from the
//! network's. The player's own interceptors wear small yellow squares, as the radar shows them.
//! Letting the key go hides everything. The markers are projected through the camera the last
//! drawn frame used (`render.project`, API 31), so they sit on the world as it is drawn.
//! Visibility comes before the draw budget (#141): each layer projects at most a bounded number
//! of its nearest candidates, keeps the markers of the nearest visible ones, and counts a target
//! that leaves the frame without spending a slot.
use crate::panel::distance;
use crate::sim::{ClassEst, Sim, Track};
use glam::DVec3;
use horizon_mod_sdk::render::{FillShape, Point, Rect, Shape, TextShape};
/// The most markers of one picture (the network's, the truth's and the interceptors' each): a full
/// raid still fits the HUD's 1024 shapes — a marker is four sides and a label.
const MAX_MARKERS: usize = 64;
/// The most candidates of one layer the frame looks at: the nearest ones by distance. The draw
/// budget is spent on what is in frame, but the projection work stays bounded — a crowd the frame
/// does not hold cannot buy an unbounded scan, and what the scan never reaches counts as past the
/// budget rather than out of the frame.
const MAX_SCAN: usize = 4 * MAX_MARKERS;
/// A marker's side thickness, pixels.
const LINE: f32 = 1.0;
/// A label line's height (the HUD font with its shadow).
const LH: f32 = 9.0;
/// The half-size a marker clamps to, near and far.
const HALF_MIN: f32 = 5.0;
const HALF_MAX: f32 = 16.0;
const RED: u32 = 0xFF4040;
const ORANGE: u32 = 0xFFB040;
const WHITE: u32 = 0xFFFFFFFF;
const GREEN: u32 = 0xFF80FF90;
const YELLOW: u32 = 0xFFFFE070;
/// The interceptors' own colour (the radar's missile dot).
const MISSILE: u32 = 0xFFE060;
/// An interceptor's marker half-size: small, it is not a target.
const MISSILE_HALF: f32 = 3.0;
fn pt(x: f32, y: f32) -> Point {
Point { x, y }
}
fn text(t: String, x: f32, y: f32, color: u32, centered: bool) -> Shape {
Shape::Text(TextShape { text: t, at: pt(x, y), color, centered, shadow: true })
}
/// 0xAARRGGBB with this alpha (0..1).
fn alpha(rgb: u32, a: f64) -> u32 {
((a.clamp(0.0, 1.0) * 255.0) as u32) << 24 | (rgb & 0xFFFFFF)
}
/// A square outline around a screen point: four thin fills, the world's marker.
fn square_outline(x: f32, y: f32, half: f32, color: u32) -> Vec<Shape> {
let (w, h) = (half * 2.0, LINE);
vec![
Shape::Fill(FillShape { rect: Rect { x: x - half, y: y - half, w, h }, color }),
Shape::Fill(FillShape { rect: Rect { x: x - half, y: y + half - LINE, w, h }, color }),
Shape::Fill(FillShape { rect: Rect { x: x - half, y: y - half, w: h, h: w }, color }),
Shape::Fill(FillShape { rect: Rect { x: x + half - LINE, y: y - half, w: h, h: w }, color }),
]
}
/// A marker's half-size by the distance: near targets read bigger, far ones stay legible.
fn half(dist: f64) -> f32 {
(700.0 / dist.max(1.0)).clamp(HALF_MIN as f64, HALF_MAX as f64) as f32
}
/// The short line under a network marker: the estimated class's mark (#133) and the distance to
/// the forecast place; a forecast says how old it is. An unidentified track gets a `?`, never the
/// target's type.
fn track_label(t: &Track, now: u64, player: DVec3) -> String {
let mark = match t.class {
ClassEst::Unknown => "?",
c => c.mark(),
};
let mut s = format!("{mark} {}", distance(t.est(now).distance(player)));
if t.forecast(now) {
s += &format!(" ~{}с", t.age(now) / 20);
}
s
}
/// Where a marker's label sits: under the square, or over it when the bottom edge is close.
fn label_y(y: f32, half: f32, gui_h: f32, above: bool) -> f32 {
if above {
if y - half - LH - 2.0 >= 0.0 { y - half - LH - 2.0 } else { y + half + 2.0 }
} else if y + half + LH + 2.0 <= gui_h {
y + half + 2.0
} else {
y - half - LH - 2.0
}
}
/// What one layer shows this frame: the markers to draw (the nearest visible candidates), how
/// many of the scanned candidates left the frame, and how many the budgets left out.
struct Pick<T> {
marks: Vec<(T, Point, f32)>,
offscreen: usize,
capped: usize,
}
/// The markers one layer gets this frame. The candidates are ordered nearest the player first and
/// at most [`MAX_SCAN`] of them are projected; a candidate the frame does not hold (behind the
/// camera or past an edge) is counted and its slot stays free for the next, so the nearest
/// [`MAX_MARKERS`] visible candidates are drawn. Work stays bounded by the scan, not the picture.
fn pick<T: Copy>(
items: impl Iterator<Item = T>,
at: impl Fn(T) -> DVec3,
half_at: impl Fn(T) -> f32,
player: DVec3,
gui: (f32, f32),
project: &impl Fn(DVec3) -> Option<Point>,
) -> Pick<T> {
let near = |a: &T, b: &T| at(*a).distance(player).total_cmp(&at(*b).distance(player));
let mut items: Vec<T> = items.collect();
let total = items.len();
// Only the nearest candidates are ever projected: no sort of the whole picture is needed.
if items.len() > MAX_SCAN {
items.select_nth_unstable_by(MAX_SCAN, near);
items.truncate(MAX_SCAN);
}
items.sort_by(near);
let mut marks = Vec::new();
let mut offscreen = 0usize;
for it in items {
if marks.len() >= MAX_MARKERS {
break;
}
let h = half_at(it);
match project(at(it)) {
Some(p) if p.x >= h && p.x <= gui.0 - h && p.y >= h && p.y <= gui.1 - h => marks.push((it, p, h)),
_ => offscreen += 1,
}
}
Pick { capped: total - marks.len() - offscreen, marks, offscreen }
}
/// The overlay's shapes for this frame. `project` is the game's `render.project` (the last drawn
/// frame's camera); a point behind the camera projects to None, a point off the screen still
/// projects past its edges — both are counted, not drawn. Drawn only while the key is held.
pub fn draw(sim: &Sim, player: DVec3, gui: (f32, f32), project: impl Fn(DVec3) -> Option<Point>) -> Vec<Shape> {
let mut s = Vec::new();
if gui.0 <= 0.0 || gui.1 <= 0.0 {
return s;
}
let pic = sim.air_picture();
let now = pic.now;
let truth = sim.truth && !pic.unaided;
// The frame's counts: what got a marker and what did not — out of the frame (behind the camera
// or past an edge) or past the budget. The header keeps the two apart (#141).
let mut shown = 0usize;
let mut offscreen = 0usize;
let mut capped = 0usize;
// The network's tracks: the nearest visible keep the markers; a target behind the camera no
// longer spends one, so a crowd behind cannot crowd out the target in frame.
let net = pick(pic.tracks.iter(), |t| t.est(now), |t| half(t.est(now).distance(player)), player, gui, &project);
offscreen += net.offscreen;
capped += net.capped;
for (t, p, h) in net.marks {
// Fresh: red; a forecast: orange, fading as it ages towards the track's drop (the radar's colours).
let (color, a) = if pic.unaided {
(RED, 1.0)
} else if t.forecast(now) {
(ORANGE, (1.0 - t.age(now) as f64 / t.ttl.max(1) as f64 * 0.7).max(0.3))
} else {
(RED, 1.0)
};
let color = alpha(color, a);
s.extend(square_outline(p.x, p.y, h, color));
s.push(text(track_label(t, now, player), p.x, label_y(p.y, h, gui.1, false), color, true));
shown += 1;
}
// The truth's own markers: the real drones, even the ones no radar holds, white and labelled
// with the actual type the network never shows. A tracked drone wears both: the network's
// estimate under the square, the truth over it — the offset between them is the point.
if truth {
let real = pick(
sim.drones.iter().filter(|d| d.alive()),
|d| d.pos,
|d| half(d.pos.distance(player)) + 2.0,
player,
gui,
&project,
);
offscreen += real.offscreen;
capped += real.capped;
for (d, p, h) in real.marks {
s.extend(square_outline(p.x, p.y, h, WHITE));
let label = format!("{} {}", d.kind.spec().name, distance(d.pos.distance(player)));
s.push(text(label, p.x, label_y(p.y, h, gui.1, true), WHITE, true));
shown += 1;
}
}
// The player's own interceptors: small yellow squares, no label — they are not targets, and
// the network never hid them (the radar has always shown them). They keep their own budget.
let own = pick(sim.missiles.iter(), |m| m.pos, |_| MISSILE_HALF, player, gui, &project);
for (_, p, h) in own.marks {
s.extend(square_outline(p.x, p.y, h, MISSILE));
}
// The mode, named as the map names it: the network's data by default, the sandbox's truth
// explicitly marked. The counts say what the frame holds, what left it, and what the budget cut.
let counts = format!("в кадре {shown}, за кадром {offscreen}, сверх бюджета {capped}");
let head = if truth {
format!("ОБЗОР · ИСТИНА (песочница): белые рамки — реальные дроны · {counts}")
} else {
format!("ОБЗОР · данные сети РЛС · {counts}")
};
s.push(text(head, gui.0 / 2.0, 2.0, if truth { YELLOW } else { GREEN }, true));
s
}
#[cfg(test)]
mod tests {
use super::*;
use crate::sim::{DroneKind, Out, Sam, SamKind};
const GUI: (f32, f32) = (800.0, 600.0);
/// A projector as the game's: the world ahead lands on the screen, behind the camera None.
/// Here: south (+z) is ahead, x spreads across the screen, the height lines up at 64.
fn ahead(p: DVec3) -> Option<Point> {
if p.z <= 0.0 {
return None;
}
Some(pt(400.0 + p.x as f32, 300.0 - (p.y - 64.0) as f32))
}
fn sim_with(kind: DroneKind, at: DVec3) -> Sim {
let mut sim = Sim::new(1);
sim.launch(kind, at, DVec3::ZERO, DVec3::new(at.x, 64.0, 5000.0), &mut Out::default());
sim
}
fn fills(shapes: &[Shape], rgb: u32) -> usize {
shapes.iter().filter(|s| matches!(s, Shape::Fill(f) if f.color & 0xFFFFFF == rgb & 0xFFFFFF)).count()
}
fn texts(shapes: &[Shape]) -> Vec<&TextShape> {
shapes.iter().filter_map(|s| match s {
Shape::Text(t) => Some(t),
_ => None,
}).collect()
}
fn head(shapes: &[Shape]) -> String {
texts(shapes).into_iter().find(|t| t.text.starts_with("ОБЗОР")).expect("no header").text.clone()
}
/// `n` targets in a row right behind the camera, each nearer than anything the tests put ahead.
fn crowd_behind(sim: &mut Sim, n: u32) {
for i in 0..n {
sim.launch(DroneKind::Shahed, DVec3::new(i as f64, 64.0, -50.0), DVec3::ZERO, DVec3::new(0.0, 64.0, -5000.0), &mut Out::default());
}
}
#[test]
fn a_visible_target_gets_a_square_and_a_short_line() {
let sim = sim_with(DroneKind::Shahed, DVec3::new(0.0, 64.0, 100.0));
let shapes = draw(&sim, DVec3::new(0.0, 64.0, 0.0), GUI, ahead);
// One marker: four red sides, and a label with the firm class's mark and the distance.
assert_eq!(fills(&shapes, RED), 4, "the marker is not one square outline");
let label = texts(&shapes).into_iter().find(|t| t.text.contains("100 м")).expect("no distance label");
assert!(label.text.starts_with("Д "), "the firm drone class is not marked: {}", label.text);
assert!(label.centered && label.at.y > 300.0, "the label sits under the square");
// The header names the network's data and the counts.
let head = texts(&shapes).into_iter().find(|t| t.text.starts_with("ОБЗОР")).unwrap();
assert!(head.text.contains("данные сети РЛС") && head.text.contains("в кадре 1, за кадром 0"), "{}", head.text);
}
#[test]
fn behind_the_camera_and_off_screen_are_counted_not_drawn() {
let mut sim = sim_with(DroneKind::Shahed, DVec3::new(0.0, 64.0, 100.0));
sim.launch(DroneKind::Shahed, DVec3::new(0.0, 64.0, -100.0), DVec3::ZERO, DVec3::new(0.0, 64.0, -5000.0), &mut Out::default());
let shapes = draw(&sim, DVec3::ZERO, GUI, ahead);
assert_eq!(fills(&shapes, RED), 4, "the drone behind the camera drew a marker");
let head = texts(&shapes).into_iter().find(|t| t.text.starts_with("ОБЗОР")).unwrap();
assert!(head.text.contains("в кадре 1, за кадром 1"), "{}", head.text);
// Off the screen's edge: still a place, but no marker.
let shapes = draw(&sim, DVec3::ZERO, GUI, |_| Some(pt(-40.0, 300.0)));
assert_eq!(fills(&shapes, RED), 0);
let head = texts(&shapes).into_iter().find(|t| t.text.starts_with("ОБЗОР")).unwrap();
assert!(head.text.contains("в кадре 0, за кадром 2"), "{}", head.text);
}
#[test]
fn the_label_never_leaks_the_type_of_an_unidentified_track() {
let t = Track { id: 1, class: ClassEst::Unknown, pos: DVec3::new(0.0, 64.0, 100.0), vel: DVec3::ZERO, tick: 0, own_tick: 0, source: 0, product: crate::sim::battery::Measure::Search, quality: 40, own_product: crate::sim::battery::Measure::Search, own_quality: 0, ttl: 200, hits: 1, locked: false };
let label = track_label(&t, 0, DVec3::ZERO);
assert!(label.starts_with("? "), "{label}");
assert!(!label.contains("дрон") && !label.contains("Шахед"), "{label}");
// A probable class keeps its question mark; a firm one loses it.
let t = Track { class: ClassEst::Probable(crate::sim::Class::Cruise), ..t };
assert!(track_label(&t, 0, DVec3::ZERO).starts_with("К? "));
let t = Track { class: ClassEst::Firm(crate::sim::Class::Cruise), hits: 3, ..t };
assert!(track_label(&t, 0, DVec3::ZERO).starts_with("К "));
// A forecast says its age.
let label = track_label(&t, 100, DVec3::ZERO);
assert!(label.contains("~5с"), "{label}");
}
#[test]
fn the_truth_mode_marks_the_real_drones_apart_from_the_network() {
let mut sim = sim_with(DroneKind::Shahed, DVec3::new(0.0, 64.0, 100.0));
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::Buk, DVec3::new(0.0, 64.0, 0.0), 0.0));
// Without the truth mode: no white markers, no actual type anywhere.
let shapes = draw(&sim, DVec3::ZERO, GUI, ahead);
assert_eq!(fills(&shapes, WHITE), 0);
assert!(!texts(&shapes).iter().any(|t| t.text.contains("Шахед")), "the network overlay leaked the type");
// With it: a white square with the real type, and the header says whose picture it is.
sim.truth = true;
let shapes = draw(&sim, DVec3::new(0.0, 64.0, 0.0), GUI, ahead);
assert_eq!(fills(&shapes, WHITE), 4, "the truth marker is not one white square");
let label = texts(&shapes).into_iter().find(|t| t.text.contains("Шахед-136")).expect("no truth label");
assert!(label.text.contains("100 м") && label.at.y < 300.0, "the truth label sits over the square: {label:?}");
let head = texts(&shapes).into_iter().find(|t| t.text.starts_with("ОБЗОР")).unwrap();
assert!(head.text.contains("ИСТИНА (песочница)"), "{}", head.text);
// The truth mode with no system deployed adds nothing: the sky as it is was already shown.
sim.sams.clear();
let shapes = draw(&sim, DVec3::ZERO, GUI, ahead);
assert_eq!(fills(&shapes, WHITE), 0);
}
#[test]
fn a_full_raid_stays_inside_the_huds_shape_budget() {
let mut sim = Sim::new(1);
sim.raid(DroneKind::Shahed, DVec3::new(0.0, 64.0, 0.0), 80, 300.0, &mut Out::default());
sim.truth = true;
let shapes = draw(&sim, DVec3::ZERO, GUI, ahead);
assert!(shapes.len() <= 1024, "the overlay overflowed the HUD: {} shapes", shapes.len());
// The nearest markers were kept, the rest counted.
let head = texts(&shapes).into_iter().find(|t| t.text.starts_with("ОБЗОР")).unwrap();
assert!(head.text.contains("за кадром"), "{}", head.text);
assert!(fills(&shapes, RED) / 4 <= MAX_MARKERS);
}
/// #141: 64 targets behind the camera and one in frame. The budget used to be spent on the
/// crowd before the visibility check, so the picture came out empty; the target in frame must
/// keep its marker, and the crowd is out of frame, not past the budget.
#[test]
fn a_crowd_behind_the_camera_leaves_the_network_budget_to_the_target_in_frame() {
let mut sim = Sim::new(1);
crowd_behind(&mut sim, 64);
sim.launch(DroneKind::Shahed, DVec3::new(0.0, 64.0, 100.0), DVec3::ZERO, DVec3::new(0.0, 64.0, 5000.0), &mut Out::default());
let shapes = draw(&sim, DVec3::new(0.0, 64.0, 0.0), GUI, ahead);
assert_eq!(fills(&shapes, RED), 4, "the target in frame got no marker");
assert_eq!(head(&shapes), "ОБЗОР · данные сети РЛС · в кадре 1, за кадром 64, сверх бюджета 0");
assert!(shapes.len() <= 1024, "{} shapes", shapes.len());
}
/// The truth layer keeps its own budget the same way: the real drone in frame is drawn, the
/// crowd behind the camera costs no white marker.
#[test]
fn a_crowd_behind_the_camera_leaves_the_truth_budget_to_the_target_in_frame() {
let mut sim = Sim::new(1);
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::Buk, DVec3::new(0.0, 64.0, 0.0), 0.0));
sim.truth = true;
crowd_behind(&mut sim, 64);
sim.launch(DroneKind::Shahed, DVec3::new(0.0, 64.0, 100.0), DVec3::ZERO, DVec3::new(0.0, 64.0, 5000.0), &mut Out::default());
let shapes = draw(&sim, DVec3::new(0.0, 64.0, 0.0), GUI, ahead);
assert_eq!(fills(&shapes, WHITE), 4, "the drone in frame got no truth marker");
assert_eq!(fills(&shapes, RED), 0, "the network drew a track it does not hold");
assert_eq!(head(&shapes), "ОБЗОР · ИСТИНА (песочница): белые рамки — реальные дроны · в кадре 1, за кадром 64, сверх бюджета 0");
assert!(shapes.len() <= 1024, "{} shapes", shapes.len());
}
/// The interceptors keep their own budget too: a salvo behind the camera leaves the marker
/// to the one in frame.
#[test]
fn a_crowd_behind_the_camera_leaves_the_interceptor_budget_to_the_one_in_frame() {
let mut sim = Sim::new(1);
for i in 0..64 {
sim.missiles.push(crate::sim::Missile::test_at(i + 1, DVec3::new(i as f64, 64.0, -50.0), 0));
}
sim.missiles.push(crate::sim::Missile::test_at(100, DVec3::new(0.0, 64.0, 100.0), 0));
let shapes = draw(&sim, DVec3::new(0.0, 64.0, 0.0), GUI, ahead);
assert_eq!(fills(&shapes, MISSILE), 4, "the interceptor in frame got no marker");
assert!(shapes.len() <= 1024, "{} shapes", shapes.len());
}
/// The header tells what really left the frame from what the draw budget cut, and the markers
/// go to the nearest of the visible: 64 behind the camera, 65 in frame.
#[test]
fn the_header_separates_the_frames_edge_from_the_draw_budget() {
let mut sim = Sim::new(1);
crowd_behind(&mut sim, 64);
for i in 0..65 {
let z = 100.0 + i as f64 * 10.0;
sim.launch(DroneKind::Shahed, DVec3::new(0.0, 64.0, z), DVec3::ZERO, DVec3::new(0.0, 64.0, 5000.0), &mut Out::default());
}
let shapes = draw(&sim, DVec3::new(0.0, 64.0, 0.0), GUI, ahead);
// The 64 nearest in frame are drawn; the farthest one is past the draw budget, not out of frame.
assert_eq!(fills(&shapes, RED), 4 * MAX_MARKERS);
assert!(texts(&shapes).iter().any(|t| t.text.contains("100 м")), "the nearest visible lost its marker");
assert!(!texts(&shapes).iter().any(|t| t.text.contains("740 м")), "the farthest visible took a nearer one's marker");
assert_eq!(head(&shapes), "ОБЗОР · данные сети РЛС · в кадре 64, за кадром 64, сверх бюджета 1");
assert!(shapes.len() <= 1024, "{} shapes", shapes.len());
}
/// The projection work itself is bounded: with more candidates than the scan budget, only the
/// nearest `MAX_SCAN` are looked at, and the rest are counted as past the budget.
#[test]
fn the_projection_work_is_bounded_by_the_scan_budget() {
let mut sim = Sim::new(1);
for i in 0..1000 {
sim.launch(DroneKind::Shahed, DVec3::new((i % 100) as f64, 64.0, -50.0), DVec3::ZERO, DVec3::new(0.0, 64.0, -5000.0), &mut Out::default());
}
let calls = std::cell::Cell::new(0usize);
let shapes = draw(&sim, DVec3::new(0.0, 64.0, 0.0), GUI, |p| {
calls.set(calls.get() + 1);
ahead(p)
});
assert_eq!(calls.get(), MAX_SCAN, "one layer projected more than its scan budget");
assert_eq!(head(&shapes), "ОБЗОР · данные сети РЛС · в кадре 0, за кадром 256, сверх бюджета 744");
assert!(shapes.len() <= 1024, "{} shapes", shapes.len());
}
#[test]
fn interceptors_wear_small_yellow_squares_without_labels() {
let mut sim = sim_with(DroneKind::Shahed, DVec3::new(0.0, 64.0, 100.0));
sim.missiles.push(crate::sim::Missile::test_at(1, DVec3::new(10.0, 70.0, 120.0), 0));
sim.missiles.push(crate::sim::Missile::test_at(2, DVec3::new(0.0, 64.0, -50.0), 0));
let shapes = draw(&sim, DVec3::ZERO, GUI, ahead);
// The one ahead: four yellow sides; the one behind the camera: nothing.
assert_eq!(fills(&shapes, MISSILE), 4);
assert!(!texts(&shapes).iter().any(|t| t.text.contains("перехват")), "an interceptor is not a target");
// The budget holds with a full salvo too.
for id in 3..100 {
sim.missiles.push(crate::sim::Missile::test_at(id, DVec3::new(id as f64, 64.0, 100.0), 0));
}
let shapes = draw(&sim, DVec3::ZERO, GUI, ahead);
assert!(shapes.len() <= 1024, "{} shapes", shapes.len());
assert!(fills(&shapes, MISSILE) / 4 <= MAX_MARKERS);
}
#[test]
fn labels_flip_over_the_square_near_the_edges() {
// Near the bottom: the label goes over the square; near the top: under it.
assert!(label_y(590.0, 10.0, 600.0, false) < 590.0);
assert!(label_y(10.0, 10.0, 600.0, true) > 10.0);
assert!(label_y(300.0, 10.0, 600.0, false) > 300.0);
assert!(label_y(300.0, 10.0, 600.0, true) < 300.0);
}
}
+103 -9
View File
@@ -1,6 +1,6 @@
//! The summary panel (top right): the alert, what is in the air, each //! The summary panel (top right): the alert, what is in the air, each
//! air-defence system's state and the score. //! air-defence system's state and the score.
use crate::sim::{AirPicture, DroneKind, Sim}; use crate::sim::{AirPicture, Class, ClassEst, Sim};
use glam::DVec3; use glam::DVec3;
use horizon_mod_sdk::hud::Line; use horizon_mod_sdk::hud::Line;
@@ -31,28 +31,50 @@ pub fn summary(sim: &Sim, pic: &AirPicture, player: DVec3) -> Vec<Line> {
} else { } else {
let blink = (sim.tick / 10) % 2 == 0; let blink = (sim.tick / 10) % 2 == 0;
lines.push(line(format!("ВОЗДУШНАЯ ТРЕВОГА — целей: {}", pic.tracks.len()), if blink { RED } else { PINK })); lines.push(line(format!("ВОЗДУШНАЯ ТРЕВОГА — целей: {}", pic.tracks.len()), if blink { RED } else { PINK }));
// By type, as the radars classed them. // By the class the tracks were estimated (#133): probable and firm counted apart, the
// unidentified named — the exact models stay in the sandbox's truth line.
let mut by_type = String::new(); let mut by_type = String::new();
for kind in DroneKind::ALL { for c in Class::ALL {
let n = pic.tracks.iter().filter(|t| t.kind == kind).count(); let firm = pic.tracks.iter().filter(|t| t.class == ClassEst::Firm(c)).count();
let prob = pic.tracks.iter().filter(|t| t.class == ClassEst::Probable(c)).count();
for (n, pre) in [(firm, ""), (prob, "вер. ")] {
if n > 0 { if n > 0 {
if !by_type.is_empty() { if !by_type.is_empty() {
by_type += ", "; by_type += ", ";
} }
by_type += &format!("{} ×{n}", kind.spec().name); by_type += &format!("{pre}{} ×{n}", c.name());
} }
} }
}
let unknown = pic.tracks.iter().filter(|t| t.class == ClassEst::Unknown).count();
if unknown > 0 {
if !by_type.is_empty() {
by_type += ", ";
}
by_type += &format!("не опознано ×{unknown}");
}
lines.push(line(by_type, PINK)); lines.push(line(by_type, PINK));
// The nearest track to the player: where it was last measured (a forecast says so, with its age). // The nearest track to the player: where it was last measured (a forecast says so, with its age).
if let Some(t) = pic.nearest(player) { if let Some(t) = pic.nearest(player) {
let e = t.est(now); let e = t.est(now);
let mark = if t.forecast(now) { format!(" ~{}с", t.age(now) / 20) } else { String::new() }; let mark = if t.forecast(now) { format!(" ~{}с", t.age(now) / 20) } else { String::new() };
lines.push(line( lines.push(line(
format!("Ближ.: {} {} выс.{:.0} {:.0}км/ч{mark}", t.kind.spec().name, distance(e.distance(player)), e.y - player.y, kmh(t.vel)), format!("Ближ.: {} {} выс.{:.0} {:.0}км/ч · {} кач.{}{mark}", t.class.name(), distance(e.distance(player)), e.y - player.y, kmh(t.vel), t.product.name(), t.quality),
PINK, PINK,
)); ));
} }
} }
// Recon aircraft the network tracks: their presence and the coarse phase of the flight. This is
// what the visible aircraft are doing, not the enemy's knowledge — the marks and the reasons are
// the debug command's and the after-action review's alone (#135).
let recon_n = pic.tracks.iter().filter(|t| crate::sim::is_drone_id(t.id)).count();
if recon_n > 0 {
let mut text = format!("Разведка противника: разведчиков в воздухе {recon_n}");
if let Some(phase) = crate::recon_view::battle_phase(&sim.enemy_picture()) {
text += &format!(" · фаза: {phase}");
}
lines.push(line(text, YELLOW));
}
if sim.truth { if sim.truth {
let real = sim.drones.iter().filter(|d| d.alive()).count(); let real = sim.drones.iter().filter(|d| d.alive()).count();
let unseen = sim.drones.iter().filter(|d| d.alive() && pic.get(d.id).is_none()).count(); let unseen = sim.drones.iter().filter(|d| d.alive() && pic.get(d.id).is_none()).count();
@@ -61,6 +83,12 @@ pub fn summary(sim: &Sim, pic: &AirPicture, player: DVec3) -> Vec<Line> {
text += ", противник планирует налёт"; text += ", противник планирует налёт";
} }
lines.push(line(text, YELLOW)); lines.push(line(text, YELLOW));
// The recon phase, in the truth only: the aircraft out and the marks the enemy holds
// are its knowledge, not the player's (#135).
let (out, marks) = sim.recon_status();
if out > 0 || marks > 0 {
lines.push(line(format!("РАЗВЕДКА ПРОТИВНИКА: в воздухе {out}, отметок в картине {marks}"), YELLOW));
}
} }
// The launch sites found, and the strike missiles (#101). // The launch sites found, and the strike missiles (#101).
if !sim.strikes.known.is_empty() || !sim.strikes.flights.is_empty() { if !sim.strikes.known.is_empty() || !sim.strikes.flights.is_empty() {
@@ -77,6 +105,11 @@ pub fn summary(sim: &Sim, pic: &AirPicture, player: DVec3) -> Vec<Line> {
let worst = sim.target_health.iter().copied().fold(100.0, f64::min); let worst = sim.target_health.iter().copied().fold(100.0, f64::min);
lines.push(line(format!("Объекты: {}", list.join(" ")), if worst < 50.0 { RED } else { GREEN })); lines.push(line(format!("Объекты: {}", list.join(" ")), if worst < 50.0 { RED } else { GREEN }));
} }
// The passive optical posts (#136): their own status and source, never a radar's emission.
let optics = sim.optical_reports();
if let Some(r) = optics.iter().find(|r| r.state == crate::sim::OpticalState::Observing).or_else(|| optics.first()) {
lines.push(line(format!("Опт. №{}: {}", r.index, r.line()), CYAN));
}
let lost = sim.sams.iter().filter(|s| !s.alive()).count(); let lost = sim.sams.iter().filter(|s| !s.alive()).count();
if lost > 0 { if lost > 0 {
lines.push(line(format!("Потеряно комплексов: {lost}"), RED)); lines.push(line(format!("Потеряно комплексов: {lost}"), RED));
@@ -94,12 +127,12 @@ pub fn summary(sim: &Sim, pic: &AirPicture, player: DVec3) -> Vec<Line> {
} }
for sam in sim.sams.iter().take(shown) { for sam in sim.sams.iter().take(shown) {
let mut text = if sam.kind.armed() { let mut text = if sam.kind.armed() {
format!("{} [{}]", sam.status(), crate::sim::roles_text(sam.roles)) format!("{} [{}]", crate::battery_view::sam_status(sam, now), crate::sim::roles_text(sam.roles))
} else { } else {
sam.status() crate::battery_view::sam_status(sam, now)
}; };
if let Some(t) = sam.gun_target.or(sam.target).and_then(|t| pic.get(t)) { if let Some(t) = sam.gun_target.or(sam.target).and_then(|t| pic.get(t)) {
text += &format!(" > {} {}", t.kind.spec().name, distance(t.est(now).distance(sam.pos))); text += &format!(" > {} {}", t.class.name(), distance(t.est(now).distance(sam.pos)));
} }
if sam.kills > 0 { if sam.kills > 0 {
text += &format!(" ({})", sam.kills); text += &format!(" ({})", sam.kills);
@@ -119,3 +152,64 @@ pub fn summary(sim: &Sim, pic: &AirPicture, player: DVec3) -> Vec<Line> {
)); ));
lines lines
} }
#[cfg(test)]
mod tests {
use super::*;
use crate::sim::{Aim, AirPicture, Approach, DroneKind, Out, RaidOrder, Track};
use glam::DVec3;
fn track(id: u32, class: ClassEst) -> Track {
Track { id, class, pos: DVec3::new(0.0, 120.0, 300.0), vel: DVec3::new(0.0, 0.0, -0.5), tick: 100, own_tick: 100, source: 0, product: crate::sim::battery::Measure::Search, quality: 40, own_product: crate::sim::battery::Measure::Search, own_quality: 0, ttl: 200, hits: 3, locked: false }
}
// A recon aircraft the network holds is named as such, with the flight's coarse phase; the line
// carries no mark, area or priority — the enemy's knowledge is not the HUD's (#135).
#[test]
fn a_tracked_recon_aircraft_shows_presence_and_phase_not_marks() {
let mut sim = Sim::new(135);
let object = DVec3::new(0.0, 70.0, 0.0);
sim.targets.push(object);
sim.target_health.push(100.0);
let order = RaidOrder { kinds: vec![(DroneKind::Shahed, 2)], approach: Approach::Sector, dist: 300.0, aim: Aim::Smart };
sim.order_raid(&order, &[object], &mut Out::default());
let pic = sim.air_picture();
assert!(pic.tracks.iter().any(|t| crate::sim::is_drone_id(t.id)), "the smart wave sent no recon to track");
let lines = summary(&sim, &pic, DVec3::ZERO);
let recon = lines.iter().find(|l| l.text.contains("Разведка противника")).expect("no recon line");
assert!(recon.text.contains("разведчиков в воздухе"), "{}", recon.text);
assert!(recon.text.contains("фаза:"), "the flight's phase was not shown: {}", recon.text);
assert!(!recon.text.contains("приоритет") && !recon.text.contains("Отметка"), "the HUD leaked the enemy's marks: {}", recon.text);
assert!(lines.iter().all(|l| !l.text.contains("Отметка") && !l.text.contains("приоритет")), "a mark reached the normal HUD");
}
// An ordinary strike track is not a recon flight: no recon line appears.
#[test]
fn an_ordinary_track_is_not_called_recon() {
let sim = Sim::new(1);
let pic = AirPicture { now: 100, tracks: vec![track(1, ClassEst::Firm(Class::Drone))], unaided: false };
let lines = summary(&sim, &pic, DVec3::ZERO);
assert!(lines.iter().all(|l| !l.text.contains("Разведка противника")), "{lines:?}");
}
// A recon id in the picture is enough for the presence line even without a live sortie (a flight
// finishing its way home): the phase is then omitted, the presence stays.
#[test]
fn a_recon_track_without_a_sortie_still_names_the_presence() {
let sim = Sim::new(1);
let pic = AirPicture { now: 100, tracks: vec![track(0x3000_0001, ClassEst::Firm(Class::Drone))], unaided: false };
let lines = summary(&sim, &pic, DVec3::ZERO);
let recon = lines.iter().find(|l| l.text.contains("Разведка противника")).expect("no recon line");
assert!(recon.text.contains("разведчиков в воздухе 1"), "{}", recon.text);
assert!(!recon.text.contains("фаза:"), "a phase was invented without a sortie: {}", recon.text);
}
#[test]
fn an_empty_sky_has_no_recon_line() {
let sim = Sim::new(1);
let pic = AirPicture { now: 100, tracks: Vec::new(), unaided: false };
let lines = summary(&sim, &pic, DVec3::ZERO);
assert!(lines.iter().all(|l| !l.text.contains("Разведка противника")), "{lines:?}");
}
}
+171 -14
View File
@@ -1,15 +1,24 @@
//! The radar screen (top left): a round scope round the player, north up, //! The radar screen (bottom right): a round scope round the player, north up,
//! with a sweeping beam; blips fade after the beam passes them. //! with a sweeping beam; blips fade after the beam passes them. A track's blip is a shape by the
//! class the radar measured (#132), big enough to read at a glance; close ones merge with a count.
use crate::panel::distance; use crate::panel::distance;
use crate::sim::{SamKind, Sim}; use crate::sim::{Class, ClassEst, SamKind, Sim};
use glam::DVec3; use glam::DVec3;
use horizon_mod_sdk::render::{FillShape, Point, QuadShape, Rect, Shape, TextShape}; use horizon_mod_sdk::render::{FillShape, Point, QuadShape, Rect, Shape, TextShape};
/// The scope's side in GUI pixels. /// The scope's side in GUI pixels.
pub const SIZE: f32 = 112.0; pub const SIZE: f32 = 112.0;
/// The corner box's height: the scope and its range label, plus the truth mode's own line when it shows one.
pub fn height(truth_label: bool) -> f32 {
SIZE + if truth_label { 22.0 } else { 12.0 }
}
/// Blocks from the centre to the edge. /// Blocks from the centre to the edge.
const RANGE: f64 = 500.0; const RANGE: f64 = 500.0;
const SEGMENTS: usize = 48; const SEGMENTS: usize = 48;
/// A track blip's half-size: the icons span about six pixels, against the old dot's three and a half.
const BLIP: f32 = 3.0;
/// Tracks this close on the scope merge into one blip with their number.
const MERGE_R: f32 = 4.5;
fn pt(x: f32, y: f32) -> Point { fn pt(x: f32, y: f32) -> Point {
Point { x, y } Point { x, y }
@@ -32,6 +41,34 @@ fn alpha(rgb: u32, a: f64) -> u32 {
((a.clamp(0.0, 1.0) * 255.0) as u32) << 24 | (rgb & 0xFFFFFF) ((a.clamp(0.0, 1.0) * 255.0) as u32) << 24 | (rgb & 0xFFFFFF)
} }
/// A track's blip: a shape by the estimated class, pointing along the measured course.
/// Drones are triangles, jets darts, cruise squares, supersonic diamonds, ballistic octagons;
/// an unidentified track gets a question mark instead of leaking the target's type (#133).
fn blip(class: ClassEst, x: f32, y: f32, color: u32, vel: DVec3) -> Vec<Shape> {
let h = DVec3::new(vel.x, 0.0, vel.z).normalize_or_zero();
let (hx, hy) = if h == DVec3::ZERO { (0.0, -1.0) } else { (h.x as f32, h.z as f32) };
let (px, py) = (-hy, hx);
let r = BLIP;
let at = |along: f32, side: f32| pt(x + hx * along + px * side, y + hy * along + py * side);
match class.class() {
Some(Class::Drone) => vec![quad(at(r * 1.2, 0.0), at(-r * 0.8, r * 0.9), at(-r * 0.8, -r * 0.9), at(-r * 0.8, -r * 0.9), color)],
Some(Class::Jet) => vec![quad(at(r * 1.3, 0.0), at(-r * 0.9, r * 0.9), at(-r * 0.3, 0.0), at(-r * 0.9, -r * 0.9), color)],
Some(Class::Cruise) => vec![square(x, y, 2.6, color)],
Some(Class::Supersonic) => vec![quad(pt(x, y - 3.2), pt(x + 3.2, y), pt(x, y + 3.2), pt(x - 3.2, y), color)],
Some(Class::Ballistic) => vec![square(x, y, 2.3, color), quad(pt(x, y - r), pt(x + r, y), pt(x, y + r), pt(x - r, y), color)],
None => vec![square(x, y, 2.4, color), text("?".into(), x, y - 3.0, 0xFF200808, true)],
}
}
/// Keeps a blip's centre far enough inside the disc that the whole icon stays on the scope: the longest point
/// of any class's icon is 1.3 × a half-size out.
fn inside(x: f32, y: f32, cx: f32, cy: f32, r: f32) -> (f32, f32) {
let (dx, dy) = (x - cx, y - cy);
let d = dx.hypot(dy);
let max = r - BLIP * 1.4 - 0.5;
if d > max && d > 0.0 { (cx + dx / d * max, cy + dy / d * max) } else { (x, y) }
}
pub fn draw(sim: &Sim, player: DVec3, yaw: f32) -> Vec<Shape> { pub fn draw(sim: &Sim, player: DVec3, yaw: f32) -> Vec<Shape> {
let mut s = Vec::new(); let mut s = Vec::new();
let r = SIZE / 2.0 - 2.0; let r = SIZE / 2.0 - 2.0;
@@ -143,49 +180,169 @@ pub fn draw(sim: &Sim, player: DVec3, yaw: f32) -> Vec<Shape> {
s.push(square(x, y, 1.5, 0xFFFFFFA0)); s.push(square(x, y, 1.5, 0xFFFFFFA0));
} }
} }
// The player is below target blips: a close target must not disappear under the white arrow.
// Minecraft's yaw 0 looks south (+z, down the scope).
let face = yaw.to_radians();
let tip = |a: f32, l: f32| pt(cx - (face + a).sin() * l, cy + (face + a).cos() * l);
s.push(quad(tip(0.0, 6.0), tip(2.5, 4.0), pt(cx, cy), tip(-2.5, 4.0), 0xFFFFFFFF));
let mut far = 0; let mut far = 0;
// The air picture is what the systems' radars hold, as they last measured it (a track older than a second // The air picture is what the systems' radars hold, as they last measured it (a track older than a second
// is a forecast, dimmer); with no system deployed, the sky as it is. Nothing else is read (#93). // is a forecast, dimmer); with no system deployed, the sky as it is. Nothing else is read (#93).
let pic = sim.air_picture(); let pic = sim.air_picture();
let now = pic.now; let now = pic.now;
// (x, y, class, colour, brightness, velocity) of every track on the scope, its icon kept inside the disc.
let mut marks: Vec<(f32, f32, ClassEst, u32, f64, DVec3)> = Vec::new();
for t in &pic.tracks { for t in &pic.tracks {
let (pos, vel) = (t.est(now), t.vel); let (pos, vel) = (t.est(now), t.vel);
match scope(pos) { match scope(pos) {
Some((x, y, bearing)) => { Some((x, y, bearing)) => {
// Fresh: bright and red; a forecast: orange, fading as it ages towards the track's drop. // Fresh: bright and red; a forecast: orange, fading as it ages towards the track's drop.
// The product is visible: a coarse search plot is amber, a refinement yellow, a fire plot red.
let fresh_color = match t.product {
crate::sim::battery::Measure::Search => 0xFFB060,
crate::sim::battery::Measure::Refine => 0xFFE070,
crate::sim::battery::Measure::Fire => 0xFF4040,
};
let (a, color) = if pic.unaided { let (a, color) = if pic.unaided {
(fade(bearing), 0xFF4040) (fade(bearing), 0xFF4040)
} else if t.forecast(now) { } else if t.forecast(now) {
((1.0 - t.age(now) as f64 / t.ttl.max(1) as f64 * 0.7).max(0.3), 0xFFB040) ((1.0 - t.age(now) as f64 / t.ttl.max(1) as f64 * 0.7).max(0.3), 0xFFB040)
} else { } else {
(1.0, 0xFF4040) (1.0, fresh_color)
}; };
s.push(square(x, y, 1.8, alpha(color, a))); let (x, y) = inside(x, y, cx, cy, r);
// Its heading, a short tail. marks.push((x, y, t.class, color, a, vel));
let v = vel.normalize_or_zero();
s.push(quad(pt(x, y), pt(x + 0.6, y), pt(x - v.x as f32 * 6.0 + 0.6, y - v.z as f32 * 6.0), pt(x - v.x as f32 * 6.0, y - v.z as f32 * 6.0), alpha(color, a * 0.6)));
} }
None => far += 1, None => far += 1,
} }
} }
// A tight raid reads as one blip with its number, not a pile of icons.
let pos: Vec<(f32, f32)> = marks.iter().map(|m| (m.0, m.1)).collect();
for grp in crate::map::group(&pos, MERGE_R) {
let (x, y, class, color, a, vel) = marks[grp[0]];
s.extend(blip(class, x, y, alpha(color, a), vel));
// Its heading, a short tail, kept on the disc too.
let v = vel.normalize_or_zero();
let (ex, ey) = inside(x - v.x as f32 * 7.0, y - v.z as f32 * 7.0, cx, cy, r);
s.push(quad(pt(x, y), pt(x + 1.0, y), pt(ex + 1.0, ey), pt(ex, ey), alpha(color, a * 0.6)));
if grp.len() > 1 {
s.push(text(format!("×{}", grp.len()), x + 4.0, y - 9.0, alpha(color, a), false));
}
}
// The true places, when the sandbox asks for them: a white dot beside the track, to see how far the picture is off. // The true places, when the sandbox asks for them: a white dot beside the track, to see how far the picture is off.
if sim.truth && !pic.unaided { if sim.truth && !pic.unaided {
for d in sim.drones.iter().filter(|d| d.alive()) { for d in sim.drones.iter().filter(|d| d.alive()) {
if let Some((x, y, _)) = scope(d.pos) { if let Some((x, y, _)) = scope(d.pos) {
s.push(square(x, y, 0.8, 0xFFFFFFFF)); let (x, y) = inside(x, y, cx, cy, r);
s.push(square(x, y, 1.3, 0xFFFFFFFF));
} }
} }
} }
// The player: a white arrow the way they look.
// Minecraft's yaw 0 looks south (+z, down the scope).
let face = yaw.to_radians();
let tip = |a: f32, l: f32| pt(cx - (face + a).sin() * l, cy + (face + a).cos() * l);
s.push(quad(tip(0.0, 6.0), tip(2.5, 4.0), pt(cx, cy), tip(-2.5, 4.0), 0xFFFFFFFF));
// Labels. // Labels.
s.push(text(format!("РЛС · {}", distance(RANGE)), cx, SIZE + 2.0, 0xFF80FF90, true)); s.push(text(format!("РЛС · {}", distance(RANGE)), cx, SIZE + 2.0, 0xFF80FF90, true));
if sim.truth && !pic.unaided {
s.push(text("ИСТИНА · песочница".into(), cx, SIZE + 12.0, 0xFFFFE070, true));
}
s.push(text("С".into(), cx, 3.0, 0xFF80FF90, true)); s.push(text("С".into(), cx, 3.0, 0xFF80FF90, true));
if far > 0 { if far > 0 {
s.push(text(format!("+{far} за пределом"), cx, SIZE - 14.0, 0xFFFF8080, true)); s.push(text(format!("+{far} за пределом"), cx, SIZE - 14.0, 0xFFFF8080, true));
} }
s s
} }
#[cfg(test)]
mod tests {
use super::*;
use crate::sim::{DroneKind, Out, Sam};
#[test]
fn target_blips_are_drawn_over_the_player_arrow() {
let mut sim = Sim::new(1);
sim.launch(DroneKind::Shahed, DVec3::new(0.0, 64.0, -10.0), DVec3::ZERO, DVec3::ZERO, &mut Out::default());
let shapes = draw(&sim, DVec3::ZERO, 0.0);
let arrow = shapes.iter().rposition(|s| matches!(s, Shape::Quad(q) if q.color == 0xFFFFFFFF)).unwrap();
// The Shahed's blip is a red triangle (a quad with a repeated corner), drawn after the arrow.
let target = shapes.iter().rposition(|s| matches!(s, Shape::Quad(q) if q.color == 0xFFFF4040)).unwrap();
assert!(target > arrow, "the player arrow covers the target blip");
}
#[test]
fn every_class_has_its_own_blip_shape() {
let vel = DVec3::new(0.5, 0.0, 0.0);
let shapes: Vec<Vec<Shape>> = Class::ALL.iter().map(|c| blip(ClassEst::Firm(*c), 50.0, 50.0, 0xFFFF4040, vel)).collect();
for (i, a) in shapes.iter().enumerate() {
assert!(!a.is_empty());
for b in &shapes[i + 1..] {
assert_ne!(format!("{a:?}"), format!("{b:?}"), "two classes share one icon");
}
}
// A courseless track (a ballistic one straight overhead) still draws, pointing north.
assert!(!blip(ClassEst::Firm(Class::Ballistic), 50.0, 50.0, 0xFFFF4040, DVec3::Y).is_empty());
assert!(blip(ClassEst::Unknown, 50.0, 50.0, 0xFFFF4040, vel).iter().any(|s| matches!(s, Shape::Text(t) if t.text == "?")));
}
#[test]
fn blips_stay_inside_the_scope() {
let mut sim = Sim::new(1);
// One track near the rim on every bearing, one of each class among them, one just beyond it.
for k in 0..8 {
let a = k as f64 / 8.0 * std::f64::consts::TAU;
sim.launch(DroneKind::Shahed, DVec3::new(a.sin() * 495.0, 64.0, a.cos() * 495.0), DVec3::ZERO, DVec3::ZERO, &mut Out::default());
}
for (k, kind) in [DroneKind::Geran3, DroneKind::Kh101, DroneKind::Kh22, DroneKind::Kinzhal].into_iter().enumerate() {
let a = (k as f64 + 0.5) / 4.0 * std::f64::consts::TAU;
sim.launch(kind, DVec3::new(a.sin() * 490.0, 64.0, a.cos() * 490.0), DVec3::ZERO, DVec3::ZERO, &mut Out::default());
}
sim.launch(DroneKind::Shahed, DVec3::new(0.0, 64.0, -700.0), DVec3::ZERO, DVec3::ZERO, &mut Out::default());
let shapes = draw(&sim, DVec3::ZERO, 0.0);
let (cx, cy, r) = (SIZE / 2.0, SIZE / 2.0, SIZE / 2.0 - 2.0);
let mut blips = 0;
for s in &shapes {
let corners = match s {
Shape::Quad(q) if q.color & 0xFFFFFF == 0xFF4040 => vec![q.corners.0, q.corners.1, q.corners.2, q.corners.3],
Shape::Fill(f) if f.color & 0xFFFFFF == 0xFF4040 => vec![pt(f.rect.x, f.rect.y), pt(f.rect.x + f.rect.w, f.rect.y), pt(f.rect.x, f.rect.y + f.rect.h), pt(f.rect.x + f.rect.w, f.rect.y + f.rect.h)],
_ => continue,
};
blips += 1;
for p in corners {
assert!((p.x - cx).hypot(p.y - cy) <= r + 0.01, "a blip corner leaves the disc: {p:?}");
}
}
assert!(blips >= 8, "the rim tracks were not drawn");
assert!(shapes.iter().any(|s| matches!(s, Shape::Text(t) if t.text.contains("за пределом"))), "the track beyond the range is counted");
}
#[test]
fn a_tight_raid_merges_into_one_blip_with_a_count() {
let mut sim = Sim::new(1);
for k in 0..3 {
sim.launch(DroneKind::Shahed, DVec3::new(100.0 + k as f64, 64.0, -100.0), DVec3::ZERO, DVec3::ZERO, &mut Out::default());
}
let shapes = draw(&sim, DVec3::ZERO, 0.0);
assert!(shapes.iter().any(|s| matches!(s, Shape::Text(t) if t.text == "×3")), "the merged blip has no count");
let triangles = shapes
.iter()
.filter(|s| matches!(s, Shape::Quad(q) if q.color & 0xFFFFFF == 0xFF4040 && q.corners.2.x == q.corners.3.x && q.corners.2.y == q.corners.3.y))
.count();
assert_eq!(triangles, 1, "three close tracks drew three icons");
}
#[test]
fn the_truth_mode_is_labelled_on_the_scope() {
let mut sim = Sim::new(1);
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::Buk, DVec3::new(0.0, 64.0, 0.0), 0.0));
sim.launch(DroneKind::Shahed, DVec3::new(0.0, 64.0, -100.0), DVec3::ZERO, DVec3::ZERO, &mut Out::default());
let plain = draw(&sim, DVec3::ZERO, 0.0);
assert!(!plain.iter().any(|s| matches!(s, Shape::Text(t) if t.text.contains("ИСТИНА"))));
sim.truth = true;
let shapes = draw(&sim, DVec3::ZERO, 0.0);
let label = shapes.iter().find_map(|s| match s {
Shape::Text(t) if t.text.contains("ИСТИНА") && t.text.contains("песочница") => Some(t),
_ => None,
}).expect("the truth mode is not marked");
// The corner box is sized to hold the label: a line of the HUD font is 9 pixels with its shadow.
assert!(label.at.y + 9.0 <= height(true), "the truth label falls outside the corner box");
assert!(height(true) > height(false));
}
}
+298
View File
@@ -0,0 +1,298 @@
//! Text for the enemy's reconnaissance (#135): the readable phase of a recon flight and the
//! reason a mark outranks another. It reads only the diagnostic report types (`EnemyPictureReport`,
//! `ReconReport`, `ReconSortieReport`) — an area, a public category, a channel, an age and a quality,
//! never a true place, `SamKind`, health, magazine, link or real id. The full picture is for the
//! explicit debug command and the after-action review; the battle HUD takes only the coarse phase
//! of aircraft the player's own network already tracks.
use crate::sim::{Category, Confidence, EnemyPictureReport, Quality, ReconReport, ReconSortieReport, priority_parts};
/// The public category a look reported, in the panel's words.
pub fn category_name(key: &str) -> &'static str {
match key {
"radar" => "РЛС",
"launcher" => "пусковая",
"gun" => "пушка",
"ew" => "РЭБ",
"support" => "тыл",
_ => "не определено",
}
}
/// A radar's role, public only once a refined look told it.
pub fn role_name(key: &str) -> &'static str {
match key {
"multi" => "многофункциональная",
"search" => "обзорная",
"engagement" => "наведения",
"height" => "высотомер",
_ => "не определена",
}
}
/// The channel that showed the unit.
pub fn source_name(key: &str) -> &'static str {
match key {
"emission" => "излучение",
"jamming" => "РЭБ",
"launch" => "пуск",
_ => "пролёт",
}
}
/// How well the area is known.
pub fn quality_name(key: &str) -> &'static str {
match key {
"refined" => "уточнённая",
_ => "грубая",
}
}
/// The trust the picture puts in a mark of this age.
pub fn confidence_name(confidence: Confidence) -> &'static str {
match confidence {
Confidence::Confirmed => "подтверждена",
Confidence::Probable => "вероятна",
Confidence::Doubtful => "сомнительна",
}
}
/// The phase of a sortie, as the timeline and the battle UI read it.
pub fn phase_name(phase: &str) -> &'static str {
match phase {
"reporting" => "донесение",
"done" => "завершение",
"looking" => "осмотр",
_ => "разведка",
}
}
/// Why a smart drone's aim is what it is, in words.
pub fn intent_name(intent: &str) -> &'static str {
match intent {
"sead" => "подавление ПВО",
"react" => "реакция",
"replace" => "замена",
_ => "план",
}
}
/// One mark in a line: its area's category and role, the channel, the quality, the trust, the age
/// and the priority the planner prices it at.
pub fn mark_line(m: &ReconReport) -> String {
let role = m.role.map(|k| format!(" ({})", role_name(k))).unwrap_or_default();
format!(
"Отметка {}: {}{} · {} · {} · {} · {} с назад · приоритет {}",
m.id,
category_name(m.category),
role,
source_name(m.source),
quality_name(m.quality),
confidence_name(m.confidence),
m.age / 20,
m.priority
)
}
/// Why the mark has the priority it does: the observed role, the freshness and the quality, each
/// with the weight the planner gives it, summing to the priority. The unit's true importance is not
/// in it — only what the look reported.
pub fn mark_reason(m: &ReconReport) -> String {
let category = Category::from_key(m.category).unwrap_or(Category::Unknown);
let quality = Quality::from_key(m.quality).unwrap_or(Quality::Coarse);
let role = m.role.and_then(crate::sim::battery::RadarRole::from_key);
let (freshness, quality_w, role_w) = priority_parts(m.confidence, quality, category, role);
let role_txt = match m.role {
Some(key) => format!("роль «{}»", role_name(key)),
None => format!("категория «{}»", category_name(m.category)),
};
format!(
"приоритет {} = свежесть {}×4 + качество {}×3 + роль {}: {} {}, {}",
m.priority,
freshness,
quality_w,
role_w,
confidence_name(m.confidence),
quality_name(m.quality),
role_txt
)
}
/// One sortie in a line: its phase, the zones left and when its pending report is due.
pub fn sortie_line(s: &ReconSortieReport) -> String {
let mut text = format!("Разведчик {}: {}", s.drone, phase_name(s.phase));
if s.zones_left > 0 {
text += &format!(" · зон осталось {}", s.zones_left);
}
if let Some(due) = s.report_in {
text += &format!(" · донесение через {} с", due / 20);
}
text
}
/// The coarse phase of the recon flight for the battle UI: a report going home now, else aircraft
/// still looking, else the flight finishing. `None` when no sortie is out. It says nothing of what
/// the enemy learned — only what its visible aircraft are doing.
pub fn battle_phase(pic: &EnemyPictureReport) -> Option<&'static str> {
if pic.recon_sorties.iter().any(|s| s.phase == "reporting") {
Some("донесение")
} else if pic.recon_sorties.iter().any(|s| s.phase == "outbound" || s.phase == "looking") {
Some("разведка")
} else if !pic.recon_sorties.is_empty() {
Some("завершение")
} else {
None
}
}
/// The whole picture for the debug command and the after-action review: the sorties and their
/// phases, then the marks best-first with the reason each outranks the rest, then the drones aimed
/// at a mark. Explicitly the enemy's belief, not the truth; never the normal HUD.
pub fn picture_lines(pic: &EnemyPictureReport) -> Vec<String> {
let mut lines = Vec::new();
if pic.recon.is_empty() && pic.recon_sorties.is_empty() {
lines.push("Разведки не было: противник не высылал разведчиков и ничего не запомнил.".into());
return lines;
}
lines.push(format!(
"Картина противника (debug/разбор): отметок {}, разведчиков в воздухе {}",
pic.recon.len(),
pic.recon_sorties.len()
));
for s in &pic.recon_sorties {
lines.push(sortie_line(s));
}
let mut marks: Vec<&ReconReport> = pic.recon.iter().collect();
marks.sort_by(|a, b| b.priority.cmp(&a.priority).then(a.id.cmp(&b.id)));
for m in marks {
lines.push(mark_line(m));
lines.push(format!(" ↳ {}", mark_reason(m)));
}
for a in pic.aims.iter().filter(|a| a.recon) {
lines.push(format!(
"Дрон {} целится в отметку {} (приоритет {}, {})",
a.drone,
a.unit,
a.priority.unwrap_or(0),
intent_name(a.intent)
));
}
lines
}
#[cfg(test)]
mod tests {
use super::*;
use crate::sim::{AimReport, BearingReport, Confidence, EnemyPictureReport, ReconReport, ReconSortieReport};
use glam::DVec3;
fn mark(id: u32, category: &'static str, role: Option<&'static str>, quality: &'static str, confidence: Confidence, age: u64) -> ReconReport {
let cat = Category::from_key(category).unwrap();
let qual = Quality::from_key(quality).unwrap();
let role_enum = role.and_then(crate::sim::battery::RadarRole::from_key);
let (f, q, r) = priority_parts(confidence, qual, cat, role_enum);
ReconReport { id, area: DVec3::ZERO, radius: 120.0, category, role, source: "flyby", age, quality, confidence, live: true, priority: f * 4 + q * 3 + r }
}
fn sortie(drone: u32, phase: &'static str, zones_left: usize, report_in: Option<u64>) -> ReconSortieReport {
ReconSortieReport { drone, phase, zones_left, report_in }
}
fn picture(recon: Vec<ReconReport>, recon_sorties: Vec<ReconSortieReport>, aims: Vec<AimReport>) -> EnemyPictureReport {
EnemyPictureReport {
now: 1000,
contacts: Vec::new(),
aims,
pending: Vec::new(),
work_per_tick: 4,
recon,
recon_sorties,
observations: Vec::new(),
bearing: BearingReport::default(),
refresh_waiting: false,
refresh_applied: 0,
}
}
// The reason names all three factors with the planner's own weights, and they sum to the priority.
#[test]
fn the_reason_is_the_observed_role_freshness_and_quality() {
let m = mark(0x1000_0001, "radar", Some("engagement"), "refined", Confidence::Confirmed, 100);
let reason = mark_reason(&m);
assert_eq!(m.priority, 4 * 4 + 2 * 3 + 3);
assert!(reason.contains("приоритет 25 = свежесть 4×4 + качество 2×3 + роль 3"), "{reason}");
assert!(reason.contains("подтверждена") && reason.contains("уточнённая") && reason.contains("роль «наведения»"), "{reason}");
// A coarse, doubtful, unknown mark: every part is zero, and the reason says so.
let weak = mark(0x1000_0002, "unknown", None, "coarse", Confidence::Doubtful, 5000);
assert_eq!(weak.priority, 0);
let weak_reason = mark_reason(&weak);
assert!(weak_reason.contains("свежесть 0×4 + качество 0×3 + роль 0"), "{weak_reason}");
assert!(weak_reason.contains("сомнительна") && weak_reason.contains("категория «не определено»"), "{weak_reason}");
}
// A fresh modest mark can outrank a stale big one: the reason reflects the age, not the truth.
#[test]
fn a_fresh_modest_mark_outranks_a_stale_big_one() {
let stale_big = mark(0x1000_0001, "radar", Some("engagement"), "refined", Confidence::Doubtful, 5000);
let fresh_modest = mark(0x1000_0002, "gun", None, "coarse", Confidence::Confirmed, 100);
assert!(fresh_modest.priority > stale_big.priority, "{} vs {}", fresh_modest.priority, stale_big.priority);
let fresh_id = fresh_modest.id;
let lines = picture_lines(&picture(vec![stale_big, fresh_modest], Vec::new(), Vec::new()));
let first = lines.iter().position(|l| l.starts_with("Отметка")).unwrap();
assert!(lines[first].contains(&format!("Отметка {fresh_id}")), "the fresh modest mark did not lead: {lines:?}");
}
#[test]
fn the_phase_reads_recon_report_and_done() {
assert_eq!(phase_name("outbound"), "разведка");
assert_eq!(phase_name("reporting"), "донесение");
assert_eq!(phase_name("done"), "завершение");
let reporting = picture(Vec::new(), vec![sortie(0x3000_0001, "reporting", 0, Some(40)), sortie(0x3000_0002, "outbound", 2, None)], Vec::new());
assert_eq!(battle_phase(&reporting), Some("донесение"));
let looking = picture(Vec::new(), vec![sortie(0x3000_0001, "outbound", 2, None)], Vec::new());
assert_eq!(battle_phase(&looking), Some("разведка"));
let done = picture(Vec::new(), vec![sortie(0x3000_0001, "done", 0, None)], Vec::new());
assert_eq!(battle_phase(&done), Some("завершение"));
assert_eq!(battle_phase(&picture(Vec::new(), Vec::new(), Vec::new())), None);
assert!(sortie_line(&sortie(0x3000_0001, "reporting", 1, Some(40))).contains("донесение через 2 с"));
}
#[test]
fn an_empty_picture_says_there_was_no_recon() {
let lines = picture_lines(&picture(Vec::new(), Vec::new(), Vec::new()));
assert_eq!(lines.len(), 1);
assert!(lines[0].contains("Разведки не было"), "{lines:?}");
}
// The review shows the marks with their reasons and the drones aimed at them; the ids are the
// synthetic ones, and nothing of the unit's truth (kind, health, exact place) is in the report.
#[test]
fn the_review_lists_marks_reasons_and_recon_aims() {
let m = mark(0x1000_0001, "launcher", None, "coarse", Confidence::Probable, 1000);
let mid = m.id;
let aim = AimReport { drone: 7, unit: mid, intent: "sead", since: 900, switches: 0, confidence: Some(Confidence::Probable), recon: true, priority: Some(m.priority) };
let unit_aim = AimReport { drone: 8, unit: 3, intent: "plan", since: 900, switches: 0, confidence: Some(Confidence::Confirmed), recon: false, priority: None };
let lines = picture_lines(&picture(vec![m], vec![sortie(0x3000_0001, "outbound", 1, None)], vec![aim, unit_aim]));
assert!(lines.iter().any(|l| l.contains(&format!("Отметка {mid}")) && l.contains("пусковая")), "{lines:?}");
assert!(lines.iter().any(|l| l.contains("↳") && l.contains("приоритет")), "{lines:?}");
assert!(lines.iter().any(|l| l.contains("Дрон 7 целится в отметку") && l.contains("подавление ПВО")), "{lines:?}");
// A unit contact's aim is not a recon aim: it is not listed here.
assert!(!lines.iter().any(|l| l.contains("Дрон 8")), "{lines:?}");
// No true unit id leaks: the mark id is synthetic, far above any real unit's.
assert!(mid >= 0x1000_0000);
}
#[test]
fn every_public_name_is_translated() {
for key in ["unknown", "radar", "launcher", "gun", "ew", "support"] {
assert_ne!(category_name(key), key, "{key}");
}
for key in ["multi", "search", "engagement", "height"] {
assert_ne!(role_name(key), key, "{key}");
}
for key in ["flyby", "emission", "jamming", "launch"] {
assert_ne!(source_name(key), key, "{key}");
}
assert_ne!(quality_name("coarse"), "coarse");
assert_ne!(quality_name("refined"), "refined");
}
}
+244 -30
View File
@@ -9,7 +9,7 @@ use crate::sim::catalog::sound;
use crate::film::{self, Film}; use crate::film::{self, Film};
use crate::panel::distance; use crate::panel::distance;
use crate::sim::Ground; use crate::sim::Ground;
use crate::sim::record::{EventKind, Recording, STEP, StrikeResult, What}; use crate::sim::record::{Chain, ChainOutcome, ChainStepKind, EventKind, Recording, STEP, StrikeResult, What};
use std::cell::Cell; use std::cell::Cell;
use crate::sim::{Class, DroneKind, Out, Sim}; use crate::sim::{Class, DroneKind, Out, Sim};
use glam::DVec3; use glam::DVec3;
@@ -187,6 +187,67 @@ pub fn row(rec: &Recording, i: usize) -> String {
format!("{} {what}", clock(e.at as f64)) format!("{} {what}", clock(e.at as f64))
} }
/// A row of the after-action chain list and where a click on it opens a replay.
#[derive(Clone, Debug, PartialEq)]
pub struct ChainRow {
pub text: String,
/// The recorded event to clip (the outcome), when there is one.
pub event: Option<usize>,
/// Otherwise the recording's tick to open the map at (the launch, else the mark).
pub at: f64,
}
/// The short chains of a raid: отметка → передача → захват → пуск → исход, filtered by a
/// battery's id when asked. The list is the recording's measured transitions, not a guess.
pub fn chain_rows(rec: &Recording, battery: Option<u32>) -> Vec<ChainRow> {
rec.chains(battery).iter().map(|chain| ChainRow { text: chain_row(rec, chain), event: chain.outcome_event(), at: chain_jump_at(chain) }).collect()
}
/// Where a chain opens in a replay when its outcome has no recorded event.
fn chain_jump_at(chain: &Chain) -> f64 {
chain
.step(ChainStepKind::Launch)
.or_else(|| chain.step(ChainStepKind::Mark))
.map_or(0.0, |s| s.at as f64)
}
fn chain_step_name(chain: &Chain, kind: ChainStepKind, own: bool) -> &'static str {
match kind {
ChainStepKind::Mark => "отметка",
ChainStepKind::Handoff if own => "передача (своя РЛС)",
ChainStepKind::Handoff => "передача (сеть)",
ChainStepKind::Lock => "захват",
ChainStepKind::Launch => "пуск",
ChainStepKind::Outcome => match chain.outcome {
ChainOutcome::Destroyed => "сбит",
ChainOutcome::Hit => "прорыв",
ChainOutcome::Lost => "потерян",
ChainOutcome::Unfinished => "без исхода",
},
}
}
/// One chain as a line: the battery, its contact, and the four or five measured steps.
pub fn chain_row(rec: &Recording, chain: &Chain) -> String {
let index = rec.sams.iter().position(|s| s.0 == chain.sam).map(|i| i + 1);
let kind = rec.sam(chain.sam).map_or("ПВО", |(kind, _)| kind.name());
let target = rec
.track(chain.target)
.and_then(|t| match t.what {
What::Drone(kind) => Some(kind.spec().name),
_ => None,
})
.unwrap_or("цель");
let steps: Vec<String> = chain.steps.iter().map(|s| format!("{} {}", chain_step_name(chain, s.kind, s.own), clock(s.at as f64))).collect();
let battery = index.map_or_else(|| format!("№? {kind}"), |i| format!("№{i} {kind}"));
format!(
"{} {battery} → «{target}»: {}{}",
clock(chain.marked_at() as f64),
steps.join(" → "),
if chain.missed() { " · без пуска" } else { "" },
)
}
/// How worth watching an event is: the reel takes the best. /// How worth watching an event is: the reel takes the best.
pub fn interest(rec: &Recording, i: usize) -> f64 { pub fn interest(rec: &Recording, i: usize) -> f64 {
let e = &rec.events[i]; let e = &rec.events[i];
@@ -299,6 +360,16 @@ impl Player {
} }
} }
/// Opens the replay at a recording tick (a chain's launch or mark), holding that frame.
pub fn seek(&mut self, rec: &Recording, at: f64) {
self.t = at.clamp(0.0, rec.len as f64);
self.heard = self.t;
self.shot = (usize::MAX, 0);
self.fade = 0;
self.card = 0;
self.paused = true;
}
/// The wheel: scrubs the map and the full replay, skips clips. /// The wheel: scrubs the map and the full replay, skips clips.
pub fn wheel(&mut self, steps: f32, rec: &Recording) { pub fn wheel(&mut self, steps: f32, rec: &Recording) {
let c = if steps > 0.0 { Control::Back } else { Control::Forward }; let c = if steps > 0.0 { Control::Back } else { Control::Forward };
@@ -525,7 +596,7 @@ impl Player {
/// Sounds as the camera hears them: moved so the player stands where the camera is. /// Sounds as the camera hears them: moved so the player stands where the camera is.
fn sounds(&mut self, rec: &Recording, listener: DVec3, out: &mut Out) { fn sounds(&mut self, rec: &Recording, listener: DVec3, out: &mut Out) {
let heard = |p: DVec3| listener + (p - self.eye); let heard = |p: DVec3| listener + (p - self.eye);
for e in rec.events.iter().filter(|e| (self.heard..self.t).contains(&(e.at as f64))) { for (_, e) in rec.events_between(self.heard, self.t) {
let event = match e.kind { let event = match e.kind {
EventKind::Kill { kind, outcome, .. } => crate::sim::outcome::look(kind, outcome).3, EventKind::Kill { kind, outcome, .. } => crate::sim::outcome::look(kind, outcome).3,
EventKind::Hit { power, .. } | EventKind::Crash { power, .. } => [sound::BLAST_AIR, sound::BLAST_MEDIUM, sound::BLAST_BIG, sound::BLAST_HEAVY, sound::BLAST_HUGE][(power as usize).min(4)], EventKind::Hit { power, .. } | EventKind::Crash { power, .. } => [sound::BLAST_AIR, sound::BLAST_MEDIUM, sound::BLAST_BIG, sound::BLAST_HEAVY, sound::BLAST_HUGE][(power as usize).min(4)],
@@ -546,7 +617,7 @@ impl Player {
} }
// New recordings carry the exact launch and ignition sounds and their actual positions. // New recordings carry the exact launch and ignition sounds and their actual positions.
if let Some(scene) = &rec.scene { if let Some(scene) = &rec.scene {
for e in scene.events().iter().filter(|e| (self.heard..self.t).contains(&(e.at as f64))) { for e in scene.events_between(self.heard, self.t) {
match e.kind { match e.kind {
crate::sim::record::SceneKind::MissileLaunch { sound, pitch, .. } => out.sound(sound, heard(e.pos), 1.0, pitch), crate::sim::record::SceneKind::MissileLaunch { sound, pitch, .. } => out.sound(sound, heard(e.pos), 1.0, pitch),
crate::sim::record::SceneKind::MotorIgnition { sound: Some(sound), .. } => out.sound(sound, heard(e.pos), 1.0, 1.0), crate::sim::record::SceneKind::MotorIgnition { sound: Some(sound), .. } => out.sound(sound, heard(e.pos), 1.0, 1.0),
@@ -773,9 +844,9 @@ impl Player {
// The full replay follows what comes next: the next event within 6 s, else the drone // The full replay follows what comes next: the next event within 6 s, else the drone
// nearest its target. // nearest its target.
Mode::Full => rec Mode::Full => rec
.events .events_between(self.t - 30.0, self.t + 120.0)
.iter() .next()
.position(|e| (self.t - 30.0..self.t + 120.0).contains(&(e.at as f64))) .map(|(i, _)| i)
.or(if self.shot.0 != usize::MAX && (rec.events[self.shot.0].at as f64) > self.t - 60.0 { Some(self.shot.0) } else { None }), .or(if self.shot.0 != usize::MAX && (rec.events[self.shot.0].at as f64) > self.t - 60.0 { Some(self.shot.0) } else { None }),
Mode::Map | Mode::Film(_) => None, Mode::Map | Mode::Film(_) => None,
}; };
@@ -973,11 +1044,11 @@ impl Player {
What::Missile(..) => (0x90FFD040, 0xFFFFE070), What::Missile(..) => (0x90FFD040, 0xFFFFE070),
What::Strike | What::StrikeCarrier(_) => (0x90FFA040, 0xFFFFC060), What::Strike | What::StrikeCarrier(_) => (0x90FFA040, 0xFFFFC060),
}; };
let upto = ((self.t - tr.first as f64) / STEP as f64).floor(); let upto = ((self.t - tr.first as f64) / tr.step() as f64).floor();
if upto < 0.0 { if upto < 0.0 {
continue; continue;
} }
let last = ((tr.last() - tr.first) / STEP) as f64; let last = ((tr.last() - tr.first) / tr.step()) as f64;
let count = upto.min(last) as usize + 1; let count = upto.min(last) as usize + 1;
if count < 2 { if count < 2 {
continue; continue;
@@ -999,29 +1070,13 @@ impl Player {
s.push(fill(prev.0 - 1.5, prev.1 - 1.5, 3.0, 3.0, head)); s.push(fill(prev.0 - 1.5, prev.1 - 1.5, 3.0, 3.0, head));
} }
} }
// Events so far. // Events so far, in their order. The header's counts come from the recording's prefix
for e in rec.events.iter().filter(|e| (e.at as f64) <= self.t) { // index, not from walking the journal again; past the shape cap nothing drawn here
let (x, y) = at(e.pos); // survives `truncate`.
if !inside((x, y)) { s.extend(event_marks(rec, self.t, &at, &inside, 1024usize.saturating_sub(s.len())));
continue;
}
match e.kind {
EventKind::Kill { .. } => {
s.push(line((x - 2.5, y - 2.5), (x + 2.5, y + 2.5), 1.2, 0xFFFFE040));
s.push(line((x + 2.5, y - 2.5), (x - 2.5, y + 2.5), 1.2, 0xFFFFE040));
}
EventKind::Hit { power, .. } | EventKind::Crash { power, .. } => {
let r = 2.0 + power as f32;
s.push(fill(x - r, y - r, r * 2.0, r * 2.0, 0xB0FF3020));
}
EventKind::SamLost { .. } => s.push(fill(x - 4.0, y - 4.0, 8.0, 8.0, 0xFF200000)),
EventKind::Split { .. } => s.push(fill(x - 2.0, y - 2.0, 4.0, 4.0, 0xFFFF9020)),
EventKind::Strike { .. } => s.push(fill(x - 3.0, y - 3.0, 6.0, 6.0, 0xFFFFA040)),
}
}
// Header, legend, time line. // Header, legend, time line.
let kills = rec.events.iter().filter(|e| (e.at as f64) <= self.t && matches!(e.kind, EventKind::Kill { .. })).count(); let kills = rec.kills_until(self.t);
let hits = rec.events.iter().filter(|e| (e.at as f64) <= self.t && matches!(e.kind, EventKind::Hit { .. })).count(); let hits = rec.hits_until(self.t);
let state = if self.paused { "ПАУЗА".to_string() } else { format!("×{}", self.speed) }; let state = if self.paused { "ПАУЗА".to_string() } else { format!("×{}", self.speed) };
s.push(text(format!("КАРТА НАЛЁТА №{} · {} / {} {state} · сбито {kills} · прилётов {hits}", rec.number, clock(self.t), clock(rec.len as f64)), 8.0, 6.0, 0xFF9FE0FF, false)); s.push(text(format!("КАРТА НАЛЁТА №{} · {} / {} {state} · сбито {kills} · прилётов {hits}", rec.number, clock(self.t), clock(rec.len as f64)), 8.0, 6.0, 0xFF9FE0FF, false));
let legend = "красный: цели · серый: ложные · жёлтый: перехватчики · x сбит · квадрат: прилёт"; let legend = "красный: цели · серый: ложные · жёлтый: перехватчики · x сбит · квадрат: прилёт";
@@ -1040,6 +1095,10 @@ impl Player {
s.push(fill(tx, ty, tw, 3.0, 0x60FFFFFF)); s.push(fill(tx, ty, tw, 3.0, 0x60FFFFFF));
let len = rec.len.max(1) as f32; let len = rec.len.max(1) as f32;
for e in &rec.events { for e in &rec.events {
// The line is cut at 1024 shapes: past that, a mark would not be kept.
if s.len() >= 1024 {
break;
}
let x = tx + tw * e.at as f32 / len; let x = tx + tw * e.at as f32 / len;
let c = match e.kind { let c = match e.kind {
EventKind::Kill { .. } => 0xFFFFE040, EventKind::Kill { .. } => 0xFFFFE040,
@@ -1057,6 +1116,42 @@ impl Player {
} }
} }
/// The marks of the events up to `t` on the raid map, in the order they happened: a kill as a
/// cross, a hit as a square, a lost system as a dark square, a split and a strike as dots. Reads
/// the journal by time (`events_until`) and stops at `room` shapes, the rest of the map's cap.
fn event_marks(
rec: &Recording,
t: f64,
at: &impl Fn(DVec3) -> (f32, f32),
inside: &impl Fn((f32, f32)) -> bool,
room: usize,
) -> Vec<Shape> {
let mut s = Vec::new();
for (_, e) in rec.events_until(t) {
if s.len() >= room {
break;
}
let (x, y) = at(e.pos);
if !inside((x, y)) {
continue;
}
match e.kind {
EventKind::Kill { .. } => {
s.push(line((x - 2.5, y - 2.5), (x + 2.5, y + 2.5), 1.2, 0xFFFFE040));
s.push(line((x + 2.5, y - 2.5), (x - 2.5, y + 2.5), 1.2, 0xFFFFE040));
}
EventKind::Hit { power, .. } | EventKind::Crash { power, .. } => {
let r = 2.0 + power as f32;
s.push(fill(x - r, y - r, r * 2.0, r * 2.0, 0xB0FF3020));
}
EventKind::SamLost { .. } => s.push(fill(x - 4.0, y - 4.0, 8.0, 8.0, 0xFF200000)),
EventKind::Split { .. } => s.push(fill(x - 2.0, y - 2.0, 4.0, 4.0, 0xFFFF9020)),
EventKind::Strike { .. } => s.push(fill(x - 3.0, y - 3.0, 6.0, 6.0, 0xFFFFA040)),
}
}
s
}
/// The ground the map shows, as [lo x, lo z, hi x, hi z]: everything that /// The ground the map shows, as [lo x, lo z, hi x, hi z]: everything that
/// flew (not the ballistic falls), with the systems and objects, or round the /// flew (not the ballistic falls), with the systems and objects, or round the
/// origin when nothing did. /// origin when nothing did.
@@ -1102,6 +1197,41 @@ impl Player {
mod surface_tests { mod surface_tests {
use super::*; use super::*;
#[test]
fn a_chain_row_lists_the_measured_steps_and_opens_its_frame() {
use crate::sim::record::{Event, SceneEvent, SceneJournal, SceneKind};
use crate::sim::outcome::Outcome;
use crate::sim::MissileKind;
let mut rec = Recording::blank(300);
rec.sams = vec![(10, crate::sim::SamKind::Pantsir, DVec3::ZERO)];
rec.straight(7, What::Drone(DroneKind::Shahed), 0, 200, DVec3::new(0.0, 80.0, 0.0), DVec3::new(200.0, 80.0, 0.0));
let mut scene = SceneJournal::default();
let at = |at: u32, kind| SceneEvent { at, pos: DVec3::ZERO, kind };
scene.fixture_push(at(20, SceneKind::TrackAcquired { sam: 10, target: 7, ever_own: false }));
scene.fixture_push(at(30, SceneKind::TrackSource { sam: 10, target: 7, ever_own: true }));
scene.fixture_push(at(40, SceneKind::TrackLock { sam: 10, target: 7, locked: true }));
scene.fixture_push(at(50, SceneKind::MissileLaunch { missile: 500, sam: 10, target: 7, kind: MissileKind::M57e6, sound: "airdef:launch.pantsir", pitch: 1.0 }));
rec.scene = Some(scene);
rec.events.push(Event {
at: 90,
pos: DVec3::ZERO,
kind: EventKind::Kill { drone: 7, kind: DroneKind::Shahed, sam: 10, sam_kind: crate::sim::SamKind::Pantsir, sam_index: 0, missile: Some(500), outcome: Outcome::DisabledFalling },
});
let rows = chain_rows(&rec, None);
assert_eq!(rows.len(), 1);
for step in ["отметка", "передача", "захват", "пуск", "сбит"] {
assert!(rows[0].text.contains(step), "the chain row misses {step}: {}", rows[0].text);
}
assert_eq!(rows[0].event, Some(0));
assert!(chain_rows(&rec, Some(10)).len() == 1);
assert!(chain_rows(&rec, Some(11)).is_empty());
// A chain with no recorded outcome opens its launch frame on the map, held still.
let mut player = Player::new(1, Mode::Map, &Sim::new(1));
player.seek(&rec, rows[0].at);
assert!(player.paused);
assert!((player.time() - rows[0].at).abs() < 1e-9);
}
/// A gun standing on the sea floor films from above the water, not from under it. /// A gun standing on the sea floor films from above the water, not from under it.
#[test] #[test]
fn the_gun_camera_is_lifted_above_the_water() { fn the_gun_camera_is_lifted_above_the_water() {
@@ -1326,6 +1456,90 @@ mod engine_tests {
assert!(host.0.is_empty()); assert!(host.0.is_empty());
} }
// #150: the sounds of a window are exactly the events it holds: the same set, order and
// names after any seek, forward or back, empty or spanning ties.
#[test]
fn event_sounds_are_exactly_the_events_of_the_window_after_any_seek() {
use crate::sim::catalog::sound;
use crate::sim::record::{Event, EventKind};
let mut rec = Recording::blank(1000);
rec.events = [10u32, 10, 25, 40, 40, 40, 75, 130]
.into_iter()
.enumerate()
.map(|(i, at)| Event {
at,
pos: DVec3::new(i as f64, 80.0, 0.0),
kind: EventKind::Crash { drone: 1, kind: DroneKind::Geran3, power: (i % 5) as u32 },
})
.collect();
let names = |lo: f64, hi: f64| -> Vec<&'static str> {
rec.events
.iter()
.filter(|e| (lo..hi).contains(&(e.at as f64)))
.map(|e| match e.kind {
EventKind::Crash { power, .. } => [sound::BLAST_AIR, sound::BLAST_MEDIUM, sound::BLAST_BIG, sound::BLAST_HEAVY, sound::BLAST_HUGE][(power as usize).min(4)],
_ => unreachable!(),
})
.collect()
};
let mut p = player(&rec);
let mut out = Out::default();
for &(heard, t) in &[(0.0, 11.0), (10.0, 10.0), (11.0, 25.0), (10.0, 40.0), (25.0, 40.5), (40.0, 41.0), (40.0, 75.0), (75.0, 130.5), (130.0, 0.0), (41.0, 25.0), (10.5, 40.0)] {
out.sounds.clear();
p.heard = heard;
p.t = t;
p.sounds(&rec, DVec3::ZERO, &mut out);
let got: Vec<&'static str> = out.sounds.iter().map(|s| s.0).collect();
assert_eq!(got, names(heard, t), "{heard}..{t}");
}
}
// #150: the map draws every event up to now, in its order, and reads only that far.
#[test]
fn the_map_marks_the_events_up_to_now_in_their_order() {
use crate::sim::record::{Event, EventKind, StrikeResult};
let ev = |at, kind| Event { at, pos: DVec3::new(at as f64, 0.0, 0.0), kind };
let mut rec = Recording::blank(1000);
rec.events = vec![
ev(100, EventKind::Kill { drone: 1, kind: DroneKind::Geran3, sam: 1, sam_kind: crate::sim::SamKind::S400, sam_index: 0, missile: None, outcome: Default::default() }),
ev(200, EventKind::Hit { drone: 1, kind: DroneKind::Geran3, power: 2, object: None, sam: None }),
ev(300, EventKind::Crash { drone: 1, kind: DroneKind::Geran3, power: 1 }),
ev(400, EventKind::SamLost { sam: 1, kind: crate::sim::SamKind::S400, index: 0 }),
ev(500, EventKind::Split { drone: 1 }),
ev(600, EventKind::Strike { site: 1, result: StrikeResult::Stunned }),
ev(900, EventKind::Kill { drone: 1, kind: DroneKind::Geran3, sam: 1, sam_kind: crate::sim::SamKind::S400, sam_index: 0, missile: None, outcome: Default::default() }),
];
rec.close();
let at = |p: DVec3| (p.x as f32, 0.0);
let all = |_: (f32, f32)| true;
let colors = |shapes: Vec<Shape>| shapes
.iter()
.map(|s| match s {
Shape::Fill(f) => f.color,
Shape::Quad(q) => q.color,
_ => 0,
})
.collect::<Vec<_>>();
// The kill's cross, then the hit, the crash, the lost system and the split: the earlier
// events only, in their order.
assert_eq!(
colors(event_marks(&rec, 500.0, &at, &all, usize::MAX)),
vec![0xFFFFE040, 0xFFFFE040, 0xB0FF3020, 0xB0FF3020, 0xFF200000, 0xFFFF9020]
);
assert_eq!(
colors(event_marks(&rec, 600.0, &at, &all, usize::MAX)),
vec![0xFFFFE040, 0xFFFFE040, 0xB0FF3020, 0xB0FF3020, 0xFF200000, 0xFFFF9020, 0xFFFFA040]
);
// The map's shape cap stops the reading; nothing past it would be kept anyway.
assert_eq!(event_marks(&rec, 600.0, &at, &all, 3).len(), 3);
// What lies outside the map is skipped, the rest keeps its order.
let left = |(x, _): (f32, f32)| x < 250.0;
assert_eq!(
colors(event_marks(&rec, 600.0, &at, &left, usize::MAX)),
vec![0xFFFFE040, 0xFFFFE040, 0xB0FF3020]
);
}
#[test] #[test]
fn a_fast_replay_is_silent() { fn a_fast_replay_is_silent() {
let rec = recording(); let rec = recording();
+243 -4
View File
@@ -33,8 +33,199 @@ impl RadarRole {
pub fn from_key(key: &str) -> Option<Self> { pub fn from_key(key: &str) -> Option<Self> {
match key { "multi" => Some(Self::Multifunction), "search" => Some(Self::Search), "engagement" => Some(Self::Engagement), "height" => Some(Self::Height), _ => None } match key { "multi" => Some(Self::Multifunction), "search" => Some(Self::Search), "engagement" => Some(Self::Engagement), "height" => Some(Self::Height), _ => None }
} }
pub fn authorizes(self) -> bool { matches!(self, Self::Multifunction | Self::Engagement) } pub fn profile(self) -> RadarProfile { RadarProfile::of(self) }
pub(super) fn reach_factor(self) -> f64 { match self { Self::Multifunction => 1.0, Self::Search => 1.15, Self::Engagement => 0.8, Self::Height => 1.05 } } pub fn authorizes(self) -> bool { self.profile().products & RadarProfile::FIRE_BIT != 0 }
}
/// What a measurement is good for. A search plot is a warning, a refined
/// plot fixes a matched contact, and a fire plot is a confirmed measurement
/// a launcher may use. Quality (0..100) is separate from identification:
/// a well-measured track can still be an unknown type (#133).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
pub enum Measure {
#[default]
Search,
Refine,
Fire,
}
impl Measure {
pub fn name(self) -> &'static str {
match self { Self::Search => "обзор", Self::Refine => "уточнение", Self::Fire => "пригоден для пуска" }
}
pub fn allows_fire(self) -> bool { self == Self::Fire }
}
/// A radar profile: a stable catalog identity over the existing `SamKind::Radar`.
/// The numbers are fictional game settings. The silhouette is shared with the
/// existing radar model: this slice does not add art (a separate owner's zone).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RadarProfile {
/// Stable content ID; old saves only have `RadarRole`, which maps here.
pub id: &'static str,
pub name: &'static str,
/// Allowed measurement products (`SEARCH_BIT`, `REFINE_BIT`, `FIRE_BIT`).
pub products: u8,
/// Ticks for the beam to go round.
pub cycle: u32,
/// Electronic revisit of held contacts between beam passes.
pub agile: bool,
/// Extra antenna height over the unit's spec mast (blocks).
pub mast: f64,
/// Search reach, a factor of the unit's sensor.
pub reach: f64,
/// Local search radius, a factor of the unit's sensor (1: the whole reach).
pub local: f64,
/// Simultaneous refined/fire channels; 0 means only search plots.
pub channels: u8,
/// Measurement error scale (blocks) and its growth per block of range.
pub sigma: f64,
pub spread: f64,
/// Vertical error as a share of the horizontal one.
pub vertical: f64,
pub deployment: &'static str,
/// The limit the profile deliberately keeps, shown in the UI.
pub limit: &'static str,
}
impl RadarProfile {
pub const SEARCH_BIT: u8 = 1;
pub const REFINE_BIT: u8 = 2;
pub const FIRE_BIT: u8 = 4;
pub const MULTI: RadarProfile = RadarProfile {
id: "radar_multi",
name: "многофункциональная",
products: Self::SEARCH_BIT | Self::REFINE_BIT | Self::FIRE_BIT,
cycle: 140,
agile: false,
mast: 0.0,
reach: 1.0,
local: 0.55,
channels: 3,
sigma: 0.7,
spread: 0.004,
vertical: 0.75,
deployment: "стационарная",
limit: "универсальная: уступает специализированным по циклу, каналам и точности",
};
pub const SEARCH: RadarProfile = RadarProfile {
id: "radar_search",
name: "дальнего обзора",
products: Self::SEARCH_BIT,
cycle: 170,
agile: false,
mast: 0.0,
reach: 1.15,
local: 1.0,
channels: 0,
sigma: 1.0,
spread: 0.008,
vertical: 1.0,
deployment: "крупная стационарная антенна",
limit: "редкие грубые отметки; своего права на пуск не даёт",
};
pub const ENGAGEMENT: RadarProfile = RadarProfile {
id: "radar_track",
name: "сопровождения",
products: Self::SEARCH_BIT | Self::REFINE_BIT | Self::FIRE_BIT,
cycle: 70,
agile: true,
mast: 0.0,
reach: 0.8,
local: 0.12,
channels: 2,
sigma: 0.35,
spread: 0.002,
vertical: 0.6,
deployment: "мобильная панель",
limit: "локальный поиск и два канала; сеть лишь подсказывает, измеряет станция",
};
pub const HEIGHT: RadarProfile = RadarProfile {
id: "radar_height",
name: "мачта низких высот",
products: Self::SEARCH_BIT | Self::REFINE_BIT,
cycle: 140,
agile: false,
mast: 8.0,
reach: 1.05,
local: 0.15,
channels: 3,
sigma: 0.5,
spread: 0.003,
vertical: 0.35,
deployment: "шасси с поднятой антенной",
limit: "уточняет низкие контакты над рельефом; сквозь препятствия не видит и права на пуск не даёт",
};
/// A weapon's own radar: it measures for its own fire control. Kept out of
/// the separate radar roles so embedded radars keep working as before.
pub const EMBEDDED: RadarProfile = RadarProfile {
id: "embedded",
name: "РЛС комплекса",
products: Self::SEARCH_BIT | Self::REFINE_BIT | Self::FIRE_BIT,
cycle: 0,
agile: false,
mast: 0.0,
reach: 1.0,
local: 1.0,
channels: 0,
sigma: 0.8,
spread: 0.004,
// The old embedded scan drew its vertical error at half the horizontal one.
vertical: 0.5,
deployment: "встроенная",
limit: "обслуживает только свой комплекс",
};
pub fn of(role: RadarRole) -> Self {
match role {
RadarRole::Multifunction => Self::MULTI,
RadarRole::Search => Self::SEARCH,
RadarRole::Engagement => Self::ENGAGEMENT,
RadarRole::Height => Self::HEIGHT,
}
}
/// Old saves write the role key; new saves write the stable profile ID.
/// Both read here, so a legacy `search` line maps to `radar_search`.
pub fn from_id(id: &str) -> Option<Self> {
match id {
"radar_multi" | "multi" => Some(Self::MULTI),
"radar_search" | "search" => Some(Self::SEARCH),
"radar_track" | "engagement" => Some(Self::ENGAGEMENT),
"radar_height" | "height" => Some(Self::HEIGHT),
_ => None,
}
}
pub fn role(self) -> RadarRole {
match self.id {
"radar_search" => RadarRole::Search,
"radar_track" => RadarRole::Engagement,
"radar_height" => RadarRole::Height,
_ => RadarRole::Multifunction,
}
}
pub fn allows(self, product: Measure) -> bool {
match product {
Measure::Search => self.products & Self::SEARCH_BIT != 0,
Measure::Refine => self.products & Self::REFINE_BIT != 0,
Measure::Fire => self.products & Self::FIRE_BIT != 0,
}
}
pub fn products_text(self) -> &'static str {
match self.products {
p if p == Self::SEARCH_BIT | Self::REFINE_BIT | Self::FIRE_BIT => "обзор, уточнение, пуск",
p if p == Self::SEARCH_BIT | Self::REFINE_BIT => "обзор, уточнение",
p if p == Self::SEARCH_BIT | Self::FIRE_BIT => "обзор, пуск",
_ => "обзор",
}
}
}
impl Sam {
/// The profile this unit measures with. Embedded radars keep their kind's
/// own scan and reach; only the separate radar uses a selectable profile.
pub fn radar_profile(&self) -> RadarProfile {
if self.kind == SamKind::Radar { RadarProfile::of(self.radar_role) } else { RadarProfile::EMBEDDED }
}
} }
impl Sam { impl Sam {
@@ -113,7 +304,22 @@ mod tests {
} }
fn track(now: u64) -> Track { fn track(now: u64) -> Track {
Track { id: 42, kind: DroneKind::Kh101, pos: DVec3::new(0.0, 100.0, -200.0), vel: DVec3::ZERO, tick: now, own_tick: now, ttl: 400, hits: 3, locked: false } Track {
id: 42,
class: ClassEst::Firm(Class::Cruise),
pos: DVec3::new(0.0, 100.0, -200.0),
vel: DVec3::ZERO,
tick: now,
own_tick: now,
source: 1,
product: battery::Measure::Fire,
quality: 90,
own_product: battery::Measure::Fire,
own_quality: 90,
ttl: 400,
hits: 3,
locked: false,
}
} }
#[test] #[test]
@@ -251,6 +457,24 @@ mod tests {
assert!(sight::reach(&r, DroneKind::Kh101, 5000.0) > base_reach); assert!(sight::reach(&r, DroneKind::Kh101, 5000.0) > base_reach);
} }
#[test]
fn profiles_have_stable_ids_and_deliberately_different_limits() {
let search = RadarRole::Search.profile();
let height = RadarRole::Height.profile();
let engagement = RadarRole::Engagement.profile();
let multi = RadarRole::Multifunction.profile();
assert_eq!((search.id, height.id, engagement.id, multi.id), ("radar_search", "radar_height", "radar_track", "radar_multi"));
assert!(!RadarRole::Search.authorizes() && !RadarRole::Height.authorizes() && RadarRole::Engagement.authorizes());
assert_eq!(search.products, RadarProfile::SEARCH_BIT);
assert_eq!(height.products, RadarProfile::SEARCH_BIT | RadarProfile::REFINE_BIT);
assert_ne!(search.cycle, engagement.cycle);
assert!(height.mast > search.mast && height.mast > engagement.mast);
assert!(engagement.channels < multi.channels && height.channels > 0 && search.channels == 0);
assert!(search.local > height.local && height.local > engagement.local);
assert_eq!(RadarProfile::from_id(search.id), Some(search));
assert_eq!(RadarProfile::from_id("search"), Some(search), "legacy role keys map to profiles");
}
#[test] #[test]
fn launcher_has_no_own_map_sensor_and_mode_switch_drops_stale_tracks() { fn launcher_has_no_own_map_sensor_and_mode_switch_drops_stale_tracks() {
let mut sim = Sim::new(3); let mut sim = Sim::new(3);
@@ -294,7 +518,22 @@ mod emission_tests {
receiver.radar_on = false; receiver.radar_on = false;
sim.add_drone(DroneKind::Kh101, DVec3::new(0.0, 70.0, -100.0), DVec3::Z, DVec3::ZERO); sim.add_drone(DroneKind::Kh101, DVec3::new(0.0, 70.0, -100.0), DVec3::Z, DVec3::ZERO);
let id = sim.drones[0].id; let id = sim.drones[0].id;
source.tracks.push(Track { id, kind: DroneKind::Kh101, pos: sim.drones[0].pos, vel: DVec3::ZERO, tick: 20, own_tick: 20, ttl: 200, hits: 2, locked: false }); source.tracks.push(Track {
id,
class: ClassEst::Firm(Class::Cruise),
pos: sim.drones[0].pos,
vel: DVec3::ZERO,
tick: 20,
own_tick: 20,
source: 1,
product: battery::Measure::Fire,
quality: 90,
own_product: battery::Measure::Fire,
own_quality: 90,
ttl: 200,
hits: 2,
locked: false,
});
sim.sams.extend([source, receiver]); sim.sams.extend([source, receiver]);
let mut ground = Ground::default(); let mut ground = Ground::default();
sim.update_sight(&mut ground); sim.update_sight(&mut ground);
+97 -2
View File
@@ -3,7 +3,7 @@
//! Balance and rendering remain in `DroneSpec` and `SamSpec`: the catalog //! Balance and rendering remain in `DroneSpec` and `SamSpec`: the catalog
//! refers to those typed definitions instead of copying their values. The //! refers to those typed definitions instead of copying their values. The
//! first eleven drone entries retain the historical positional wave-save order. //! first eleven drone entries retain the historical positional wave-save order.
use super::{DroneKind, SamKind}; use super::{battery::RadarProfile, battery::RadarRole, battery::SamMode, DroneKind, SamKind};
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
pub struct Aircraft { pub struct Aircraft {
@@ -19,6 +19,30 @@ impl Aircraft {
pub fn id(self) -> &'static str { self.kind.spec().key } pub fn id(self) -> &'static str { self.kind.spec().key }
} }
/// A variant of a complex: a configuration over an existing kind, deployed
/// under its own command/menu id. Not new balance.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct UnitVariant {
/// Existing command/menu key; changing it requires an explicit migration.
pub id: &'static str,
/// Its own placeable remote, so every configuration is a separate item.
pub deploy_item: &'static str,
pub kind: SamKind,
pub mode: SamMode,
pub role: RadarRole,
/// The deploy menu's row.
pub label: &'static str,
/// What the configuration is for (shown in the deploy menu).
pub description: &'static str,
}
impl UnitVariant {
/// The typed radar profile behind a separate radar variant.
pub fn radar_profile(self) -> Option<RadarProfile> {
(self.kind == SamKind::Radar).then(|| RadarProfile::of(self.role))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)] #[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum GroundStrike { pub enum GroundStrike {
/// Game-only RM48U coordinate-strike profile for S-400. Evidence: official agency report, /// Game-only RM48U coordinate-strike profile for S-400. Evidence: official agency report,
@@ -59,6 +83,7 @@ pub mod sound {
// Generated entries keep the historical raid and unit ordering. // Generated entries keep the historical raid and unit ordering.
include!("catalog_entries.rs"); include!("catalog_entries.rs");
include!("unit_variants_generated.rs");
/// Existing positional serialization makes the first entries' order part of the save format. /// Existing positional serialization makes the first entries' order part of the save format.
const fn raid_count() -> usize { const fn raid_count() -> usize {
@@ -98,7 +123,7 @@ pub fn unit(kind: SamKind) -> &'static Unit {
/// Inventory ordering is stable for existing remotes, while availability comes from the same entries as raids. /// Inventory ordering is stable for existing remotes, while availability comes from the same entries as raids.
const fn inventory_count() -> usize { const fn inventory_count() -> usize {
let mut n = UNIT_COUNT + 4; let mut n = UNIT_COUNT + VARIANTS.len() + 4;
let mut i = 0; let mut i = 0;
while i < AIRCRAFT.len() { while i < AIRCRAFT.len() {
if AIRCRAFT[i].launch_item.is_some() { n += 1; } if AIRCRAFT[i].launch_item.is_some() { n += 1; }
@@ -121,6 +146,10 @@ const fn inventory_items() -> [&'static str; INVENTORY_COUNT] {
out[n] = "airdef:mover"; out[n] = "airdef:mover";
out[n + 1] = "airdef:flare_gun"; out[n + 1] = "airdef:flare_gun";
out[n + 2] = "airdef:remover"; out[n + 2] = "airdef:remover";
// Variant remotes come last: every existing remote keeps its slot.
n += 3;
i = 0;
while i < VARIANTS.len() { out[n] = VARIANTS[i].deploy_item; n += 1; i += 1; }
out out
} }
pub const INVENTORY: [&str; INVENTORY_COUNT] = inventory_items(); pub const INVENTORY: [&str; INVENTORY_COUNT] = inventory_items();
@@ -131,6 +160,18 @@ pub fn launch_item(id: &str) -> Option<DroneKind> {
pub fn deploy_item(id: &str) -> Option<SamKind> { pub fn deploy_item(id: &str) -> Option<SamKind> {
UNITS.iter().find(|entry| entry.deploy_item == id).map(|entry| entry.kind) UNITS.iter().find(|entry| entry.deploy_item == id).map(|entry| entry.kind)
} }
/// The configuration a remote item deploys: a unit's ordinary integrated
/// system or a variant's own mode and radar role.
pub fn deploy_item_configuration(id: &str) -> Option<(SamKind, SamMode, RadarRole)> {
if let Some(kind) = deploy_item(id) {
return Some((kind, SamMode::Integrated, RadarRole::Multifunction));
}
VARIANTS.iter().find(|entry| entry.deploy_item == id).map(|entry| (entry.kind, entry.mode, entry.role))
}
pub fn variant(id: &str) -> Option<&'static UnitVariant> {
VARIANTS.iter().find(|variant| variant.id == id)
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
@@ -170,9 +211,63 @@ mod tests {
} }
assert_eq!(kinds, SamKind::ALL.into_iter().collect()); assert_eq!(kinds, SamKind::ALL.into_iter().collect());
for e in VARIANTS {
assert!(items.insert(e.deploy_item), "duplicate item {}", e.deploy_item);
assert_eq!(e.deploy_item, format!("airdef:deploy_{}", e.id));
}
assert_eq!(&RAID_KINDS[..11], &[Gerbera, Shahed, Geran3, Lancet, Kh101, Kalibr, Kh22, Zircon, Iskander, Kinzhal, Oreshnik]); assert_eq!(&RAID_KINDS[..11], &[Gerbera, Shahed, Geran3, Lancet, Kh101, Kalibr, Kh22, Zircon, Iskander, Kinzhal, Oreshnik]);
} }
/// `give` hands out every remote once; the ordinary units keep their historical
/// slots and the variant remotes are appended after them.
#[test]
fn inventory_holds_every_remote_once_and_keeps_existing_slots() {
let unique: HashSet<&str> = INVENTORY.iter().copied().collect();
assert_eq!(unique.len(), INVENTORY.len(), "duplicate inventory item");
let launches = AIRCRAFT.iter().filter(|a| a.launch_item.is_some()).count();
let first_unit = 1 + launches;
for (i, unit) in UNITS.iter().enumerate() {
assert_eq!(INVENTORY[first_unit + i], unit.deploy_item);
assert_eq!(deploy_item_configuration(unit.deploy_item), Some((unit.kind, SamMode::Integrated, RadarRole::Multifunction)));
}
let tail = first_unit + UNITS.len();
assert_eq!(&INVENTORY[tail..tail + 3], &["airdef:mover", "airdef:flare_gun", "airdef:remover"]);
assert_eq!(&INVENTORY[tail + 3..], &VARIANTS.iter().map(|v| v.deploy_item).collect::<Vec<_>>()[..]);
assert_eq!(deploy_item_configuration("airdef:designator"), None);
assert_eq!(deploy_item_configuration("airdef:deploy_radar_track"), Some((SamKind::Radar, SamMode::Integrated, RadarRole::Engagement)));
}
/// A variant is a configuration of an existing kind, one row in the catalog,
/// under an id that stays out of the other identities' keys; the battery-menu
/// order is part of the UI's tested behaviour.
#[test]
fn variants_configure_existing_units_under_free_ids() {
let ids: Vec<&str> = VARIANTS.iter().map(|v| v.id).collect();
assert_eq!(ids, ["s400_launcher", "s500_launcher", "radar_search", "radar_track", "radar_height"]);
for v in VARIANTS {
assert!(UNITS.iter().any(|unit| unit.kind == v.kind), "{} configures an unknown kind", v.id);
assert!(SamKind::from_key(v.id).is_none(), "{} shadows a unit kind", v.id);
assert!(!INVENTORY.contains(&format!("airdef:{}", v.id).as_str()), "{} doubles an item", v.id);
assert_eq!(v.deploy_item, format!("airdef:deploy_{}", v.id));
assert!(INVENTORY.contains(&v.deploy_item), "{} has no remote in the inventory", v.id);
assert_eq!(deploy_item_configuration(v.deploy_item), Some((v.kind, v.mode, v.role)));
assert!(!v.label.is_empty() && !v.description.is_empty());
assert_eq!(variant(v.id).map(|u| (u.kind, u.mode, u.role)), Some((v.kind, v.mode, v.role)));
if v.kind == SamKind::Radar {
let profile = v.radar_profile().expect("a radar variant has a profile");
assert_eq!(profile.id, v.id, "the stable profile ID is the variant ID");
assert_eq!(profile.role(), v.role);
assert!(profile.channels <= 3 && profile.cycle > 0);
} else {
assert!(v.radar_profile().is_none());
}
}
let launcher = variant("s400_launcher").unwrap();
assert_eq!((launcher.kind, launcher.mode, launcher.role), (SamKind::S400, SamMode::LauncherOnly, RadarRole::Multifunction));
assert_eq!(VARIANTS[4].id, "radar_height");
assert!(variant("miss").is_none() && variant("s400").is_none());
}
/// The catalog is the only copy of the numbers: a kind without a row, or a row under /// The catalog is the only copy of the numbers: a kind without a row, or a row under
/// another kind, would be a silent balance change. /// another kind, would be a silent balance change.
#[test] #[test]
+1
View File
@@ -31,4 +31,5 @@ pub const UNITS: &[Unit] = &[
Unit { kind: SamKind::Tzm, deploy_item: "airdef:deploy_tzm" }, Unit { kind: SamKind::Tzm, deploy_item: "airdef:deploy_tzm" },
Unit { kind: SamKind::Ew, deploy_item: "airdef:deploy_ew" }, Unit { kind: SamKind::Ew, deploy_item: "airdef:deploy_ew" },
Unit { kind: SamKind::Light, deploy_item: "airdef:deploy_light" }, Unit { kind: SamKind::Light, deploy_item: "airdef:deploy_light" },
Unit { kind: SamKind::Optical, deploy_item: "airdef:deploy_optical" },
]; ];
+8 -30
View File
@@ -54,6 +54,10 @@ impl Part {
Part::Comms => "Св", Part::Comms => "Св",
} }
} }
/// The short label as this kind of unit reads it: a passive post has optics, not a radar.
pub fn short_on(self, kind: SamKind) -> &'static str {
if self == Part::Sensor && kind == SamKind::Optical { "Опт" } else { self.short() }
}
fn index(self) -> usize { fn index(self) -> usize {
self as usize self as usize
} }
@@ -61,7 +65,8 @@ impl Part {
pub fn on(self, kind: SamKind) -> bool { pub fn on(self, kind: SamKind) -> bool {
let spec = kind.spec(); let spec = kind.spec();
match self { match self {
Part::Sensor => spec.sensor > 0.0, // A passive optical post has a sensor without radar reach: it can be damaged and blinded too.
Part::Sensor => spec.sensor > 0.0 || kind == SamKind::Optical,
Part::Mount => kind.armed() && kind != SamKind::Light && (spec.missile.is_some() || spec.gun.is_some()), Part::Mount => kind.armed() && kind != SamKind::Light && (spec.missile.is_some() || spec.gun.is_some()),
Part::Launcher => spec.missile.is_some(), Part::Launcher => spec.missile.is_some(),
Part::Gun => spec.gun.is_some(), Part::Gun => spec.gun.is_some(),
@@ -112,30 +117,6 @@ impl Comps {
pub fn whole(&self) -> bool { pub fn whole(&self) -> bool {
self.0.iter().all(|&v| v >= 1.0) self.0.iter().all(|&v| v >= 1.0)
} }
/// Parts of this kind that are not whole, as "РЛС 40%, ходовая отказ".
pub fn describe(&self, kind: SamKind) -> String {
Part::ALL
.iter()
.filter(|p| p.on(kind) && self.get(**p) < 1.0)
.map(|p| match self.state(*p) {
PartState::Failed => format!("{} отказ", p.short()),
_ => format!("{} {:.0}%", p.short(), self.get(*p) * 100.0),
})
.collect::<Vec<_>>()
.join(", ")
}
/// The weakest part alone, for a one-line status (the full list is on the monitor).
pub fn worst(&self, kind: SamKind) -> String {
Part::ALL
.iter()
.filter(|p| p.on(kind) && self.get(**p) < 1.0)
.min_by(|a, b| self.get(**a).total_cmp(&self.get(**b)))
.map(|p| match self.state(*p) {
PartState::Failed => format!("{} отказ", p.short()),
_ => format!("{} {:.0}%", p.short(), self.get(*p) * 100.0),
})
.unwrap_or_default()
}
} }
/// Health points an object loses at the centre of a blast. /// Health points an object loses at the centre of a blast.
@@ -443,9 +424,6 @@ impl Sam {
pub fn part_state(&self, p: Part) -> PartState { pub fn part_state(&self, p: Part) -> PartState {
if p.on(self.kind) { self.comps.state(p) } else { PartState::Ok } if p.on(self.kind) { self.comps.state(p) } else { PartState::Ok }
} }
pub fn parts_text(&self) -> String {
self.comps.describe(self.kind)
}
/// The aiming drive's share of its speed: a failed one doesn't turn at all. /// The aiming drive's share of its speed: a failed one doesn't turn at all.
pub(super) fn drive_fit(&self) -> f64 { pub(super) fn drive_fit(&self) -> f64 {
let h = self.part(Part::Mount); let h = self.part(Part::Mount);
@@ -461,7 +439,7 @@ impl Sam {
0.5 + 0.5 * self.part(Part::Gun) 0.5 + 0.5 * self.part(Part::Gun)
} }
/// Its launcher's cells still good: a damaged one holds fewer missiles. /// Its launcher's cells still good: a damaged one holds fewer missiles.
pub(super) fn cells(&self) -> u32 { pub fn cells(&self) -> u32 {
let Some(load) = &self.kind.spec().missile else { return 0 }; let Some(load) = &self.kind.spec().missile else { return 0 };
let h = self.part(Part::Launcher); let h = self.part(Part::Launcher);
if h <= 0.0 { 0 } else { ((load.magazine as f64 * (0.4 + 0.6 * h)).ceil() as u32).clamp(1, load.magazine) } if h <= 0.0 { 0 } else { ((load.magazine as f64 * (0.4 + 0.6 * h)).ceil() as u32).clamp(1, load.magazine) }
@@ -475,7 +453,7 @@ impl Sam {
} }
} }
/// Ticks a reload takes: longer with a damaged launcher. /// Ticks a reload takes: longer with a damaged launcher.
pub(super) fn reload_time(&self) -> u32 { pub fn reload_time(&self) -> u32 {
let r = self.kind.spec().reload.max(1); let r = self.kind.spec().reload.max(1);
(r as f64 * (1.0 + 1.5 * (1.0 - self.part(Part::Launcher)))).round() as u32 (r as f64 * (1.0 + 1.5 * (1.0 - self.part(Part::Launcher)))).round() as u32
} }
+31 -10
View File
@@ -85,6 +85,11 @@ impl Doctrine {
if near <= slack { if near <= slack {
return true; return true;
} }
// One blip carries no measured course (#133): nothing says the contact passes the
// object by, so it is not ruled out as a threat on a velocity that is not there.
if track.hits <= 1 {
return true;
}
let (vx, vz) = (track.vel.x, track.vel.z); let (vx, vz) = (track.vel.x, track.vel.z);
let speed = vx.hypot(vz); let speed = vx.hypot(vz);
// Closing, and the line of flight passes the object within the slack. // Closing, and the line of flight passes the object within the slack.
@@ -97,23 +102,24 @@ impl Doctrine {
(if self.in_sector(pos, track.est(now)) { 0 } else { OUT_SECTOR }) | (if self.guards.is_empty() || self.threatens(track, now).is_some() { 0 } else { NO_THREAT }) (if self.in_sector(pos, track.est(now)) { 0 } else { OUT_SECTOR }) | (if self.guards.is_empty() || self.threatens(track, now).is_some() { 0 } else { NO_THREAT })
} }
/// What matters enough to spend the reserve: a ballistic missile, or anything about to hit. /// What matters enough to spend the reserve: a ballistic missile (as the track's estimate
pub fn matters(d: &Drone) -> bool { /// classes it, an unidentified contact does not count), or anything about to hit.
d.kind.spec().class == Class::Ballistic || why::arrival(d) < why::URGENT pub fn matters(d: &Drone, class: ClassEst) -> bool {
class.class() == Some(Class::Ballistic) || why::arrival(d) < why::URGENT
} }
/// The reserve holds the launch back: the magazine is at the reserve and the target doesn't matter. /// The reserve holds the launch back: the magazine is at the reserve and the target doesn't matter.
pub fn reserve_blocks(&self, missiles: u32, d: &Drone) -> u8 { pub fn reserve_blocks(&self, missiles: u32, d: &Drone, class: ClassEst) -> u8 {
if self.reserve > 0 && missiles <= self.reserve && !Self::matters(d) { RESERVE } else { 0 } if self.reserve > 0 && missiles <= self.reserve && !Self::matters(d, class) { RESERVE } else { 0 }
} }
/// Interceptors this doctrine asks for on `d`: `why::needed` by default, the base only when economical, one more when heavy. /// Interceptors this doctrine asks for on `d`: `why::needed` by default, the base only when economical, one more when heavy.
pub fn needed(&self, d: &Drone) -> u32 { pub fn needed(&self, d: &Drone, class: ClassEst) -> u32 {
let base = if d.kind.spec().class == Class::Ballistic { 2 } else { 1 }; let base = if class.class() == Some(Class::Ballistic) { 2 } else { 1 };
match self.salvo { match self.salvo {
Salvo::Economy => base, Salvo::Economy => base,
Salvo::Normal => why::needed(d), Salvo::Normal => why::needed(d, class),
Salvo::Heavy => why::needed(d) + 1, Salvo::Heavy => why::needed(d, class) + 1,
} }
} }
@@ -162,7 +168,22 @@ mod tests {
use super::*; use super::*;
fn track(pos: DVec3, vel: DVec3) -> Track { fn track(pos: DVec3, vel: DVec3) -> Track {
Track { id: 1, kind: DroneKind::Shahed, pos, vel, tick: 0, own_tick: 0, ttl: 100, hits: 3, locked: false } Track {
id: 1,
class: ClassEst::Unknown,
pos,
vel,
tick: 0,
own_tick: 0,
source: 0,
product: battery::Measure::Search,
quality: 40,
own_product: battery::Measure::Search,
own_quality: 0,
ttl: 100,
hits: 3,
locked: false,
}
} }
#[test] #[test]
+360 -31
View File
@@ -9,6 +9,11 @@
//! picture is mixed into a replay: a recording keeps trajectories, and this section is written and //! picture is mixed into a replay: a recording keeps trajectories, and this section is written and
//! read for the live simulation only. //! read for the live simulation only.
//! //!
//! Reconnaissance flights and the partial picture they radioed home are part of the same
//! section (#135): their marks (an area, a category and an age, never a unit's truth), the
//! sorties still out with their pending reports, and the zones already checked. A save keeps
//! that memory across raids, and a restored flight finishes the same way.
//!
//! The format is its own versioned section of `state_text` (`air 1 ...`). A save without the section //! The format is its own versioned section of `state_text` (`air 1 ...`). A save without the section
//! (every save made before #127) loads exactly as before: the layout, and an empty sky. Every value is //! (every save made before #127) loads exactly as before: the layout, and an empty sky. Every value is
//! checked before anything is restored, like [`layout`](crate::layout): a bad line refuses the whole //! checked before anything is restored, like [`layout`](crate::layout): a bad line refuses the whole
@@ -16,6 +21,7 @@
//! contacts, route points and relief cells — so a saved air state can never grow the file without limit. //! contacts, route points and relief cells — so a saved air state can never grow the file without limit.
use super::*; use super::*;
use std::collections::{BTreeMap, HashMap}; use std::collections::{BTreeMap, HashMap};
use std::fmt::Write;
/// The section's format version. A different one is refused rather than half-read. /// The section's format version. A different one is refused rather than half-read.
const VERSION: u32 = 1; const VERSION: u32 = 1;
@@ -25,6 +31,9 @@ const MAX_DRONES: usize = 512;
/// Bytes the section may take before further drones are left out (the host allows 1 MiB a write; /// Bytes the section may take before further drones are left out (the host allows 1 MiB a write;
/// the layout and the headroom of the rest of the state stay clear of it). /// the layout and the headroom of the rest of the state stay clear of it).
const MAX_BYTES: usize = 900_000; const MAX_BYTES: usize = 900_000;
/// Bytes the recon block (marks, checked zones, sorties) may take. The drone loop keeps this much
/// room free, so the recon memory never pushes the section past `MAX_BYTES` (#135).
const MAX_RECON_BYTES: usize = 150_000;
/// Route points one drone may have in a save. /// Route points one drone may have in a save.
const MAX_ROUTE: usize = 512; const MAX_ROUTE: usize = 512;
/// Contacts (the picture, and a job's picture rebuilt from it) a save may hold. /// Contacts (the picture, and a job's picture rebuilt from it) a save may hold.
@@ -32,6 +41,10 @@ const MAX_CONTACTS: usize = 4096;
/// Relief versions a save may hold, and the cells of each. /// Relief versions a save may hold, and the cells of each.
const MAX_RELIEFS: usize = 8; const MAX_RELIEFS: usize = 8;
const MAX_CELLS: usize = 40_000; const MAX_CELLS: usize = 40_000;
/// Recon marks, checked zones and sorties a save may hold (#135).
const MAX_RECON_MARKS: usize = recon::MAX_MARKS;
const MAX_RECON_CHECKED: usize = recon::MAX_CHECKED;
const MAX_RECON_SORTIES: usize = recon::SORTIES_MAX * 2;
/// What the air section of a save holds, checked as a whole before the scene is touched. /// What the air section of a save holds, checked as a whole before the scene is touched.
pub struct AirSave { pub struct AirSave {
@@ -39,12 +52,16 @@ pub struct AirSave {
job_next: u32, job_next: u32,
kills: [u32; ew::SECTORS], kills: [u32; ew::SECTORS],
hits: [u32; ew::SECTORS], hits: [u32; ew::SECTORS],
/// The bearing memory's small window of recent outcomes (#149).
outcomes: Vec<ew::Learned>,
contacts: Vec<ew::Contact>, contacts: Vec<ew::Contact>,
drones: Vec<Drone>, drones: Vec<Drone>,
queue: Vec<(u64, Drone)>, queue: Vec<(u64, Drone)>,
jobs: Vec<JobRec>, jobs: Vec<JobRec>,
/// The land new retarget jobs take as their version. /// The land new retarget jobs take as their version.
known_relief: Option<std::sync::Arc<ew::KnownRelief>>, known_relief: Option<std::sync::Arc<ew::KnownRelief>>,
/// The enemy's recon flights and the partial picture they radioed home (#135).
recon: recon::Recon,
} }
pub(crate) struct JobRec { pub(crate) struct JobRec {
@@ -148,7 +165,8 @@ impl Drone {
if !self.route.is_empty() { if !self.route.is_empty() {
route = self.route.len().to_string(); route = self.route.len().to_string();
for p in &self.route { for p in &self.route {
route += &format!(" {} {} {}", coord(p.x), coord(p.y), coord(p.z)); // 🤖 Agent: format straight into the buffer, not through a temporary `String`.
write!(route, " {} {} {}", coord(p.x), coord(p.y), coord(p.z)).unwrap();
} }
} }
format!( format!(
@@ -198,6 +216,7 @@ impl Sim {
^ (self.retargets.len() as u64) << 24 ^ (self.retargets.len() as u64) << 24
^ (self.intel.contacts().len() as u64) << 36 ^ (self.intel.contacts().len() as u64) << 36
^ (self.job_next as u64) << 48 ^ (self.job_next as u64) << 48
^ self.recon.mark().rotate_left(12)
} }
/// The air section of the state text: `None` when there is nothing to keep (an empty sky and no /// The air section of the state text: `None` when there is nothing to keep (an empty sky and no
@@ -226,13 +245,26 @@ impl Sim {
let job_relief: Vec<Option<usize>> = self.retargets.iter().map(|j| j.relief.as_ref().and_then(|r| token_of(r, &mut reliefs))).collect(); let job_relief: Vec<Option<usize>> = self.retargets.iter().map(|j| j.relief.as_ref().and_then(|r| token_of(r, &mut reliefs))).collect();
let (kills, hits) = self.intel.sectors(); let (kills, hits) = self.intel.sectors();
// The head, with the counts filled in later; its length is what the body is measured against. // The head, with the counts filled in later; its length is what the body is measured against.
// 🤖 Agent: `write!`/`push_str` format into the buffer in place. `head += &format!(...)` made a
// temporary `String` per item and re-copied the whole growing head, so a full relief grid cost
// O(n²) bytes and a heavy autosave ran out of fuel.
let mut head = format!("air {VERSION} {} {} 0 0 0 {} {}\n", self.tick, self.job_next, contacts.len(), reliefs.len()); let mut head = format!("air {VERSION} {} {} 0 0 0 {} {}\n", self.tick, self.job_next, contacts.len(), reliefs.len());
head += "airintel"; head.push_str("airintel");
for v in kills.iter().chain(hits.iter()) { for v in kills.iter().chain(hits.iter()) {
head += &format!(" {v}"); write!(head, " {v}").unwrap();
} }
head += "\n"; head.push('\n');
head += &format!("airglobal {}\n", global.map_or_else(|| "-".into(), |t| t.to_string())); // The bearing window (#149): bounded, and optional — an older save without it loads with
// an empty window and the lifetime tally it does carry.
let outcomes: Vec<&ew::Learned> = self.intel.outcomes().iter().take(ew::MAX_OUTCOMES).collect();
if !outcomes.is_empty() {
write!(head, "airlearn {}", outcomes.len()).unwrap();
for o in &outcomes {
write!(head, " {} {} {}", o.sector, o.tick, u8::from(o.killed)).unwrap();
}
head.push('\n');
}
write!(head, "airglobal {}\n", global.map_or_else(|| "-".into(), |t| t.to_string())).unwrap();
for (i, r) in reliefs.iter().enumerate() { for (i, r) in reliefs.iter().enumerate() {
let g = r.grid(); let g = r.grid();
let mut line = format!("airrelief {i} {} {} {} {} ", coord(g.min.x), coord(g.min.z), coord(g.cell), g.size); let mut line = format!("airrelief {i} {} {} {} {} ", coord(g.min.x), coord(g.min.z), coord(g.cell), g.size);
@@ -242,20 +274,21 @@ impl Sim {
match run { match run {
Some((k, n)) if k == key => run = Some((k, n + 1)), Some((k, n)) if k == key => run = Some((k, n + 1)),
Some((k, n)) => { Some((k, n)) => {
line += &format!("{} ", run_token(k, n)); write!(line, "{} ", run_token(k, n)).unwrap();
run = Some((key, 1)); run = Some((key, 1));
} }
None => run = Some((key, 1)), None => run = Some((key, 1)),
} }
} }
if let Some((k, n)) = run { if let Some((k, n)) = run {
line += &run_token(k, n); line.push_str(&run_token(k, n));
} }
head += &line; head.push_str(&line);
head += "\n"; head.push('\n');
} }
for c in &contacts { for c in &contacts {
head += &format!( write!(
head,
"aircontact {} {} {} {} {} {} {} {} {} {}\n", "aircontact {} {} {} {} {} {} {} {} {} {}\n",
c.id, c.id,
c.kind.spec().key, c.kind.spec().key,
@@ -267,21 +300,22 @@ impl Sim {
tick(c.emission), tick(c.emission),
tick(c.destroyed), tick(c.destroyed),
c.launches c.launches
); )
.unwrap();
} }
// The bodies go in while the section stays inside its byte bound; a drone left out takes its // The bodies go in while the section stays inside its byte bound; a drone left out takes its
// job with it (a job whose drone is not saved could never be restored). // job with it (a job whose drone is not saved could never be restored).
let mut body = String::new(); let mut body = String::new();
let mut saved: std::collections::HashSet<u32> = std::collections::HashSet::new(); let mut saved: std::collections::HashSet<u32> = std::collections::HashSet::new();
let fits = |head: &str, body: &str, line: &str| head.len() + 32 + body.len() + line.len() <= MAX_BYTES; let fits = |head: &str, body: &str, line: &str| head.len() + 32 + body.len() + line.len() + MAX_RECON_BYTES <= MAX_BYTES;
let mut drone_count = 0usize; let mut drone_count = 0usize;
for d in &drones { for d in &drones {
let line = d.air_line("airdrone", ""); let line = d.air_line("airdrone", "");
if !fits(&head, &body, &line) { if !fits(&head, &body, &line) {
break; break;
} }
body += &line; body.push_str(&line);
body += "\n"; body.push('\n');
saved.insert(d.id); saved.insert(d.id);
drone_count += 1; drone_count += 1;
} }
@@ -291,19 +325,20 @@ impl Sim {
if !fits(&head, &body, &line) { if !fits(&head, &body, &line) {
break; break;
} }
body += &line; body.push_str(&line);
body += "\n"; body.push('\n');
saved.insert(d.id); saved.insert(d.id);
queued_count += 1; queued_count += 1;
} }
let units: std::collections::HashSet<u32> = contacts.iter().map(|c| c.id).collect(); // A job's unit may be an exact contact or a recon mark's synthetic id (#135).
let units: std::collections::HashSet<u32> = contacts.iter().map(|c| c.id).chain(self.recon.marks.keys().copied()).collect();
let jobs: Vec<(&ew::RouteJob, Option<usize>)> = self let jobs: Vec<(&ew::RouteJob, Option<usize>)> = self
.retargets .retargets
.iter() .iter()
.zip(job_relief) .zip(job_relief)
.filter(|(j, _)| saved.contains(&j.drone) && (j.unit == 0 || units.contains(&j.unit))) .filter(|(j, _)| saved.contains(&j.drone) && (j.unit == 0 || units.contains(&j.unit)))
.collect(); .collect();
if drone_count == 0 && queued_count == 0 && jobs.is_empty() && contacts.is_empty() { if drone_count == 0 && queued_count == 0 && jobs.is_empty() && contacts.is_empty() && self.recon.is_empty() && outcomes.is_empty() {
return None; return None;
} }
let head = head.replacen( let head = head.replacen(
@@ -312,9 +347,10 @@ impl Sim {
1, 1,
); );
let mut text = head; let mut text = head;
text += &body; text.push_str(&body);
for (job, relief) in jobs { for (job, relief) in jobs {
text += &format!( write!(
text,
"airjob {} {} {} {} {} {} {} {} {} {}\n", "airjob {} {} {} {} {} {} {} {} {} {}\n",
job.id, job.id,
job.drone, job.drone,
@@ -326,7 +362,94 @@ impl Sim {
job.priority(), job.priority(),
job.intent.key(), job.intent.key(),
relief.map_or_else(|| "-".into(), |t| t.to_string()) relief.map_or_else(|| "-".into(), |t| t.to_string())
)
.unwrap();
}
// Recon: the marks are memory (survive a new raid), the sorties are the aircraft still
// out, and the zones already reported empty. Everything is bounded, and each line is
// added only while the block stays inside its budget (#135).
if !self.recon.is_empty() {
let room = MAX_RECON_BYTES.min(MAX_BYTES.saturating_sub(text.len() + 96));
let mut recon_body = String::new();
let mut add = |line: &str| -> bool {
if recon_body.len() + line.len() > room {
return false;
}
recon_body.push_str(line);
true
};
let mut marks = 0usize;
for m in self.recon.marks.values().take(MAX_RECON_MARKS) {
let truth = self.recon.truth.get(&m.id).copied().unwrap_or(0);
let line = format!(
"airreconmark {} {} {} {} {} {} {} {} {} {} {} {} {}\n",
m.id,
truth,
coord(m.area.x),
coord(m.area.y),
coord(m.area.z),
coord(m.radius),
m.category.name(),
m.role.map_or_else(|| "-".to_string(), |r| r.key().to_string()),
m.source.name(),
m.quality.name(),
m.observed,
m.reported,
m.looks,
); );
if !add(&line) {
break;
}
marks += 1;
}
let mut checked = 0usize;
for ((i, j), t) in self.recon.checked.iter().take(MAX_RECON_CHECKED) {
if !add(&format!("airreconchecked {i} {j} {t}\n")) {
break;
}
checked += 1;
}
let mut sorties = 0usize;
for s in self.recon.sorties.iter().filter(|s| saved.contains(&s.drone)).take(MAX_RECON_SORTIES) {
// A sortie is written whole or not at all: its look and zone lines follow its header.
let mut body = format!(
"airrec {} {} {} {} {} {} {}\n",
s.drone,
s.launched,
s.next,
tick(s.report_at),
s.report_zone.map_or_else(|| "-".into(), |z| z.to_string()),
s.pending.len(),
s.zones.len(),
);
for l in &s.pending {
write!(
body,
"airrecobs {} {} {} {} {} {} {} {} {} {} {}\n",
l.truth,
coord(l.area.x),
coord(l.area.y),
coord(l.area.z),
coord(l.radius),
l.category.name(),
l.role.map_or_else(|| "-".to_string(), |r| r.key().to_string()),
l.quality.name(),
l.source.name(),
l.observed,
l.wreck,
)
.unwrap();
}
for z in &s.zones {
write!(body, "airreczone {} {} {} {}\n", coord(z.center.x), coord(z.center.y), coord(z.center.z), coord(z.radius)).unwrap();
}
if !add(&body) {
break;
}
sorties += 1;
}
write!(text, "airrecon {} {} {} {} {}\n", self.recon.next, self.recon.drone_next, marks, sorties, checked).unwrap();
text.push_str(&recon_body);
} }
Some(text) Some(text)
} }
@@ -367,12 +490,19 @@ impl Sim {
let n_reliefs = l.count(8, "версии рельефа", MAX_RELIEFS)?; let n_reliefs = l.count(8, "версии рельефа", MAX_RELIEFS)?;
// Every line of the section, and nothing else: a truncated or foreign line is refused. // Every line of the section, and nothing else: a truncated or foreign line is refused.
let mut intel: Option<[u32; ew::SECTORS * 2]> = None; let mut intel: Option<[u32; ew::SECTORS * 2]> = None;
let mut outcomes: Vec<ew::Learned> = Vec::new();
let mut global: Option<usize> = None; let mut global: Option<usize> = None;
let mut reliefs: Vec<Option<std::sync::Arc<ew::KnownRelief>>> = vec![None; n_reliefs]; let mut reliefs: Vec<Option<std::sync::Arc<ew::KnownRelief>>> = vec![None; n_reliefs];
let mut contacts: BTreeMap<u32, ew::Contact> = BTreeMap::new(); let mut contacts: BTreeMap<u32, ew::Contact> = BTreeMap::new();
let mut drones: BTreeMap<u32, Drone> = BTreeMap::new(); let mut drones: BTreeMap<u32, Drone> = BTreeMap::new();
let mut queue: Vec<(u64, Drone)> = Vec::new(); let mut queue: Vec<(u64, Drone)> = Vec::new();
let mut jobs: Vec<JobRec> = Vec::new(); let mut jobs: Vec<JobRec> = Vec::new();
// Recon (#135): a mark line carries the unit it is of (the observer's secret, never in
// the planner's picture); a sortie's look and zone lines follow its header.
let mut recon = recon::Recon::default();
let mut recon_head: Option<(usize, usize, usize)> = None;
let mut recon_sortie_at: Option<usize> = None;
let mut recon_expect: Vec<(usize, usize)> = Vec::new();
for (n, w) in &lines { for (n, w) in &lines {
if w.first() == Some(&"air") { if w.first() == Some(&"air") {
continue; continue;
@@ -393,6 +523,21 @@ impl Sim {
} }
intel = Some(v); intel = Some(v);
} }
"airlearn" => {
let n = l.count(1, "исходы", ew::MAX_OUTCOMES)?;
if w.len() != 2 + n * 3 {
return Err(l.bad("исходы", "нужны сектор, такт и исход каждого"));
}
if !outcomes.is_empty() {
return Err(l.bad("исходы", "окно записано дважды"));
}
for i in 0..n {
let sector = l.int(2 + i * 3, "сектор исхода", 0, ew::SECTORS as i64 - 1)? as u8;
let t = l.int(3 + i * 3, "такт исхода", 0, tick as i64)? as u64;
let killed = l.int(4 + i * 3, "исход", 0, 1)? == 1;
outcomes.push(ew::Learned { sector, tick: t, killed });
}
}
"airglobal" => { "airglobal" => {
if w.len() != 2 { if w.len() != 2 {
return Err(l.bad("рельеф", "нужна одна ссылка на версию рельефа")); return Err(l.bad("рельеф", "нужна одна ссылка на версию рельефа"));
@@ -496,7 +641,7 @@ impl Sim {
let unit = l.int(6, "юнит", 0, 1 << 30)? as u32; let unit = l.int(6, "юнит", 0, 1 << 30)? as u32;
let version = l.int(7, "версия знаний", 0, tick as i64)? as u64; let version = l.int(7, "версия знаний", 0, tick as i64)? as u64;
let priority = l.int(8, "приоритет", 0, 9)? as u8; let priority = l.int(8, "приоритет", 0, 9)? as u8;
let intent = intent_of(l.word(9, "намерение")?).ok_or_else(|| l.bad("намерение", "plan, sead, react или replace"))?; let intent = intent_of(l.word(9, "намерение")?).ok_or_else(|| l.bad("намерение", "plan, sead, react, replace или refresh"))?;
if priority != intent.priority() { if priority != intent.priority() {
return Err(l.bad("приоритет", "не совпадает с намерением")); return Err(l.bad("приоритет", "не совпадает с намерением"));
} }
@@ -512,6 +657,151 @@ impl Sim {
}; };
jobs.push(JobRec { id, drone, aim, unit, version, intent, relief }); jobs.push(JobRec { id, drone, aim, unit, version, intent, relief });
} }
"airrecon" => {
if w.len() != 6 {
return Err(l.bad("разведка", "нужны счётчики отметок и дронов, отметки, разведчики и проверенные зоны"));
}
let next = l.int(1, "счётчик отметок", 0, i64::from(recon::MARK_TOP - recon::ID_BASE - 1))? as u32;
let drone_next = l.int(2, "счётчик дронов", 0, i64::from(recon::DRONE_TOP - recon::DRONE_BASE - 1))? as u32;
let marks = l.count(3, "отметки", MAX_RECON_MARKS)?;
let sorties = l.count(4, "разведчики", MAX_RECON_SORTIES)?;
let checked = l.count(5, "проверенные зоны", MAX_RECON_CHECKED)?;
if recon_head.is_some() {
return Err(l.bad("разведка", "заголовок записан дважды"));
}
recon_head = Some((marks, sorties, checked));
recon.next = next;
recon.drone_next = drone_next;
}
"airreconmark" => {
if w.len() != 14 {
return Err(l.bad("отметка разведки", "нужны id, юнит, место, категория, источник, качество и времена"));
}
let id = l.int(1, "id отметки", 0, i64::from(u32::MAX))? as u32;
if !recon::is_mark(id) {
return Err(l.bad("id отметки", "не в диапазоне отметок"));
}
let truth = l.int(2, "юнит отметки", 0, 1 << 30)? as u32;
let area = DVec3::new(l.num(3, "отметка X")?, l.num(4, "отметка Y")?, l.num(5, "отметка Z")?);
let radius = l.num(6, "радиус отметки")?;
if radius <= 0.0 {
return Err(l.bad("радиус отметки", "должен быть больше нуля"));
}
let category = recon::Category::from_key(l.word(7, "категория")?).ok_or_else(|| l.bad("категория", "unknown, radar, launcher, gun, ew или support"))?;
let role = match l.word(8, "роль")? {
"-" => None,
key => Some(battery::RadarRole::from_key(key).ok_or_else(|| l.bad("роль", "multi, search, engagement или height"))?),
};
let source = recon::Source::from_key(l.word(9, "источник")?).ok_or_else(|| l.bad("источник", "flyby, emission, jamming или launch"))?;
let quality = recon::Quality::from_key(l.word(10, "качество")?).ok_or_else(|| l.bad("качество", "coarse или refined"))?;
let observed = l.int(11, "такт наблюдения", 0, tick as i64)? as u64;
let reported = l.int(12, "такт донесения", 0, tick as i64)? as u64;
let looks = l.int(13, "число взглядов", 0, u16::MAX as i64)? as u16;
if recon.marks.contains_key(&id) {
return Err(l.bad("id отметки", "отметка записана дважды"));
}
recon.truth.insert(id, truth);
recon.marks.insert(id, recon::Mark {
id,
area,
radius,
category,
role,
source,
observed,
reported,
quality,
looks,
});
let slot = id.saturating_sub(recon::ID_BASE);
recon.next = recon.next.max(slot);
}
"airreconchecked" => {
if w.len() != 4 {
return Err(l.bad("проверенная зона", "нужны X, Z и такт"));
}
let i = l.int(1, "зона X", -3_000_000, 3_000_000)?;
let j = l.int(2, "зона Z", -3_000_000, 3_000_000)?;
let t = l.int(3, "такт проверки", 0, tick as i64)? as u64;
recon.checked.insert((i, j), t);
}
"airrec" => {
if w.len() != 8 {
return Err(l.bad("разведчик", "нужны дрон, вылет, зона, донесение и счётчики"));
}
let drone = l.int(1, "дрон разведчика", 1, 1 << 30)? as u32;
let launched = l.int(2, "вылет", 0, tick as i64)? as u64;
let next = l.count(3, "следующая зона", 1_000_000)?;
let report_at = l.opt_tick(4, "такт донесения")?;
let report_zone = match l.word(5, "зона донесения")? {
"-" => None,
v => Some(v.parse::<usize>().map_err(|_| l.bad("зона донесения", "не номер"))?),
};
let pending = l.count(6, "ожидающие наблюдения", recon::MAX_OBSERVED)?;
let zones = l.count(7, "зоны разведчика", recon::ZONES_MAX)?;
if recon.sorties.iter().any(|s| s.drone == drone) {
return Err(l.bad("дрон разведчика", "разведчик записан дважды"));
}
recon.sorties.push(recon::Sortie {
drone,
zones: Vec::new(),
next,
launched,
report_at,
report_zone,
pending: Vec::new(),
});
recon_sortie_at = Some(recon.sorties.len() - 1);
recon_expect.push((pending, zones));
}
"airrecobs" => {
if w.len() != 11 && w.len() != 12 {
return Err(l.bad("наблюдение разведки", "нужны юнит, место, категория, источник, такт и признак остова"));
}
let Some(at) = recon_sortie_at else {
return Err(l.bad("наблюдение разведки", "строка без разведчика"));
};
let (want, _) = recon_expect[at];
if recon.sorties[at].pending.len() >= want {
return Err(l.bad("наблюдение разведки", "наблюдений больше объявленного"));
}
let truth = l.int(1, "юнит наблюдения", 0, 1 << 30)? as u32;
let area = DVec3::new(l.num(2, "наблюдение X")?, l.num(3, "наблюдение Y")?, l.num(4, "наблюдение Z")?);
let radius = l.num(5, "радиус наблюдения")?;
if radius <= 0.0 {
return Err(l.bad("радиус наблюдения", "должен быть больше нуля"));
}
let category = recon::Category::from_key(l.word(6, "категория")?).ok_or_else(|| l.bad("категория", "unknown, radar, launcher, gun, ew или support"))?;
let role = match l.word(7, "роль")? {
"-" => None,
key => Some(battery::RadarRole::from_key(key).ok_or_else(|| l.bad("роль", "multi, search, engagement или height"))?),
};
let quality = recon::Quality::from_key(l.word(8, "качество")?).ok_or_else(|| l.bad("качество", "coarse или refined"))?;
let source = recon::Source::from_key(l.word(9, "источник")?).ok_or_else(|| l.bad("источник", "flyby, emission, jamming или launch"))?;
let observed = l.int(10, "такт наблюдения", 0, tick as i64)? as u64;
// An older save has no wreck flag: every pending look it holds is of a unit
// that was alive when it was seen.
let wreck = if w.len() > 11 { l.flag(11, "остов")? } else { false };
recon.sorties[at].pending.push(recon::Look { truth, area, radius, category, role, quality, source, observed, wreck });
}
"airreczone" => {
if w.len() != 5 {
return Err(l.bad("зона разведчика", "нужны X, Y, Z и радиус"));
}
let Some(at) = recon_sortie_at else {
return Err(l.bad("зона разведчика", "строка без разведчика"));
};
let (_, want) = recon_expect[at];
if recon.sorties[at].zones.len() >= want {
return Err(l.bad("зона разведчика", "зон больше объявленного"));
}
let center = DVec3::new(l.num(1, "зона X")?, l.num(2, "зона Y")?, l.num(3, "зона Z")?);
let radius = l.num(4, "радиус зоны")?;
if radius <= 0.0 {
return Err(l.bad("радиус зоны", "должен быть больше нуля"));
}
recon.sorties[at].zones.push(recon::Zone { center, radius });
}
other => return Err(l.bad("строка", &format!("неизвестная строка воздушной части «{other}»"))), other => return Err(l.bad("строка", &format!("неизвестная строка воздушной части «{other}»"))),
} }
} }
@@ -540,6 +830,32 @@ impl Sim {
if let Some(g) = global && reliefs[g].is_none() { if let Some(g) = global && reliefs[g].is_none() {
return Err("воздушная часть: глобальный рельеф не записан".into()); return Err("воздушная часть: глобальный рельеф не записан".into());
} }
if let Some((marks, sorties, checked)) = recon_head {
if recon.marks.len() != marks {
return Err(format!("воздушная часть: отметок разведки {} вместо {marks}", recon.marks.len()));
}
if recon.sorties.len() != sorties {
return Err(format!("воздушная часть: разведчиков {} вместо {sorties}", recon.sorties.len()));
}
if recon.checked.len() != checked {
return Err(format!("воздушная часть: проверенных зон {} вместо {checked}", recon.checked.len()));
}
} else if !recon.is_empty() {
return Err("воздушная часть: разведка без заголовка airrecon".into());
}
for (i, (pending, zones)) in recon_expect.iter().enumerate() {
if recon.sorties[i].pending.len() != *pending || recon.sorties[i].zones.len() != *zones {
return Err(format!("воздушная часть: разведчик {i} записан не полностью"));
}
if recon.sorties[i].next > recon.sorties[i].zones.len() {
return Err(format!("воздушная часть: разведчик {i} смотрит за пределами зон"));
}
if let Some(z) = recon.sorties[i].report_zone
&& z >= recon.sorties[i].zones.len()
{
return Err(format!("воздушная часть: разведчик {i} доносит из несуществующей зоны"));
}
}
let intel = intel.ok_or("воздушная часть: нет счётчиков секторов")?; let intel = intel.ok_or("воздушная часть: нет счётчиков секторов")?;
let mut kills = [0u32; ew::SECTORS]; let mut kills = [0u32; ew::SECTORS];
let mut hits = [0u32; ew::SECTORS]; let mut hits = [0u32; ew::SECTORS];
@@ -550,11 +866,13 @@ impl Sim {
job_next, job_next,
kills, kills,
hits, hits,
outcomes,
contacts: contacts.into_values().collect(), contacts: contacts.into_values().collect(),
drones: drones.into_values().collect(), drones: drones.into_values().collect(),
queue, queue,
jobs, jobs,
known_relief: global.and_then(|g| reliefs[g].clone()), known_relief: global.and_then(|g| reliefs[g].clone()),
recon,
})) }))
} }
@@ -567,27 +885,36 @@ impl Sim {
// New jobs must not reuse an id a restored job already holds. // New jobs must not reuse an id a restored job already holds.
let highest = save.jobs.iter().map(|j| j.id).max().unwrap_or(0); let highest = save.jobs.iter().map(|j| j.id).max().unwrap_or(0);
self.job_next = save.job_next.max(1).max(highest.saturating_add(1)); self.job_next = save.job_next.max(1).max(highest.saturating_add(1));
self.intel = ew::Intel::restore(save.contacts.clone(), save.kills, save.hits); self.intel = ew::Intel::restore(save.contacts.clone(), save.kills, save.hits, save.outcomes.clone());
self.known_relief = save.known_relief; self.known_relief = save.known_relief;
self.drones = save.drones; self.drones = save.drones;
self.queue = save.queue; self.queue = save.queue;
let alive: std::collections::HashSet<u32> = self.drones.iter().map(|d| d.id).chain(self.queue.iter().map(|(_, d)| d.id)).collect();
self.retargets.clear(); self.retargets.clear();
// A job's picture is its version's: the contacts observed no later than it, plus its own // A job's picture is its version's: the contacts observed no later than it, plus its own
// target (whose last saved observation stands in for one made after the version). // target (whose last saved observation stands in for one made after the version), and the
let mut by_version: HashMap<u64, std::sync::Arc<Vec<ew::Contact>>> = HashMap::new(); // recon marks reported by then. The snapshot keeps the version's tick: the job ages its
// contacts at that tick, not at the tick the restored queue reaches it (#146).
let mut by_version: HashMap<u64, std::sync::Arc<ew::KnowledgeSnapshot>> = HashMap::new();
for rec in save.jobs { for rec in save.jobs {
let known = by_version.entry(rec.version).or_insert_with(|| { let known = by_version.entry(rec.version).or_insert_with(|| {
let picture: Vec<ew::Contact> = save let contacts: Vec<ew::Contact> = save
.contacts .contacts
.iter() .iter()
.filter(|c| c.tick <= rec.version || c.id == rec.unit) .filter(|c| c.tick <= rec.version || c.id == rec.unit)
.copied() .copied()
.collect(); .collect();
std::sync::Arc::new(picture) let marks = save.recon.leads(rec.version).into_iter().filter(|m| m.observed <= rec.version).collect();
std::sync::Arc::new(ew::KnowledgeSnapshot { tick: rec.version, contacts, marks })
}); });
let job = ew::RouteJob::restored(rec.id, rec.drone, rec.aim, rec.unit, rec.version, rec.intent, std::sync::Arc::clone(known), rec.relief); let job = ew::RouteJob::restored(rec.id, rec.drone, rec.aim, rec.unit, rec.version, rec.intent, std::sync::Arc::clone(known), rec.relief);
self.retargets.push_back(job); self.retargets.push_back(job);
} }
// The recon memory goes back after the jobs' snapshots were read from the save's own: a
// job's version keeps the marks reported by then, not what survives today's expiry.
self.recon = save.recon;
self.recon.retain_drones(&alive);
self.recon.expire(self.tick);
// Jobs the saved picture no longer stands behind, and anything past the bound, go now. // Jobs the saved picture no longer stands behind, and anything past the bound, go now.
self.prune_air() self.prune_air()
} }
@@ -602,7 +929,7 @@ fn parse_drone(l: &Line, first: usize) -> Result<(Drone, usize), String> {
let vel = DVec3::new(l.num(first + 5, "скорость X")?, l.num(first + 6, "скорость Y")?, l.num(first + 7, "скорость Z")?); let vel = DVec3::new(l.num(first + 5, "скорость X")?, l.num(first + 6, "скорость Y")?, l.num(first + 7, "скорость Z")?);
let target = DVec3::new(l.num(first + 8, "цель X")?, l.num(first + 9, "цель Y")?, l.num(first + 10, "цель Z")?); let target = DVec3::new(l.num(first + 8, "цель X")?, l.num(first + 9, "цель Y")?, l.num(first + 10, "цель Z")?);
let flight = flight_of(l.word(first + 11, "полёт")?).ok_or_else(|| l.bad("полёт", "cruise, dive, ballistic или falling"))?; let flight = flight_of(l.word(first + 11, "полёт")?).ok_or_else(|| l.bad("полёт", "cruise, dive, ballistic или falling"))?;
let intent = intent_of(l.word(first + 12, "намерение")?).ok_or_else(|| l.bad("намерение", "plan, sead, react или replace"))?; let intent = intent_of(l.word(first + 12, "намерение")?).ok_or_else(|| l.bad("намерение", "plan, sead, react, replace или refresh"))?;
let unit = l.int(first + 13, "юнит намерения", 0, 1 << 30)? as u32; let unit = l.int(first + 13, "юнит намерения", 0, 1 << 30)? as u32;
let since = l.int(first + 14, "такт выбора цели", 0, 1 << 40)? as u64; let since = l.int(first + 14, "такт выбора цели", 0, 1 << 40)? as u64;
let switches = l.int(first + 15, "переключения", 0, u16::MAX as i64)? as u16; let switches = l.int(first + 15, "переключения", 0, u16::MAX as i64)? as u16;
@@ -695,13 +1022,14 @@ mod durable_tests {
let id = sim.id(); let id = sim.id();
let at = DVec3::new(-400.0 + k as f64 * 400.0, 70.0, 0.0); let at = DVec3::new(-400.0 + k as f64 * 400.0, 70.0, 0.0);
let c = contact(id, kind, at, 10, if kind == SamKind::Ew { ew::Seen::Jamming } else { ew::Seen::Emission }, k as u16); let c = contact(id, kind, at, 10, if kind == SamKind::Ew { ew::Seen::Jamming } else { ew::Seen::Emission }, k as u16);
sim.intel = ew::Intel::restore([c].to_vec(), [0; ew::SECTORS], [0; ew::SECTORS]); sim.intel = ew::Intel::restore([c].to_vec(), [0; ew::SECTORS], [0; ew::SECTORS], Vec::new());
ids.push(id); ids.push(id);
} }
sim.intel = ew::Intel::restore( sim.intel = ew::Intel::restore(
ids.iter().enumerate().map(|(k, id)| contact(*id, [SamKind::S400, SamKind::Radar, SamKind::Ew][k], DVec3::new(-400.0 + k as f64 * 400.0, 70.0, 0.0), 10, ew::Seen::Emission, k as u16)).collect(), ids.iter().enumerate().map(|(k, id)| contact(*id, [SamKind::S400, SamKind::Radar, SamKind::Ew][k], DVec3::new(-400.0 + k as f64 * 400.0, 70.0, 0.0), 10, ew::Seen::Emission, k as u16)).collect(),
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1], [12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
Vec::new(),
); );
sim.tick = 120; sim.tick = 120;
sim.job_next = 7; sim.job_next = 7;
@@ -726,7 +1054,8 @@ mod durable_tests {
sim.queue.push((300, queued)); sim.queue.push((300, queued));
// Two pending jobs: one of the plan, one a replacement, both with their own version. // Two pending jobs: one of the plan, one a replacement, both with their own version.
let job = |id, drone, aim, unit, version, intent| { let job = |id, drone, aim, unit, version, intent| {
ew::RouteJob::restored(id, drone, aim, unit, version, intent, std::sync::Arc::new(sim.intel.contacts().values().copied().collect()), sim.known_relief.clone()) let known = ew::KnowledgeSnapshot { tick: version, contacts: sim.intel.contacts().values().copied().collect(), marks: Vec::new() };
ew::RouteJob::restored(id, drone, aim, unit, version, intent, std::sync::Arc::new(known), sim.known_relief.clone())
}; };
sim.retargets.push_back(job(5, sim.drones[0].id, sim.drones[0].target, ids[0], 100, ew::Intent::React)); sim.retargets.push_back(job(5, sim.drones[0].id, sim.drones[0].target, ids[0], 100, ew::Intent::React));
let queued_target = sim.queue[0].1.target; let queued_target = sim.queue[0].1.target;
@@ -786,7 +1115,7 @@ mod durable_tests {
let id = sim.id(); let id = sim.id();
contacts.push(contact(id, SamKind::S400, DVec3::new(-560.0 + k as f64 * 160.0, 70.0, -320.0), 0, ew::Seen::Emission, 0)); contacts.push(contact(id, SamKind::S400, DVec3::new(-560.0 + k as f64 * 160.0, 70.0, -320.0), 0, ew::Seen::Emission, 0));
} }
sim.intel = ew::Intel::restore(contacts, [0; ew::SECTORS], [0; ew::SECTORS]); sim.intel = ew::Intel::restore(contacts, [0; ew::SECTORS], [0; ew::SECTORS], Vec::new());
for i in 0..40 { for i in 0..40 {
let from = DVec3::new(-1800.0, 100.0, -800.0 + i as f64 * 40.0); let from = DVec3::new(-1800.0, 100.0, -800.0 + i as f64 * 40.0);
let mut d = sim.make_drone(DroneKind::Kh22, from, DVec3::X, DVec3::new(1800.0, 70.0, 1800.0)); let mut d = sim.make_drone(DroneKind::Kh22, from, DVec3::X, DVec3::new(1800.0, 70.0, 1800.0));
@@ -850,7 +1179,7 @@ mod durable_tests {
let kept = sim.retargets.len(); let kept = sim.retargets.len();
let some = sim.retargets[0].clone(); let some = sim.retargets[0].clone();
// A job for a drone that is not here. // A job for a drone that is not here.
sim.retargets.push_back(ew::RouteJob::restored(900, 999_999, DVec3::ZERO, 0, sim.tick, ew::Intent::Plan, std::sync::Arc::new(Vec::new()), None)); sim.retargets.push_back(ew::RouteJob::restored(900, 999_999, DVec3::ZERO, 0, sim.tick, ew::Intent::Plan, std::sync::Arc::new(ew::KnowledgeSnapshot::empty(sim.tick)), None));
// A job whose aim is no longer its drone's. // A job whose aim is no longer its drone's.
let mut stale = some.clone(); let mut stale = some.clone();
stale.id = 901; stale.id = 901;
+580 -45
View File
@@ -19,6 +19,12 @@
//! contact is a plain function of the contact's age, and its idea of a unit's //! contact is a plain function of the contact's age, and its idea of a unit's
//! capabilities is the type's published one — a contact says nothing about //! capabilities is the type's published one — a contact says nothing about
//! damage, roles, link health or magazine. //! damage, roles, link health or magazine.
//!
//! A smart raid may also send a few recon aircraft ahead (#135). What they see is a
//! different, coarser kind of knowledge: an area, a public category, the channel that
//! showed it and its age, radioed home only after a delay and only while the aircraft
//! lives. It is kept as a `recon::Mark`, separate from a disclosure `Contact`; its
//! confidence is age alone and a duplicate report does not improve it.
use super::*; use super::*;
use std::collections::{BTreeMap, VecDeque}; use std::collections::{BTreeMap, VecDeque};
use std::sync::Arc; use std::sync::Arc;
@@ -39,6 +45,9 @@ pub enum Intent {
/// A replacement: the picture watched the previous aim die or forgot it, and this contact /// A replacement: the picture watched the previous aim die or forgot it, and this contact
/// is the nearest live one. /// is the nearest live one.
Replace, Replace,
/// A bounded refresh (#149): a recon report arrived while the raid's drones were still
/// waiting to launch, and the plan's own picks were re-aimed once on the fresh snapshot.
Refresh,
} }
impl Intent { impl Intent {
@@ -48,6 +57,7 @@ impl Intent {
Self::Sead => "sead", Self::Sead => "sead",
Self::React => "react", Self::React => "react",
Self::Replace => "replace", Self::Replace => "replace",
Self::Refresh => "refresh",
} }
} }
/// The key a save writes and reads. /// The key a save writes and reads.
@@ -55,14 +65,15 @@ impl Intent {
self.name() self.name()
} }
pub(super) fn from_key(key: &str) -> Option<Self> { pub(super) fn from_key(key: &str) -> Option<Self> {
[Self::Plan, Self::Sead, Self::React, Self::Replace].into_iter().find(|i| i.key() == key) [Self::Plan, Self::Sead, Self::React, Self::Replace, Self::Refresh].into_iter().find(|i| i.key() == key)
} }
/// The planner's share of a tick this aim is worth: a planned SEAD job and a reaction to a /// The planner's share of a tick this aim is worth: a planned SEAD job and a reaction to a
/// disclosure are finished before a replacement, and the plan's own objective before both (#127). /// disclosure are finished before a replacement, and the plan's own objective before both (#127).
/// A refresh of the unreleased portion is worth a SEAD job's share (#149).
pub(super) fn priority(self) -> u8 { pub(super) fn priority(self) -> u8 {
match self { match self {
Self::Plan => 3, Self::Plan => 3,
Self::Sead => 2, Self::Sead | Self::Refresh => 2,
Self::React => 1, Self::React => 1,
Self::Replace => 0, Self::Replace => 0,
} }
@@ -108,8 +119,9 @@ pub(super) struct RouteJob {
pub(super) unit: u32, pub(super) unit: u32,
/// The adaptive tick whose picture chose the aim: the knowledge version. /// The adaptive tick whose picture chose the aim: the knowledge version.
pub(super) version: u64, pub(super) version: u64,
/// The enemy picture that tick knew, shared by every job of the tick. /// The enemy knowledge that tick chose the aim from, shared by every job of the tick: its
pub(super) known: Arc<Vec<Contact>>, /// contacts are aged at its own tick, not at the tick the job gets its budget (#146).
pub(super) known: Arc<KnowledgeSnapshot>,
/// The land that tick's plan knew, shared by every job of the version. A later plan replacing the /// The land that tick's plan knew, shared by every job of the version. A later plan replacing the
/// global snapshot must not change a pending job's relief (#127). /// global snapshot must not change a pending job's relief (#127).
pub(super) relief: Option<Arc<KnownRelief>>, pub(super) relief: Option<Arc<KnownRelief>>,
@@ -119,14 +131,14 @@ pub(super) struct RouteJob {
impl RouteJob { impl RouteJob {
/// A job of this tick's picture; the id and the priority follow from the intent. /// A job of this tick's picture; the id and the priority follow from the intent.
fn new(id: u32, drone: u32, aim: DVec3, unit: u32, version: u64, intent: Intent, known: Arc<Vec<Contact>>, relief: Option<Arc<KnownRelief>>) -> Self { fn new(id: u32, drone: u32, aim: DVec3, unit: u32, version: u64, intent: Intent, known: Arc<KnowledgeSnapshot>, relief: Option<Arc<KnownRelief>>) -> Self {
Self { id, drone, aim, unit, version, known, relief, intent } Self { id, drone, aim, unit, version, known, relief, intent }
} }
pub(super) fn priority(&self) -> u8 { pub(super) fn priority(&self) -> u8 {
self.intent.priority() self.intent.priority()
} }
/// A job read back from a save: its id, aim, unit, version, picture and relief are the file's. /// A job read back from a save: its id, aim, unit, version, picture and relief are the file's.
pub(super) fn restored(id: u32, drone: u32, aim: DVec3, unit: u32, version: u64, intent: Intent, known: Arc<Vec<Contact>>, relief: Option<Arc<KnownRelief>>) -> Self { pub(super) fn restored(id: u32, drone: u32, aim: DVec3, unit: u32, version: u64, intent: Intent, known: Arc<KnowledgeSnapshot>, relief: Option<Arc<KnownRelief>>) -> Self {
Self { id, drone, aim, unit, version, known, relief, intent } Self { id, drone, aim, unit, version, known, relief, intent }
} }
} }
@@ -139,6 +151,11 @@ pub(super) struct KnownRelief {
} }
impl KnownRelief { impl KnownRelief {
/// What the relief holds, about (see `sim::memory`).
pub(super) fn bytes(&self) -> usize {
use super::memory::vec_bytes;
vec_bytes(&self.heights)
}
pub(super) fn new(grid: raid::Grid, heights: Vec<f32>) -> Self { pub(super) fn new(grid: raid::Grid, heights: Vec<f32>) -> Self {
Self { grid, heights } Self { grid, heights }
} }
@@ -184,7 +201,7 @@ impl RouteJob {
aim: DVec3, aim: DVec3,
unit: u32, unit: u32,
version: u64, version: u64,
known: Arc<Vec<Contact>>, known: Arc<KnowledgeSnapshot>,
relief: Option<Arc<KnownRelief>>, relief: Option<Arc<KnownRelief>>,
) -> Self { ) -> Self {
Self { id: drone, drone, aim, unit, version, known, relief, intent: Intent::Plan } Self { id: drone, drone, aim, unit, version, known, relief, intent: Intent::Plan }
@@ -239,6 +256,16 @@ pub(super) const JOB_TTL: u64 = 1200;
/// What a cell of land a job's knowledge version does not know costs on top of the open ground /// What a cell of land a job's knowledge version does not know costs on top of the open ground
/// (the base cell is 1): unknown land is not free, so a replanned route keeps to what was mapped (#127). /// (the base cell is 1): unknown land is not free, so a replanned route keeps to what was mapped (#127).
pub(super) const UNKNOWN_LAND: f32 = 6.0; pub(super) const UNKNOWN_LAND: f32 = 6.0;
/// How long a smart raid's unreleased portion may wait for a recon report to refresh its aims
/// (#149). A report due later than this is left to the adaptive ticks; nothing pauses for ever.
pub(super) const REFRESH_WINDOW: u64 = 600;
/// The pending refresh of a raid's unreleased portion (#149): the absolute deadline and the
/// report count it waits to pass. Transient — a save drops it, the launches keep their times.
pub(super) struct Refresh {
pub(super) deadline: u64,
pub(super) reports: u32,
}
/// How a contact's trust decays with age alone (#127). The bands are the only source of /// How a contact's trust decays with age alone (#127). The bands are the only source of
/// confidence: nothing is invented about a unit between observations. /// confidence: nothing is invented about a unit between observations.
@@ -323,6 +350,15 @@ pub(super) const CONTACT_TTL: u64 = 6000;
const CONFIRMED_AGE: u64 = 600; const CONFIRMED_AGE: u64 = 600;
const PROBABLE_AGE: u64 = 3000; const PROBABLE_AGE: u64 = 3000;
/// The one source of confidence: a contact's age, in the bands the picture trusts.
pub(super) fn confidence_for_age(age: u64) -> Confidence {
match age {
0..=CONFIRMED_AGE => Confidence::Confirmed,
..=PROBABLE_AGE => Confidence::Probable,
_ => Confidence::Doubtful,
}
}
impl Contact { impl Contact {
pub fn age(&self, now: u64) -> u64 { pub fn age(&self, now: u64) -> u64 {
now.saturating_sub(self.tick) now.saturating_sub(self.tick)
@@ -332,11 +368,7 @@ impl Contact {
self.destroyed.is_none() && self.age(now) < CONTACT_TTL self.destroyed.is_none() && self.age(now) < CONTACT_TTL
} }
pub fn confidence(&self, now: u64) -> Confidence { pub fn confidence(&self, now: u64) -> Confidence {
match self.age(now) { confidence_for_age(self.age(now))
0..=CONFIRMED_AGE => Confidence::Confirmed,
..=PROBABLE_AGE => Confidence::Probable,
_ => Confidence::Doubtful,
}
} }
/// Whether the enemy believes this unit sees on its own radar (#127). A kind without a /// Whether the enemy believes this unit sees on its own radar (#127). A kind without a
/// sensor never does. A kind with one does while an emission fix of this contact is /// sensor never does. A kind with one does while an emission fix of this contact is
@@ -360,6 +392,40 @@ impl Contact {
} }
} }
/// One version of the enemy's knowledge (#146): the tick it was observed at, the disclosure
/// contacts and the recon marks live then. A smart order chooses its targets and prices every
/// kind's routes on this one snapshot; a retarget version ages its contacts at its own tick,
/// never at the tick the planner's budget happens to reach the job. The current time may cancel
/// a stale job, but it never re-ages the snapshot the job was chosen from.
#[derive(Clone)]
pub(super) struct KnowledgeSnapshot {
/// The tick the contacts and marks were observed at.
pub(super) tick: u64,
pub(super) contacts: Vec<Contact>,
pub(super) marks: Vec<recon::Mark>,
}
impl KnowledgeSnapshot {
/// What the snapshot holds, about (see `sim::memory`); shared `Arc`s are counted per holder.
pub(super) fn bytes(&self) -> usize {
use super::memory::vec_bytes;
vec_bytes(&self.contacts) + vec_bytes(&self.marks)
}
pub(super) fn new(tick: u64, contacts: Vec<Contact>, marks: Vec<recon::Mark>) -> Self {
Self { tick, contacts, marks }
}
/// A version that knows nothing: for a job whose picture is empty.
#[cfg(test)]
pub(super) fn empty(tick: u64) -> Self {
Self { tick, contacts: Vec::new(), marks: Vec::new() }
}
/// The one public hint list of this version (#149): contacts and marks merged by public
/// features, ranked on the single scale. The snapshot's own tick ages every hint.
pub(super) fn observations(&self) -> Vec<Observation> {
observe::merge(&self.contacts, &self.marks, self.tick)
}
}
/// The radar reach the enemy's planners price by: the type's published figure, undamaged /// The radar reach the enemy's planners price by: the type's published figure, undamaged
/// and role-default. What a unit suffers or is configured to while unobserved is not in it. /// and role-default. What a unit suffers or is configured to while unobserved is not in it.
pub(super) fn published_reach(kind: SamKind, drone: DroneKind, height: f64) -> f64 { pub(super) fn published_reach(kind: SamKind, drone: DroneKind, height: f64) -> f64 {
@@ -372,17 +438,90 @@ pub(super) fn published_reach(kind: SamKind, drone: DroneKind, height: f64) -> f
radar.min(horizon).max(sight::NEAR) radar.min(horizon).max(sight::NEAR)
} }
/// One raid outcome the bearing memory keeps (#149): the sector it came from, when, and its fate.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(super) struct Learned {
pub(super) sector: u8,
pub(super) tick: u64,
pub(super) killed: bool,
}
/// The bearing memory is a small window of the latest outcomes, not a lifetime tally (#149):
/// this many entries, and nothing older than `OUTCOME_WINDOW` is scored.
pub(super) const MAX_OUTCOMES: usize = 48;
pub(super) const OUTCOME_WINDOW: u64 = 12_000;
/// A window whose newest outcome is older than this is stale: the fight may have moved on.
pub(super) const OUTCOME_STALE: u64 = 6_000;
/// Why the bearing picker chose as it did (#149), in typed terms the diagnostic reports.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BearingReason {
/// The legacy fixed-share picker (the comparison runner's "current" mode).
FixedShare,
/// Too few outcomes in the window to trust a best sector: explore more.
FewObservations,
/// The window's newest outcome is old: explore more.
StaleResults,
/// The public picture's shape changed since the outcomes were learned: explore more.
ConditionsChanged,
/// Enough fresh outcomes under unchanged conditions: exploit the best sector.
Exploiting,
}
impl BearingReason {
pub fn name(self) -> &'static str {
match self {
Self::FixedShare => "fixed-share",
Self::FewObservations => "few-observations",
Self::StaleResults => "stale-results",
Self::ConditionsChanged => "conditions-changed",
Self::Exploiting => "exploiting",
}
}
}
/// The bearing picker's last decision, for the diagnostic (#149).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BearingReport {
pub sector: usize,
pub reason: BearingReason,
/// Outcomes scored (the window, not the lifetime tally).
pub observations: usize,
/// The best sector's window score.
pub score: f64,
/// The exploration share this decision used.
pub explore: f64,
}
impl Default for BearingReport {
fn default() -> Self {
Self { sector: 0, reason: BearingReason::FewObservations, observations: 0, score: 0.5, explore: 0.6 }
}
}
#[derive(Default)] #[derive(Default)]
pub(super) struct Intel { pub(super) struct Intel {
/// Shot down and got through, by approach sector, over every raid. /// Shot down and got through, by approach sector, over every raid (the lifetime tally the
/// legacy picker scores; the window below is what the candidate forgets and reasons about).
pub kills: [u32; SECTORS], pub kills: [u32; SECTORS],
pub hits: [u32; SECTORS], pub hits: [u32; SECTORS],
/// The last observation of each unit the enemy knows of, by id. One entry per unit: /// The last observation of each unit the enemy knows of, by id. One entry per unit:
/// a newer observation replaces the older, so no log ever needs rescanning (#122). /// a newer observation replaces the older, so no log ever needs rescanning (#122).
contacts: BTreeMap<u32, Contact>, contacts: BTreeMap<u32, Contact>,
/// The small window of recent raid outcomes the bearing picker scores (#149).
outcomes: VecDeque<Learned>,
/// The public picture's shape when the last outcome was learned: a change is a reason to
/// explore, never a read of the hidden force (#149).
conditions: u64,
} }
impl Intel { impl Intel {
/// What the enemy's memory holds, about (see `sim::memory`).
pub(super) fn bytes(&self) -> usize {
use super::memory::{btree_bytes, vecdeque_bytes};
btree_bytes(self.contacts.len(), std::mem::size_of::<u32>() + std::mem::size_of::<Contact>())
+ vecdeque_bytes(&self.outcomes)
}
/// The picture as a save writes it, and back: the contacts (one per unit) and the sector scores. /// The picture as a save writes it, and back: the contacts (one per unit) and the sector scores.
pub(super) fn contacts(&self) -> &BTreeMap<u32, Contact> { pub(super) fn contacts(&self) -> &BTreeMap<u32, Contact> {
&self.contacts &self.contacts
@@ -390,8 +529,26 @@ impl Intel {
pub(super) fn sectors(&self) -> ([u32; SECTORS], [u32; SECTORS]) { pub(super) fn sectors(&self) -> ([u32; SECTORS], [u32; SECTORS]) {
(self.kills, self.hits) (self.kills, self.hits)
} }
pub(super) fn restore(contacts: Vec<Contact>, kills: [u32; SECTORS], hits: [u32; SECTORS]) -> Self { pub(super) fn outcomes(&self) -> &VecDeque<Learned> {
Self { kills, hits, contacts: contacts.into_iter().map(|c| (c.id, c)).collect() } &self.outcomes
}
pub(super) fn restore(contacts: Vec<Contact>, kills: [u32; SECTORS], hits: [u32; SECTORS], outcomes: Vec<Learned>) -> Self {
Self {
kills,
hits,
contacts: contacts.into_iter().map(|c| (c.id, c)).collect(),
outcomes: outcomes.into_iter().take(MAX_OUTCOMES).collect(),
conditions: 0,
}
}
/// One outcome into the window, bounded: the oldest goes first (#149).
pub(super) fn learn(&mut self, sector: usize, killed: bool, now: u64, conditions: u64) {
self.outcomes.push_back(Learned { sector: (sector % SECTORS) as u8, tick: now, killed });
while self.outcomes.len() > MAX_OUTCOMES {
self.outcomes.pop_front();
}
self.conditions = conditions;
} }
/// The one writer of contacts: what was seen of `s`, at its place, this moment. /// The one writer of contacts: what was seen of `s`, at its place, this moment.
@@ -521,17 +678,44 @@ impl Sim {
} }
} }
/// What the enemy's raids learned: their drones' fates by sector. /// What the enemy's raids learned: their drones' fates by sector, into the lifetime tally
/// and the small recent window the bearing picker scores (#149).
pub(super) fn learn(&mut self, sector: usize, killed: bool) { pub(super) fn learn(&mut self, sector: usize, killed: bool) {
if killed { if killed {
self.intel.kills[sector % SECTORS] += 1; self.intel.kills[sector % SECTORS] += 1;
} else { } else {
self.intel.hits[sector % SECTORS] += 1; self.intel.hits[sector % SECTORS] += 1;
} }
let conditions = self.picture_fingerprint();
self.intel.learn(sector, killed, self.tick, conditions);
} }
/// The bearing a smart raid comes from: the sector its raids got through best, a little random. /// The public picture's shape (#149): how many live hints of each category the enemy holds.
/// A fingerprint of beliefs only — no health, magazine, switch or true place is read.
pub(super) fn picture_fingerprint(&self) -> u64 {
let now = self.tick;
let mut h: u64 = 0xCBF2_9CE4_8422_2325;
let mut mix = |v: u64| h = (h ^ v).wrapping_mul(0x0000_0100_0000_01B3);
let mut cats = [0u32; 6];
for c in self.intel.contacts.values().filter(|c| c.live(now)) {
cats[recon::Category::of(c.kind) as usize] += 1;
}
for m in self.recon.marks.values().filter(|m| m.live(now)) {
cats[m.category as usize] += 1;
}
for n in cats {
mix(u64::from(n));
}
h
}
/// The bearing a smart raid comes from (#149). The candidate scores a small window of the
/// latest outcomes, forgets the old ones, and adapts its exploration share to what the
/// window can support — few observations, a stale result or changed public conditions each
/// named as a typed reason. The legacy mode keeps the lifetime tally and the fixed share.
pub(super) fn best_bearing(&mut self) -> f64 { pub(super) fn best_bearing(&mut self) -> f64 {
let now = self.tick;
let (pick, report) = if self.smart_legacy {
let score = |i: usize| { let score = |i: usize| {
let (k, h) = (self.intel.kills[i] as f64, self.intel.hits[i] as f64); let (k, h) = (self.intel.kills[i] as f64, self.intel.hits[i] as f64);
(h + 1.0) / (k + h + 2.0) (h + 1.0) / (k + h + 2.0)
@@ -539,6 +723,32 @@ impl Sim {
let best = (0..SECTORS).max_by(|&a, &b| score(a).total_cmp(&score(b))).unwrap_or(0); let best = (0..SECTORS).max_by(|&a, &b| score(a).total_cmp(&score(b))).unwrap_or(0);
// Unknown sectors are worth a look too. // Unknown sectors are worth a look too.
let pick = if self.rng.chance(0.3) { (self.rng.f() * SECTORS as f64) as usize } else { best }; let pick = if self.rng.chance(0.3) { (self.rng.f() * SECTORS as f64) as usize } else { best };
let observations = self.intel.kills.iter().chain(self.intel.hits.iter()).map(|n| *n as usize).sum();
(pick, BearingReport { sector: pick, reason: BearingReason::FixedShare, observations, score: score(best), explore: 0.3 })
} else {
let window: Vec<&Learned> = self.intel.outcomes.iter().filter(|o| now.saturating_sub(o.tick) <= OUTCOME_WINDOW).collect();
let total = window.len();
let newest = window.iter().map(|o| o.tick).max().unwrap_or(0);
let conditions = self.picture_fingerprint();
let (reason, explore) = if total < 6 {
(BearingReason::FewObservations, 0.6)
} else if now.saturating_sub(newest) > OUTCOME_STALE {
(BearingReason::StaleResults, 0.5)
} else if conditions != self.intel.conditions {
(BearingReason::ConditionsChanged, 0.45)
} else {
(BearingReason::Exploiting, 0.15)
};
let score = |i: usize| {
let k = window.iter().filter(|o| o.sector as usize == i && o.killed).count() as f64;
let h = window.iter().filter(|o| o.sector as usize == i && !o.killed).count() as f64;
(h + 1.0) / (k + h + 2.0)
};
let best = (0..SECTORS).max_by(|&a, &b| score(a).total_cmp(&score(b))).unwrap_or(0);
let pick = if self.rng.chance(explore) { (self.rng.f() * SECTORS as f64) as usize } else { best };
(pick, BearingReport { sector: pick, reason, observations: total, score: score(best), explore })
};
self.bearing = report;
(pick as f64 + 0.5 + self.rng.s() * 0.4) / SECTORS as f64 * TAU (pick as f64 + 0.5 + self.rng.s() * 0.4) / SECTORS as f64 * TAU
} }
@@ -553,9 +763,77 @@ impl Sim {
out out
} }
/// The knowledge this moment holds, as one snapshot for a whole decision (#146): the tick,
/// the contacts and the recon marks, read once and never re-read per kind or per job.
pub(super) fn knowledge_now(&self) -> KnowledgeSnapshot {
KnowledgeSnapshot { tick: self.tick, contacts: self.picture_of_defences(), marks: self.recon.leads(self.tick) }
}
/// The bounded refresh of a raid's unreleased portion (#149): a recon flight is out, and the
/// plan's own picks may be re-aimed once when a report arrives. The deadline is absolute — no
/// report, no delay: the launches keep their times either way.
pub(super) fn step_refresh(&mut self, out: &mut Out) {
let Some(r) = self.refresh.take() else { return };
if self.tick > r.deadline {
return;
}
if self.recon.reports <= r.reports {
self.refresh = Some(r);
return;
}
// A report arrived: one fresh snapshot, one bounded pass over the drones still waiting
// to launch. Only the plan's own picks are re-aimed, once, within the switch cap.
let knowledge = self.knowledge_now();
let obs = knowledge.observations();
let known = Arc::new(knowledge);
let relief = self.known_relief.clone();
let now = self.tick;
let mut per: HashMap<u32, usize> = HashMap::new();
let mut assigned = 0usize;
let mut changed = 0u32;
let mut job_next = self.job_next;
let mut jobs: Vec<RouteJob> = Vec::new();
for (_, d) in self.queue.iter_mut().filter(|(_, d)| d.smart && matches!(d.intent, Intent::Plan | Intent::Sead)) {
if assigned >= ASSIGN_PER_TICK || d.aim.switches >= SWITCH_CAP {
continue;
}
let Some(o) = obs.iter().find(|o| {
o.confidence(now) >= Confidence::Probable
&& (o.kind.is_some() || observe::fits(d.kind, o.category))
&& o.id != d.aim.unit
&& per.get(&o.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT
}) else {
continue;
};
*per.entry(o.id).or_insert(0) += 1;
assigned += 1;
changed += 1;
d.target = o.at + d.err;
d.intent = Intent::Refresh;
d.aim = d.aim.replaced(o.id, now, o.confidence(now));
if Self::route_plannable(d) {
jobs.push(RouteJob::new(job_next, d.id, d.target, d.aim.unit, now, Intent::Refresh, Arc::clone(&known), relief.clone()));
job_next += 1;
} else {
d.route.clear();
}
}
self.job_next = job_next;
for job in jobs {
self.queue_route(job);
}
if changed > 0 {
self.refresh_applied = self.refresh_applied.saturating_add(changed);
out.messages.push(format!("Разведка противника: донесение изменило план налёта ({changed} целей)"));
}
}
/// Whether the picture holds a live contact for this unit: what the old revelation log /// Whether the picture holds a live contact for this unit: what the old revelation log
/// answered at a scan, now one map lookup. /// answered at a scan, now one map lookup. A public belief, never the unit's truth.
pub(super) fn known_live(&self, id: u32) -> bool { pub fn known_live(&self, id: u32) -> bool {
if recon::is_mark(id) {
return self.recon.live(id, self.tick);
}
self.intel.contacts.get(&id).is_some_and(|c| c.live(self.tick)) self.intel.contacts.get(&id).is_some_and(|c| c.live(self.tick))
} }
@@ -578,8 +856,15 @@ impl Sim {
/// the picture killed is a distinct, lower-priority decision. /// the picture killed is a distinct, lower-priority decision.
fn adapt_targets(&mut self) { fn adapt_targets(&mut self) {
self.intel.expire(self.tick); self.intel.expire(self.tick);
let picture = Arc::new(self.picture_of_defences()); self.recon.expire(self.tick);
if picture.is_empty() { // One knowledge version for every aim and job this adaptive tick chooses (#146).
let knowledge = Arc::new(self.knowledge_now());
let picture = &knowledge.contacts;
let leads = &knowledge.marks;
// The candidate picks from the one merged hint list (#149); the legacy mode keeps the
// two separate lists and their old scales.
let obs = if self.smart_legacy { Vec::new() } else { knowledge.observations() };
if picture.is_empty() && leads.is_empty() {
return; return;
} }
// Every job of this adaptive tick plans over the same relief version, even if another smart // Every job of this adaptive tick plans over the same relief version, even if another smart
@@ -601,9 +886,17 @@ impl Sim {
if !eligible { if !eligible {
continue; continue;
} }
// A recon mark is an area, not a unit: it is kept while the mark lives. A
// hidden move does not move the aim; only a newer report can re-place it (#135).
if recon::is_mark(d.aim.unit) {
if self.recon.live(d.aim.unit, now) {
continue;
}
// The mark aged out: the drone falls through to a fresh lead below.
}
// What it is aiming at in the picture now, if anything (a unit merely moved is still // What it is aiming at in the picture now, if anything (a unit merely moved is still
// aimed where it was seen: a contact is matched by its observed place). // aimed where it was seen: a contact is matched by its observed place).
if let Some(current) = Self::aimed_contact(&picture, d.target - d.err) { else if let Some(current) = Self::aimed_contact(&picture, d.target - d.err) {
// Already aiming at a unit: a fresh disclosure may be worth a switch, under the throttle. // Already aiming at a unit: a fresh disclosure may be worth a switch, under the throttle.
let Some(c) = Self::switch_candidate(&picture, current, d, now) else { continue }; let Some(c) = Self::switch_candidate(&picture, current, d, now) else { continue };
if per_contact.get(&c.id).copied().unwrap_or(0) >= ASSIGN_PER_CONTACT { if per_contact.get(&c.id).copied().unwrap_or(0) >= ASSIGN_PER_CONTACT {
@@ -615,7 +908,7 @@ impl Sim {
d.intent = Intent::React; d.intent = Intent::React;
d.aim = d.aim.replaced(c.id, now, c.confidence(now)); d.aim = d.aim.replaced(c.id, now, c.confidence(now));
if Self::route_plannable(d) { if Self::route_plannable(d) {
jobs.push(RouteJob::new(job_next, d.id, d.target, d.aim.unit, now, Intent::React, Arc::clone(&picture), relief.clone())); jobs.push(RouteJob::new(job_next, d.id, d.target, d.aim.unit, now, Intent::React, Arc::clone(&knowledge), relief.clone()));
job_next += 1; job_next += 1;
} else { } else {
d.route.clear(); d.route.clear();
@@ -627,15 +920,39 @@ impl Sim {
if assigned >= ASSIGN_PER_TICK { if assigned >= ASSIGN_PER_TICK {
continue; continue;
} }
let Some(c) = Self::fresh_target(&picture, &per_contact, d.kind, n) else { continue }; // The candidate picks from the one merged hint list (#149): a matched mark is not a
*per_contact.entry(c.id).or_insert(0) += 1; // second target, and both channels rank on the same public scale. The legacy mode
// keeps the two separate lists and their old scales.
let (at, unit, confidence) = if self.smart_legacy {
let exact = Self::fresh_target(&picture, &per_contact, d.kind, n);
let mark = Self::fresh_recon_target(&leads, &per_contact);
match (exact, mark) {
(Some(c), Some(m)) => {
let exact_rank = Self::exact_rank(&c, now);
if m.priority(now) > exact_rank {
(m.area, m.id, m.confidence(now))
} else {
(c.at, c.id, c.confidence(now))
}
}
(Some(c), None) => (c.at, c.id, c.confidence(now)),
(None, Some(m)) => (m.area, m.id, m.confidence(now)),
(None, None) => continue,
}
} else {
match Self::fresh_observation(&obs, &per_contact, d.kind, n) {
Some(o) => (o.at, o.id, o.confidence(now)),
None => continue,
}
};
*per_contact.entry(unit).or_insert(0) += 1;
assigned += 1; assigned += 1;
d.target = c.at + d.err; d.target = at + d.err;
d.intent = Intent::React; d.intent = Intent::React;
// A first assignment is not a switch: the aim's clock starts here, the count is kept. // A first assignment is not a switch: the aim's clock starts here, the count is kept.
d.aim = Aim { unit: c.id, since: now, switches: d.aim.switches, confidence: Some(c.confidence(now)) }; d.aim = Aim { unit, since: now, switches: d.aim.switches, confidence: Some(confidence) };
if Self::route_plannable(d) { if Self::route_plannable(d) {
jobs.push(RouteJob::new(job_next, d.id, d.target, d.aim.unit, now, Intent::React, Arc::clone(&picture), relief.clone())); jobs.push(RouteJob::new(job_next, d.id, d.target, d.aim.unit, now, Intent::React, Arc::clone(&knowledge), relief.clone()));
job_next += 1; job_next += 1;
} else { } else {
// Nothing will be replanned for it: its old route leads to the old aim, so it goes straight. // Nothing will be replanned for it: its old route leads to the old aim, so it goes straight.
@@ -648,11 +965,14 @@ impl Sim {
// moved is still aimed where seen. // moved is still aimed where seen.
for d in self.drones.iter_mut().filter(|d| d.alive() && d.smart) { for d in self.drones.iter_mut().filter(|d| d.alive() && d.smart) {
let aim = d.target - d.err; let aim = d.target - d.err;
let aim_gone = self let aim_gone = if recon::is_mark(d.aim.unit) {
.intel !self.recon.live(d.aim.unit, self.tick)
} else {
self.intel
.contacts .contacts
.values() .values()
.any(|c| c.at.distance(aim) < 6.0 && !c.live(self.tick)); .any(|c| c.at.distance(aim) < 6.0 && !c.live(self.tick))
};
if !aim_gone { if !aim_gone {
continue; continue;
} }
@@ -663,19 +983,50 @@ impl Sim {
if d.aim.switches >= SWITCH_CAP || assigned >= ASSIGN_PER_TICK { if d.aim.switches >= SWITCH_CAP || assigned >= ASSIGN_PER_TICK {
continue; continue;
} }
let next = picture // The candidate replaces from the one merged hint list, best public rank first and
// nearest among equals (#149); the legacy mode keeps the two lists and their scales.
let next = if self.smart_legacy {
let exact = picture
.iter() .iter()
.filter(|c| !plannable || Self::can_turn_to(d, c.at)) .filter(|c| !plannable || Self::can_turn_to(d, c.at))
.filter(|c| per_contact.get(&c.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT) .filter(|c| per_contact.get(&c.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
.min_by(|a, b| a.at.distance(d.pos).total_cmp(&b.at.distance(d.pos))); .map(|c| (c.at.distance(d.pos), c.id, c.at, c.confidence(now)))
if let Some(c) = next { .min_by(|a, b| a.0.total_cmp(&b.0));
*per_contact.entry(c.id).or_insert(0) += 1; let mark = leads
.iter()
.filter(|m| !plannable || Self::can_turn_to(d, m.area))
.filter(|m| per_contact.get(&m.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
.map(|m| (m.area.distance(d.pos), m.id, m.area, m.confidence(now), m.priority(now)))
.min_by(|a, b| b.4.cmp(&a.4).then(a.0.total_cmp(&b.0)));
// A confirmed recon mark outranks a doubtful disclosure; an exact contact of equal
// freshness is preferred, because it is a fix rather than an area.
let exact_rank = exact.map(|(_, _, _, c)| match c {
Confidence::Confirmed => 30,
Confidence::Probable => 15,
Confidence::Doubtful => 0,
});
match (exact, mark) {
(Some(_), Some(m)) if m.4 > exact_rank.unwrap_or(0) + 3 => Some((m.0, m.1, m.2, m.3)),
(Some(e), _) => Some(e),
(None, Some(m)) => Some((m.0, m.1, m.2, m.3)),
(None, None) => None,
}
} else {
obs.iter()
.filter(|o| !plannable || Self::can_turn_to(d, o.at))
.filter(|o| per_contact.get(&o.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
.map(|o| (o.at.distance(d.pos), o.id, o.at, o.confidence(now), o.rank(now)))
.min_by(|a, b| b.4.cmp(&a.4).then(a.0.total_cmp(&b.0)))
.map(|(d, id, at, c, _)| (d, id, at, c))
};
if let Some((_, unit, at, confidence)) = next {
*per_contact.entry(unit).or_insert(0) += 1;
assigned += 1; assigned += 1;
d.target = c.at + d.err; d.target = at + d.err;
d.intent = Intent::Replace; d.intent = Intent::Replace;
d.aim = d.aim.replaced(c.id, now, c.confidence(now)); d.aim = d.aim.replaced(unit, now, confidence);
if plannable { if plannable {
jobs.push(RouteJob::new(job_next, d.id, d.target, d.aim.unit, now, Intent::Replace, Arc::clone(&picture), relief.clone())); jobs.push(RouteJob::new(job_next, d.id, d.target, d.aim.unit, now, Intent::Replace, Arc::clone(&knowledge), relief.clone()));
job_next += 1; job_next += 1;
} else { } else {
d.route.clear(); d.route.clear();
@@ -716,6 +1067,49 @@ impl Sim {
all.get(n % all.len().max(1)).map(|c| **c) all.get(n % all.len().max(1)).map(|c| **c)
} }
/// The rank of an exact disclosure contact: its confidence, what its observed kind is
/// worth, and a small premium for being a fix rather than an area.
fn exact_rank(c: &Contact, now: u64) -> u8 {
let seen = match c.confidence(now) {
Confidence::Confirmed => 30,
Confidence::Probable => 15,
Confidence::Doubtful => 0,
};
seen + recon::Category::of(c.kind).weight() + 3
}
/// The best recon mark a drone not yet sent at a unit may be given: observed role and
/// freshness first (the list is sorted), bounded per mark. A mark's category must be one
/// worth a strike; a support or unknown mark is only navigation interest.
fn fresh_recon_target(leads: &[recon::Mark], per_contact: &HashMap<u32, usize>) -> Option<recon::Mark> {
leads
.iter()
.copied()
.filter(|m| m.category.weight() >= 2)
.find(|m| per_contact.get(&m.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
}
/// The hint a drone not yet sent at a unit should be given (#149): one merged list, one
/// public scale. A transmitting jammer is the loudest disclosure, then (for the hunters)
/// anything that showed itself, then a round-robin over what fits — a disclosure contact
/// always fits, a recon mark only when the small policy says its category suits the kind.
fn fresh_observation(obs: &[Observation], per_contact: &HashMap<u32, usize>, kind: DroneKind, n: usize) -> Option<Observation> {
let free = |o: &&Observation| per_contact.get(&o.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT;
let jammers: Vec<&Observation> = obs.iter().filter(|o| o.category == recon::Category::Ew && o.channel == recon::Source::Jamming).filter(free).collect();
if let Some(o) = jammers.get(n % jammers.len().max(1)) {
return Some(**o);
}
let hunters = matches!(kind, DroneKind::Lancet | DroneKind::Kh22 | DroneKind::Zircon);
if hunters {
let shown: Vec<&Observation> = obs.iter().filter(|o| o.channel != recon::Source::Flyby).filter(free).collect();
if let Some(o) = shown.get(n % shown.len().max(1)) {
return Some(**o);
}
}
let fit: Vec<&Observation> = obs.iter().filter(|o| o.kind.is_some() || observe::fits(kind, o.category)).filter(free).collect();
fit.get(n % fit.len().max(1)).map(|o| **o)
}
/// Whether a fresh disclosure is worth replacing this drone's aim: a contact observed after the /// Whether a fresh disclosure is worth replacing this drone's aim: a contact observed after the
/// aim was chosen, trusted (not `Doubtful`), clearly better placed or better believed, and the /// aim was chosen, trusted (not `Doubtful`), clearly better placed or better believed, and the
/// throttle (hold time, switch cap) allows it (#127). A route change costs the planner a new /// throttle (hold time, switch cap) allows it (#127). A route change costs the planner a new
@@ -921,7 +1315,7 @@ impl Sim {
Some(r) => r.clone(), Some(r) => r.clone(),
None => { None => {
if !prices.contains_key(&(kind, version)) { if !prices.contains_key(&(kind, version)) {
let (p, cost) = self.price_grid_known(&grid, kind, land, job.known.as_slice()); let (p, cost) = self.price_grid_known(&grid, kind, land, &job.known);
work += cost; work += cost;
prices.insert((kind, version), p); prices.insert((kind, version), p);
} }
@@ -1009,7 +1403,7 @@ pub struct ContactReport {
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub struct AimReport { pub struct AimReport {
pub drone: u32, pub drone: u32,
/// The unit aimed at (0: a marked object). /// The unit aimed at (0: a marked object; a recon mark has a synthetic id).
pub unit: u32, pub unit: u32,
/// "plan", "sead", "react" or "replace". /// "plan", "sead", "react" or "replace".
pub intent: &'static str, pub intent: &'static str,
@@ -1019,6 +1413,43 @@ pub struct AimReport {
pub switches: u16, pub switches: u16,
/// The confidence of the contact the aim rests on, when it is a unit. /// The confidence of the contact the aim rests on, when it is a unit.
pub confidence: Option<Confidence>, pub confidence: Option<Confidence>,
/// Whether the aim is a recon mark's area rather than a unit contact.
pub recon: bool,
/// A recon mark's priority (observed role, freshness, quality); `None` for a unit contact.
pub priority: Option<u8>,
}
/// A recon mark as the diagnostic reports it (#135): an area, a coarse category, the channel,
/// its age and quality. There is no true place, SamKind, health, magazine, link or real id here.
#[derive(Clone, Debug, PartialEq)]
pub struct ReconReport {
pub id: u32,
pub area: DVec3,
pub radius: f64,
/// "unknown", "radar", "launcher", "gun", "ew" or "support".
pub category: &'static str,
/// A radar's role once a refined look told it.
pub role: Option<&'static str>,
/// "flyby", "emission", "jamming" or "launch".
pub source: &'static str,
pub age: u64,
/// "coarse" or "refined".
pub quality: &'static str,
pub confidence: Confidence,
pub live: bool,
/// What the planner makes of it, in words: observed role and freshness only.
pub priority: u8,
}
/// One recon sortie as the diagnostic reports it (#135).
#[derive(Clone, Debug, PartialEq)]
pub struct ReconSortieReport {
pub drone: u32,
/// "outbound", "looking", "reporting" or "done".
pub phase: &'static str,
pub zones_left: usize,
/// The tick its pending report is due.
pub report_in: Option<u64>,
} }
/// A route job the planner has not finished (#127): what it is for, why it is still waiting, /// A route job the planner has not finished (#127): what it is for, why it is still waiting,
@@ -1040,6 +1471,27 @@ pub struct PendingReport {
pub reason: &'static str, pub reason: &'static str,
} }
/// One merged public hint as the diagnostic reports it (#149): the one scale the planner ranks
/// and prices by, and whether a second channel agreed by public features (a belief, not a fact).
#[derive(Clone, Debug, PartialEq)]
pub struct ObservationReport {
pub id: u32,
pub at: DVec3,
pub radius: f64,
/// "flyby", "emission", "jamming" or "launch".
pub channel: &'static str,
pub age: u64,
pub confidence: Confidence,
pub category: &'static str,
pub role: Option<&'static str>,
/// The identified type of a disclosure contact; `None` for a recon mark's area.
pub kind: Option<&'static str>,
pub quality: &'static str,
/// A second public hint matched by area and category. Never a hidden truth.
pub matched: bool,
pub rank: u8,
}
/// The enemy's whole picture at one tick: what it knows and what it assumes, structured for /// The enemy's whole picture at one tick: what it knows and what it assumes, structured for
/// diagnostics (#127). No truth anywhere in it — a unit the picture got wrong is reported wrong. /// diagnostics (#127). No truth anywhere in it — a unit the picture got wrong is reported wrong.
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
@@ -1052,6 +1504,18 @@ pub struct EnemyPictureReport {
pub pending: Vec<PendingReport>, pub pending: Vec<PendingReport>,
/// The planner's work a tick, for the pending queue's budget. /// The planner's work a tick, for the pending queue's budget.
pub work_per_tick: usize, pub work_per_tick: usize,
/// The partial picture recon flights radioed home (#135).
pub recon: Vec<ReconReport>,
/// The recon flights still out.
pub recon_sorties: Vec<ReconSortieReport>,
/// The one merged hint list the candidate planner ranks and prices by (#149).
pub observations: Vec<ObservationReport>,
/// The bearing picker's last decision and its typed reason (#149).
pub bearing: BearingReport,
/// Whether a bounded refresh of the unreleased portion is still waiting for a report (#149).
pub refresh_waiting: bool,
/// Aims the refresh has re-chosen so far (#149).
pub refresh_applied: u32,
} }
impl Sim { impl Sim {
@@ -1099,13 +1563,18 @@ impl Sim {
.map(|(_, d)| d) .map(|(_, d)| d)
.chain(self.drones.iter()) .chain(self.drones.iter())
.filter(|d| d.alive() && d.smart) .filter(|d| d.alive() && d.smart)
.map(|d| AimReport { .map(|d| {
let mark = self.recon.marks.get(&d.aim.unit).filter(|m| m.live(now)).copied();
AimReport {
drone: d.id, drone: d.id,
unit: d.aim.unit, unit: d.aim.unit,
intent: d.intent.name(), intent: d.intent.name(),
since: d.aim.since, since: d.aim.since,
switches: d.aim.switches, switches: d.aim.switches,
confidence: d.aim.confidence, confidence: d.aim.confidence,
recon: mark.is_some(),
priority: mark.map(|m| m.priority(now)),
}
}) })
.collect(); .collect();
let pending = self let pending = self
@@ -1129,7 +1598,73 @@ impl Sim {
}, },
}) })
.collect(); .collect();
EnemyPictureReport { now, contacts, aims, pending, work_per_tick: raid::WORK_PER_TICK } let recon = self
.recon
.marks
.values()
.map(|m| ReconReport {
id: m.id,
area: m.area,
radius: m.radius,
category: m.category.name(),
role: m.role.map(|r| r.key()),
source: m.source.name(),
age: m.age(now),
quality: m.quality.name(),
confidence: m.confidence(now),
live: m.live(now),
priority: m.priority(now),
})
.collect();
let recon_sorties = self
.recon
.sorties
.iter()
.map(|s| ReconSortieReport {
drone: s.drone,
phase: if s.report_at.is_some() {
"reporting"
} else if s.next < s.zones.len() {
"outbound"
} else {
"done"
},
zones_left: s.zones.len().saturating_sub(s.next),
report_in: s.report_at.map(|t| t.saturating_sub(now)),
})
.collect();
let observations = self
.knowledge_now()
.observations()
.into_iter()
.map(|o| ObservationReport {
id: o.id,
at: o.at,
radius: o.radius,
channel: o.channel.name(),
age: o.age(now),
confidence: o.confidence(now),
category: o.category.name(),
role: o.role.map(|r| r.key()),
kind: o.kind.map(|k| k.spec().key),
quality: o.quality.name(),
matched: o.matched,
rank: o.rank(now),
})
.collect();
EnemyPictureReport {
now,
contacts,
aims,
pending,
work_per_tick: raid::WORK_PER_TICK,
recon,
recon_sorties,
observations,
bearing: self.bearing,
refresh_waiting: self.refresh.is_some(),
refresh_applied: self.refresh_applied,
}
} }
/// What the planner makes of a contact, in words for the diagnostic (#127). /// What the planner makes of a contact, in words for the diagnostic (#127).
@@ -1687,7 +2222,7 @@ mod intent_tests {
d.smart = true; d.smart = true;
let id = d.id; let id = d.id;
sim.drones.push(d); sim.drones.push(d);
sim.queue_route(RouteJob::for_test(id, DVec3::new(1000.0, 70.0, 0.0), 0, 1, Arc::new(Vec::new()), None)); sim.queue_route(RouteJob::for_test(id, DVec3::new(1000.0, 70.0, 0.0), 0, 1, Arc::new(KnowledgeSnapshot::empty(1)), None));
} }
assert_eq!(sim.retargets.len(), JOBS_MAX); assert_eq!(sim.retargets.len(), JOBS_MAX);
// A replacement is worth less than a plan's objective: the queue refuses it. // A replacement is worth less than a plan's objective: the queue refuses it.
@@ -1695,7 +2230,7 @@ mod intent_tests {
d.smart = true; d.smart = true;
let id = d.id; let id = d.id;
sim.drones.push(d); sim.drones.push(d);
sim.queue_route(RouteJob::for_test(id, DVec3::new(1000.0, 70.0, 50.0), 0, 2, Arc::new(Vec::new()), None).with_intent(Intent::Replace)); sim.queue_route(RouteJob::for_test(id, DVec3::new(1000.0, 70.0, 50.0), 0, 2, Arc::new(KnowledgeSnapshot::empty(2)), None).with_intent(Intent::Replace));
assert_eq!(sim.retargets.len(), JOBS_MAX, "a worthless job grew the queue"); assert_eq!(sim.retargets.len(), JOBS_MAX, "a worthless job grew the queue");
// Nothing queued is a replacement: a replacement is the lowest priority and does displace one. // Nothing queued is a replacement: a replacement is the lowest priority and does displace one.
sim.retargets.iter_mut().for_each(|j| j.intent = Intent::Replace); sim.retargets.iter_mut().for_each(|j| j.intent = Intent::Replace);
@@ -1703,7 +2238,7 @@ mod intent_tests {
d.smart = true; d.smart = true;
let id = d.id; let id = d.id;
sim.drones.push(d); sim.drones.push(d);
sim.queue_route(RouteJob::for_test(id, DVec3::new(1000.0, 70.0, 60.0), 0, 2, Arc::new(Vec::new()), None).with_intent(Intent::Plan)); sim.queue_route(RouteJob::for_test(id, DVec3::new(1000.0, 70.0, 60.0), 0, 2, Arc::new(KnowledgeSnapshot::empty(2)), None).with_intent(Intent::Plan));
assert_eq!(sim.retargets.len(), JOBS_MAX, "the bound was broken"); assert_eq!(sim.retargets.len(), JOBS_MAX, "the bound was broken");
assert!(sim.retargets.back().is_some_and(|j| j.drone == id && j.intent == Intent::Plan), "the plan's job did not make room"); assert!(sim.retargets.back().is_some_and(|j| j.drone == id && j.intent == Intent::Plan), "the plan's job did not make room");
} }
+7
View File
@@ -67,6 +67,13 @@ pub fn level(age: f64, life: f64) -> (f32, f32) {
} }
impl Fires { impl Fires {
/// What the fires hold, about (see `sim::memory`).
pub(super) fn bytes(&self) -> usize {
use super::memory::vec_bytes;
vec_bytes(&self.list)
+ self.list.iter().map(|f| vec_bytes(&f.blocks)).sum::<usize>()
+ self.cleanup.iter().map(|s| s.capacity()).sum::<usize>()
}
/// Fires burning now. /// Fires burning now.
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.list.len() self.list.len()
+178
View File
@@ -0,0 +1,178 @@
//! Where the mod's memory goes: an estimate of what each consumer holds, for the budget
//! tests and the diagnostics. The whole mod lives in one 64 MiB WASM linear memory
//! (`horizon-mods` runtime `MEMORY`): the simulation, the ground and block caches, the
//! recordings and the enemy's memory all share it, and a hashbrown rehash briefly holds
//! the old and the new table at once. The estimates count allocated capacity, not len,
//! and the tables' control bytes; they are a lower bound on the allocator's footprint
//! (fragmentation and the transient query/answer vectors come on top).
use super::*;
/// A hashbrown table's allocation for `len` entries of `entry` bytes (key + value):
/// the capacity grows 3, 7, 14, 28, … at a 7/8 load, and the allocation is
/// `(capacity + group) * (entry + 1)` (one control byte per slot).
pub(super) fn map_bytes(len: usize, entry: usize) -> usize {
if len == 0 {
return 0;
}
let mut cap = 3usize;
while cap * 7 / 8 < len {
cap = if cap == 3 { 7 } else { cap * 2 };
}
(cap + 16) * (entry + 1)
}
/// A `BTreeMap`'s nodes, about: the entry plus the node's share of pointers and slack.
pub(super) fn btree_bytes(len: usize, entry: usize) -> usize {
len * (entry + 32)
}
pub(super) fn vec_bytes<T>(v: &Vec<T>) -> usize {
v.capacity() * std::mem::size_of::<T>()
}
pub(super) fn vecdeque_bytes<T>(v: &std::collections::VecDeque<T>) -> usize {
v.capacity() * std::mem::size_of::<T>()
}
/// What each consumer holds, in bytes (estimated allocated capacity).
#[derive(Clone, Copy, Default, Debug)]
pub struct MemoryReport {
/// `Ground::known`: the answered land heights by column.
pub ground_known: usize,
/// The ground's other bookkeeping: loading, questions waiting, chunks wanted.
pub ground_other: usize,
/// `WorldCache::secs`: the block sections, table and the mixed ones' bits.
pub world_sections: usize,
/// The block cache's other bookkeeping: exact rays, queues, questions, blasts expected.
pub world_other: usize,
/// The simulation's vectors: drones (and their routes), missiles, systems, objects,
/// effects, blasts, the launch queue and the rest of the live state.
pub units: usize,
/// The radars' tracks and horizons.
pub tracks: usize,
/// The recording in progress.
pub recording: usize,
/// The replays kept.
pub replays: usize,
/// The enemy's memory of the layout (contacts and outcomes).
pub intel: usize,
/// The recon memory (sorties, marks, checked zones).
pub recon: usize,
/// The vehicles' ground routes and their searches.
pub routes: usize,
/// The raid's launch sites.
pub sites: usize,
/// The counter-strikes on the sites.
pub strikes: usize,
/// The raid being planned (its grid, prices, routes, knowledge) and the retarget jobs.
pub plan: usize,
/// The rest: fires, flares, roles, tallies, the smart refresh.
pub other: usize,
}
impl MemoryReport {
pub fn total(&self) -> usize {
self.ground_known
+ self.ground_other
+ self.world_sections
+ self.world_other
+ self.units
+ self.tracks
+ self.recording
+ self.replays
+ self.intel
+ self.recon
+ self.routes
+ self.sites
+ self.strikes
+ self.plan
+ self.other
}
/// The largest table a rehash could double while the old one is still held: the
/// transient peak is the total plus twice this (old + new − steady).
pub fn rehash_headroom(&self) -> usize {
2 * self.ground_known.max(self.world_sections)
}
/// One line per consumer, biggest first: the budget report's shape.
pub fn text(&self) -> String {
let mut rows = [
("ground.known", self.ground_known),
("ground.other", self.ground_other),
("world.secs", self.world_sections),
("world.other", self.world_other),
("sim.units", self.units),
("sim.tracks", self.tracks),
("recording", self.recording),
("replays", self.replays),
("intel", self.intel),
("recon", self.recon),
("routes", self.routes),
("sites", self.sites),
("strikes", self.strikes),
("plan", self.plan),
("other", self.other),
];
rows.sort_by(|a, b| b.1.cmp(&a.1));
let mut out = format!("total {:.2} MiB (+{:.2} MiB rehash transient)", self.total() as f64 / (1024.0 * 1024.0), self.rehash_headroom() as f64 / (1024.0 * 1024.0));
for (name, bytes) in rows {
if bytes > 0 {
out.push_str(&format!("\n {name}: {:.2} MiB", bytes as f64 / (1024.0 * 1024.0)));
}
}
out
}
}
impl Sim {
/// What the simulation and the ground cache hold, about: the budget tests measure it
/// under load, and the diagnostics can show where the memory went.
pub fn memory(&self, ground: &Ground) -> MemoryReport {
let mut r = MemoryReport::default();
r.ground_known = map_bytes(ground.known.len(), std::mem::size_of::<(i32, i32)>() + std::mem::size_of::<(i32, u64)>());
r.ground_other = map_bytes(ground.loading.len(), std::mem::size_of::<(i32, i32)>() + std::mem::size_of::<u64>())
+ vec_bytes(&ground.wanted)
+ map_bytes(ground.asked.len(), std::mem::size_of::<(i32, i32)>())
+ vec_bytes(&ground.chunks);
let (sections, other) = ground.world.memory();
r.world_sections = sections;
r.world_other = other;
r.units = vec_bytes(&self.drones)
+ self.drones.iter().map(|d| vec_bytes(&d.route)).sum::<usize>()
+ vec_bytes(&self.missiles)
+ vec_bytes(&self.sams)
+ vec_bytes(&self.targets)
+ vec_bytes(&self.target_health)
+ vec_bytes(&self.fx)
+ vec_bytes(&self.blasts)
+ vec_bytes(&self.queue)
+ vec_bytes(&self.settling)
+ vec_bytes(&self.later)
+ vec_bytes(&self.flares)
+ vec_bytes(&self.lit);
r.tracks = self.sams.iter().map(|s| vec_bytes(&s.tracks)).sum::<usize>()
+ map_bytes(self.horizons.len(), std::mem::size_of::<u32>() + std::mem::size_of::<sight::Horizon>())
+ self.horizons.values().map(|h| vec_bytes(&h.rays) + h.rays.iter().map(|ray| vec_bytes(ray)).sum::<usize>()).sum::<usize>();
r.recording = self.rec.as_ref().map_or(0, |rec| rec.bytes());
r.replays = self.replays.iter().map(|rec| rec.bytes()).sum();
r.intel = self.intel.bytes();
r.recon = vec_bytes(&self.recon.sorties)
+ btree_bytes(self.recon.marks.len(), std::mem::size_of::<u32>() + std::mem::size_of::<recon::Mark>())
+ btree_bytes(self.recon.truth.len(), 2 * std::mem::size_of::<u32>())
+ btree_bytes(self.recon.checked.len(), std::mem::size_of::<(i64, i64)>() + std::mem::size_of::<u64>());
r.routes = self.routes.bytes();
r.sites = self.sites.bytes();
r.strikes = self.strikes.bytes();
r.plan = self.plan.as_ref().map_or(0, |p| p.bytes())
+ vecdeque_bytes(&self.retargets)
+ self.retargets.iter().map(|j| j.known.bytes() + j.relief.as_ref().map_or(0, |k| k.bytes())).sum::<usize>()
+ self.known_relief.as_ref().map_or(0, |k| k.bytes());
r.other = map_bytes(self.roles.len(), std::mem::size_of::<SamKind>() + std::mem::size_of::<u8>())
+ self.fires.bytes()
+ std::mem::size_of::<record::Tally>()
+ std::mem::size_of::<Self>();
r
}
}
+268 -74
View File
@@ -25,8 +25,13 @@ pub mod record;
mod sight; mod sight;
mod terrain; mod terrain;
mod ew; mod ew;
mod observe;
mod optical;
mod recon;
mod durable; mod durable;
pub use ew::{AimReport, Confidence, ContactReport, EnemyPictureReport, Intent, PendingReport}; pub use ew::{AimReport, BearingReason, BearingReport, Confidence, ContactReport, EnemyPictureReport, Intent, ObservationReport, PendingReport, ReconReport, ReconSortieReport};
pub use observe::Observation;
pub use recon::{Category, Mark, Quality, Source, is_drone_id, priority_parts};
pub mod lights; pub mod lights;
mod logistics; mod logistics;
mod orders; mod orders;
@@ -36,15 +41,23 @@ pub mod outcome;
mod units; mod units;
pub mod why; pub mod why;
pub mod world; pub mod world;
pub mod memory;
pub use memory::MemoryReport;
pub mod profile;
#[cfg(test)] #[cfg(test)]
mod balance; mod balance;
#[cfg(test)] #[cfg(test)]
mod regress; mod regress;
#[cfg(test)] #[cfg(test)]
mod sensor_tests; mod sensor_tests;
#[cfg(test)]
mod smart_tests;
pub use ew::EW_RADIUS; pub use ew::EW_RADIUS;
pub use damage::{Comps, Part, PartState}; pub use damage::{Comps, Part, PartState};
pub use sight::{AirPicture, Ident, LowSensor, Track, RIM_RAYS}; pub use sight::{AirPicture, Ident, LowSensor, Track, RIM_RAYS};
pub use optical::{Optical, OpticalClassEstimate, OpticalObservation, OpticalObservable, OpticalReport, OpticalState, SightBlock};
/// The passive optical post's clear-day reach (the monitor's scale reads it).
pub const OPTICAL_RANGE: f64 = optical::RANGE;
use damage::dice; use damage::dice;
use outcome::{Impact, Outcome}; use outcome::{Impact, Outcome};
pub use units::{Family, SamKind}; pub use units::{Family, SamKind};
@@ -171,6 +184,11 @@ impl Rng {
pub fn state(&self) -> u64 { pub fn state(&self) -> u64 {
self.0 self.0
} }
/// Puts the generator back exactly where it was (a recon launch must not spend the
/// strike's combat randomness).
pub(super) fn set_state(&mut self, state: u64) {
self.0 = state;
}
pub fn next(&mut self) -> u64 { pub fn next(&mut self) -> u64 {
self.0 ^= self.0 << 13; self.0 ^= self.0 << 13;
self.0 ^= self.0 >> 7; self.0 ^= self.0 >> 7;
@@ -270,8 +288,6 @@ pub struct Ground {
chunks: Vec<(i32, i32)>, chunks: Vec<(i32, i32)>,
/// The game has answered "loading" at least once: it loads chunks on request (a server doesn't). /// The game has answered "loading" at least once: it loads chunks on request (a server doesn't).
pub loads: bool, pub loads: bool,
/// The tick of the last full clean-up (a big cache would otherwise be scanned on every answer).
swept: u64,
/// The tick of the last answer round: what the heights' ages are measured against. /// The tick of the last answer round: what the heights' ages are measured against.
now: u64, now: u64,
/// The world's epoch when the last questions went out: an answer to them is of that world or dimension, or of none. /// The world's epoch when the last questions went out: an answer to them is of that world or dimension, or of none.
@@ -302,8 +318,15 @@ const HEIGHT_TTL: u64 = 1200;
/// Ticks a flight waits for an unanswered section, and for a chunk the game doesn't have while low over the land (#61). /// Ticks a flight waits for an unanswered section, and for a chunk the game doesn't have while low over the land (#61).
pub const HOLD_PENDING: u16 = 45; pub const HOLD_PENDING: u16 = 45;
pub const HOLD_NO_CHUNK: u16 = 240; pub const HOLD_NO_CHUNK: u16 = 240;
/// Ticks between full clean-ups of a big ground cache. /// Columns whose heights are kept: the ground cache's share of the 64 MiB WASM linear memory
const SWEEP_EVERY: u64 = 200; /// the whole mod lives in (shared with the block cache, the recordings and the simulation).
/// An entry is 24 bytes plus a control byte at a 7/8 load (~29 B): 100_000 columns are ~2.7 MiB
/// steady, and a hashbrown rehash holds the old and the new table at once (~8.2 MiB transient).
/// Beyond the cap the oldest answers go first — the cache is reconstructible: an evicted column
/// is asked again when it is next needed, exactly as one never seen.
const KNOWN_MAX: usize = 100_000;
/// Heights older than this go in a sweep: past `HEIGHT_TTL`, due to be asked again anyway.
const SWEEP_AGE: u64 = 2000;
impl Ground { impl Ground {
/// One above the highest solid block, if known; the column is asked for /// One above the highest solid block, if known; the column is asked for
@@ -358,11 +381,22 @@ impl Ground {
self.world.note_settled(how); self.world.note_settled(how);
self.forget(at, 8); self.forget(at, 8);
} }
if self.known.len() > 300_000 && now.saturating_sub(self.swept) >= SWEEP_EVERY { if self.known.len() > KNOWN_MAX {
self.swept = now; self.sweep_known(now);
self.known.retain(|_, (_, when)| now.saturating_sub(*when) < 2000);
} }
} }
/// The cache over its budget: the oldest answers go, down to three quarters of the cap so
/// a sweep is not every tick (at most a few hundred answers arrive in one). Heights past
/// `SWEEP_AGE` go with them. A height reported changed (`STALE`) is still in use and stays:
/// it sorts as the newest and is asked again within the refresh budget. Equally old answers
/// are ordered by column, so the same cache always sweeps to the same state.
fn sweep_known(&mut self, now: u64) {
let keep = KNOWN_MAX * 3 / 4;
let mut ages: Vec<(u64, (i32, i32))> = self.known.iter().map(|(&k, (_, when))| (*when, k)).collect();
ages.sort_unstable();
let cut = ages[ages.len() - keep];
self.known.retain(|&k, (_, when)| (*when, k) >= cut && now.saturating_sub(*when) < SWEEP_AGE);
}
/// Heights over blocks that changed (the block cache's notes of changes, chunk replacements and a new world) /// Heights over blocks that changed (the block cache's notes of changes, chunk replacements and a new world)
/// are marked old (`when` = STALE): still used, asked again within the budget. #64. /// are marked old (`when` = STALE): still used, asked again within the budget. #64.
fn age_heights(&mut self) { fn age_heights(&mut self) {
@@ -438,6 +472,10 @@ impl Ground {
pub fn chunks_wanted(&self) -> usize { pub fn chunks_wanted(&self) -> usize {
self.chunks.len() self.chunks.len()
} }
/// How many columns' heights are cached (the budget tests and the diagnostics read it).
pub fn known_len(&self) -> usize {
self.known.len()
}
/// The chunks to ask the game to load this tick. /// The chunks to ask the game to load this tick.
pub fn take_chunks(&mut self) -> Vec<(i32, i32)> { pub fn take_chunks(&mut self) -> Vec<(i32, i32)> {
std::mem::take(&mut self.chunks) std::mem::take(&mut self.chunks)
@@ -574,11 +612,135 @@ impl Class {
Class::Ballistic => "Б", Class::Ballistic => "Б",
} }
} }
/// The class as one object ("дрон", "крылатая ракета"): what a track's estimate reads as.
pub fn singular(self) -> &'static str {
match self {
Class::Drone => "дрон",
Class::Jet => "реакт. дрон",
Class::Cruise => "крылатая ракета",
Class::Supersonic => "сверхзвуковая ракета",
Class::Ballistic => "баллистическая ракета",
}
}
/// The class a measured speed (blocks a tick) says: the classifier's bands (#133), between the
/// game's own speed clusters, so a slow propeller drone is never read as a jet. Contacts near a
/// boundary can sit in the wrong class for a while, or stay undecided between measurements:
/// there is no "three blips and the mark is known". A fast ballistic and a supersonic missile
/// fly alike (their bands overlap): only speed cannot tell them apart, and the first version
/// does not model the flight profile that would.
pub fn of_speed(v: f64) -> Class {
if v < 1.35 {
Class::Drone
} else if v < 1.9 {
Class::Jet
} else if v < 3.0 {
Class::Cruise
} else if v < 6.5 {
Class::Supersonic
} else {
Class::Ballistic
}
}
pub fn from_key(key: &str) -> Option<Self> { pub fn from_key(key: &str) -> Option<Self> {
Self::ALL.into_iter().find(|c| c.key() == key) Self::ALL.into_iter().find(|c| c.key() == key)
} }
} }
/// An optical observation this unsure (0 best, 1 worst) names no class for the network (#136):
/// the post still shows its own look, but the shared estimate keeps what the radars made of it.
pub const OPTICAL_CLASS_MAX_UNCERTAINTY: f64 = 0.5;
/// What the radars make of a track's class, from the measurements alone (#133): separate from
/// the track's confirmation (`Track::ident`, how firmly it is held), its own state with its own
/// rules. It travels with the measurement it grew from: a relay passes it as it was, ageing with
/// the track, and it is gone when the track drops — a re-detected contact starts over.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum ClassEst {
/// One measurement yet: something is there, its class is not.
Unknown,
/// Measured again: a class by how it flies; a new contrary measurement can still change it.
Probable(Class),
/// Several measurements agreed: high confidence.
Firm(Class),
}
impl ClassEst {
/// The class it holds, if any.
pub fn class(self) -> Option<Class> {
match self {
ClassEst::Unknown => None,
ClassEst::Probable(c) | ClassEst::Firm(c) => Some(c),
}
}
/// The estimate stepped by one more measurement that saw `speed`, `hits` of them so far (#133):
/// the first says nothing; the second names a class by its speed; each further agreeing
/// measurement firms it up, a contrary one replaces the hypothesis with the new guess.
/// Pure arithmetic on the measurement: nothing random, nothing from the target itself.
pub fn step(self, hits: u8, speed: f64) -> ClassEst {
let seen = Class::of_speed(speed);
match (self, hits) {
(_, 1) => ClassEst::Unknown,
(_, 2) => ClassEst::Probable(seen),
(ClassEst::Firm(had), _) if had == seen => ClassEst::Firm(had),
(ClassEst::Probable(had), _) if had == seen => ClassEst::Firm(had),
_ => ClassEst::Probable(seen),
}
}
/// The estimate stepped by one passive optical observation (#136): an independent look at the
/// same contact, never a radar measurement and never a relay. A look too unsure to name a
/// class (uncertainty over [`OPTICAL_CLASS_MAX_UNCERTAINTY`]) changes nothing. A sure look
/// names a class where none was, firms a probable one that agrees, and replaces a contrary
/// hypothesis with the new guess — the same arithmetic as [`Self::step`], fed by the optics
/// instead of the beam. It touches the class alone: no plot, no freshness and no fire right
/// travels with it, and a relay of the refined track carries the class as it was.
pub fn step_optical(self, class: Class, uncertainty: f64) -> ClassEst {
if uncertainty > OPTICAL_CLASS_MAX_UNCERTAINTY {
return self;
}
match self {
ClassEst::Unknown => ClassEst::Probable(class),
ClassEst::Probable(had) | ClassEst::Firm(had) if had == class => ClassEst::Firm(had),
_ => ClassEst::Probable(class),
}
}
/// Whether a system's roles cover the track's class. The explicit policy for the unknown
/// (#133): an unidentified track is not blocked by the class filter — it stays a candidate
/// under the general rules, and `why` says so. A system with no roles at all is holding its
/// fire: nothing is a candidate for it. A probable or firm class out of the roles is a block,
/// named in `why` too.
pub fn in_roles(self, roles: u8) -> bool {
match self {
ClassEst::Unknown => roles != 0,
ClassEst::Probable(c) | ClassEst::Firm(c) => roles & c.bit() != 0,
}
}
/// As the screens read it: «тип не определён», «вероятно крылатая ракета», «крылатая ракета».
pub fn name(self) -> String {
match self {
ClassEst::Unknown => "тип не определён".into(),
ClassEst::Probable(c) => format!("вероятно {}", c.singular()),
ClassEst::Firm(c) => c.singular().into(),
}
}
/// A short mark for the map's labels: the class letter, with `?` while the guess is only probable.
pub fn mark(self) -> &'static str {
match self {
ClassEst::Unknown => "",
ClassEst::Firm(c) => c.letter(),
ClassEst::Probable(Class::Drone) => "Д?",
ClassEst::Probable(Class::Jet) => "Г?",
ClassEst::Probable(Class::Cruise) => "К?",
ClassEst::Probable(Class::Supersonic) => "С?",
ClassEst::Probable(Class::Ballistic) => "Б?",
}
}
}
/// Roles as a mask of [`Class::bit`]s, from `drone,jet,...` or `all`. /// Roles as a mask of [`Class::bit`]s, from `drone,jet,...` or `all`.
pub fn parse_roles(text: &str) -> Option<u8> { pub fn parse_roles(text: &str) -> Option<u8> {
if text == "all" { if text == "all" {
@@ -811,6 +973,18 @@ impl Drone {
pub fn smart(&self) -> bool { pub fn smart(&self) -> bool {
self.smart self.smart
} }
/// Where it is aimed, without this airframe's navigation error: only the sandbox's truth view reads it (#132).
pub fn aim_pos(&self) -> DVec3 {
self.target - self.err
}
/// The unit it is sent at (0: a marked object), as the aim bookkeeping holds it (#127).
pub fn aim_unit(&self) -> u32 {
self.aim.unit
}
/// The points it flies by on its way, the next first: the truth view draws the route ahead.
pub fn route(&self) -> &[DVec3] {
&self.route
}
/// How much a system wants to shoot it: fast and heavy first, decoys look real. /// How much a system wants to shoot it: fast and heavy first, decoys look real.
fn threat(&self, from: DVec3) -> f64 { fn threat(&self, from: DVec3) -> f64 {
self.threat_at(from, self.pos) self.threat_at(from, self.pos)
@@ -956,6 +1130,10 @@ impl MissileKind {
} }
impl Missile { impl Missile {
/// The track it is intercepting: the map's hover says whether an interception is under way (#132).
pub fn target(&self) -> u32 {
self.target
}
/// Cold ejection and post-burn coast have no powered exhaust. /// Cold ejection and post-burn coast have no powered exhaust.
pub fn engine_lit(&self) -> bool { pub fn engine_lit(&self) -> bool {
let spec = self.kind.spec(); let spec = self.kind.spec();
@@ -963,6 +1141,14 @@ impl Missile {
} }
} }
#[cfg(any(test, feature = "test-fixtures"))]
impl Missile {
/// A missile in flight for the screens' tests: command guidance, no seeker fix.
pub fn test_at(id: u32, pos: DVec3, target: u32) -> Missile {
Missile { id, kind: MissileKind::Pac3, pos, vel: DVec3::Z, target, sam: 0, age: 20, hold: 0, fix: None, seen: 0 }
}
}
impl MissileKind { impl MissileKind {
/// How far its own seeker holds a target of average size (blocks); 0: command guidance only. /// How far its own seeker holds a target of average size (blocks); 0: command guidance only.
pub fn seeker(self) -> f64 { pub fn seeker(self) -> f64 {
@@ -1122,6 +1308,8 @@ pub struct Sam {
pub(super) terrain: HashMap<u32, (u64, u8)>, pub(super) terrain: HashMap<u32, (u64, u8)>,
/// Targets whose land hasn't been answered yet, and since when it has been waited for. /// Targets whose land hasn't been answered yet, and since when it has been waited for.
waits: HashMap<u32, u64>, waits: HashMap<u32, u64>,
/// A passive optical post's own state (#136): no radar, no track, one class observation at a time.
pub optical: Optical,
} }
impl Sam { impl Sam {
@@ -1195,6 +1383,7 @@ impl Sam {
beam_cast: 0, beam_cast: 0,
terrain: HashMap::new(), terrain: HashMap::new(),
waits: HashMap::new(), waits: HashMap::new(),
optical: Optical::default(),
} }
} }
pub fn alive(&self) -> bool { pub fn alive(&self) -> bool {
@@ -1220,57 +1409,9 @@ impl Sam {
self.yaw_vel = 0.0; self.yaw_vel = 0.0;
self.pitch_vel = 0.0; self.pitch_vel = 0.0;
} }
pub fn status(&self) -> String { /// The TPK cell being opened, for the presentation adapter.
let spec = self.kind.spec(); pub fn preparing_cell(&self) -> Option<u32> {
let mut text = spec.name.to_string(); self.preparing.map(|p| p.cell)
if !self.alive() {
return text + " УНИЧТОЖЕН";
}
if self.moving() {
return text + " " + &self.state.name().to_lowercase();
}
match self.kind {
SamKind::Depot => return format!("{text}: {} перезарядок, RM48U {}, снятых ПВО {}", self.cargo, self.ground_stock, self.air_48n6_stock),
SamKind::Tzm => return format!("{text}: на борту {}/2, RM48U {}, снятых ПВО {}{}", self.cargo, self.ground_stock, self.air_48n6_stock, if self.return_cargo { ", везёт RM48U на склад" } else if self.job.is_some() { ", в пути" } else { "" }),
SamKind::Ew => {
let state = if self.ew_on { "ГЛУШИТ" } else if self.ew_lock { "остывает" } else { "готова" };
return format!("{text}: {state}, нагрев {:.0}%", self.heat * 100.0);
}
SamKind::Radar => {
let broken = if self.comps.whole() { String::new() } else { format!(" [{}]", self.comps.worst(self.kind)) };
return format!("{text}: целей {}{broken}", self.own.len());
}
SamKind::Light => return format!("{text}{}", if self.target.is_some() { ": в луче цель" } else { "" }),
_ => {}
}
if let Some(p) = self.preparing {
text += &format!(" · открытие ТПК №{}", p.cell + 1);
}
if self.empty && self.missiles == 0 {
text += " ЖДЁТ БК";
}
if self.health < 1.0 {
text += &format!(" ({:.0}%)", self.health * 100.0);
}
if !self.comps.whole() {
text += &format!(" [{}]", self.comps.worst(self.kind));
}
if self.reloading > 0 {
text += &format!(" перезарядка {}с", self.reloading.div_ceil(20));
} else {
if let Some(m) = &spec.missile {
if self.kind == SamKind::S400 {
text += &format!(" ПВО {} · RM48U {} / {} ячеек", self.missiles, self.ground_rounds, self.cells());
if self.ground_return { text += " · ожидает вывоза RM48U"; }
} else {
text += &format!(" ракеты {}/{}", self.missiles, m.magazine);
}
}
if spec.gun.is_some() {
text += &format!(" очереди {}", self.bursts);
}
}
text
} }
} }
@@ -1302,6 +1443,8 @@ pub struct Sim {
/// The next blast's id (separate from `next`, so the other units' ids stay as they were). /// The next blast's id (separate from `next`, so the other units' ids stay as they were).
blast_seq: u32, blast_seq: u32,
next: u32, next: u32,
/// The optical probe sequence: a ready post is served oldest-probe first (fair queue, #138).
optical_seq: u64,
/// The combat randomness: what is rolled for aim, hits, damage and raids. Drawing, sound and camera never /// The combat randomness: what is rolled for aim, hits, damage and raids. Drawing, sound and camera never
/// spend it (#85). /// spend it (#85).
pub rng: Rng, pub rng: Rng,
@@ -1376,6 +1519,18 @@ pub struct Sim {
pub tally: record::Tally, pub tally: record::Tally,
/// What the enemy has learned. /// What the enemy has learned.
intel: ew::Intel, intel: ew::Intel,
/// Reconnaissance flights and the partial picture they radioed home (#135).
recon: recon::Recon,
/// The smart enemy runs the legacy picks (#149's comparison runner): the two separate hint
/// lists and their old scales, the lifetime bearing tally with its fixed share, no mark
/// pricing and no refresh of the unreleased portion. The light modes never read it.
pub smart_legacy: bool,
/// The bounded refresh of the last smart raid's unreleased portion (#149), while it waits.
refresh: Option<ew::Refresh>,
/// Aims the refresh has re-chosen (#149; diagnostics).
refresh_applied: u32,
/// The bearing picker's last decision and its typed reason (#149).
bearing: ew::BearingReport,
/// Night: guns need light (the mod sets it from the game's clock). /// Night: guns need light (the mod sets it from the game's clock).
pub night: bool, pub night: bool,
/// The long fires at crash and impact points (#52). /// The long fires at crash and impact points (#52).
@@ -1413,6 +1568,7 @@ impl Sim {
blasts: Vec::new(), blasts: Vec::new(),
blast_seq: 0, blast_seq: 0,
next: 1, next: 1,
optical_seq: 0,
rng: Rng::new(seed), rng: Rng::new(seed),
vis: Rng::new(seed ^ 0x5DEE_CE66_D1CE_4E5B), vis: Rng::new(seed ^ 0x5DEE_CE66_D1CE_4E5B),
fx_next: 0, fx_next: 0,
@@ -1452,6 +1608,11 @@ impl Sim {
recordings: 0, recordings: 0,
tally: record::Tally::default(), tally: record::Tally::default(),
intel: ew::Intel::default(), intel: ew::Intel::default(),
recon: recon::Recon::default(),
smart_legacy: false,
refresh: None,
refresh_applied: 0,
bearing: ew::BearingReport::default(),
night: false, night: false,
fires: fires::Fires::default(), fires: fires::Fires::default(),
day_time: None, day_time: None,
@@ -1473,6 +1634,16 @@ impl Sim {
self.next * PARTS self.next * PARTS
} }
/// The bearing picker's last decision and its typed reason (#149; diagnostics).
pub fn bearing_report(&self) -> ew::BearingReport {
self.bearing
}
/// Aims the bounded refresh of the unreleased portion has re-chosen (#149; diagnostics).
pub fn refresh_applied(&self) -> u32 {
self.refresh_applied
}
/// What a system's camera follows: its guns' or missiles' target, else what its missiles in /// What a system's camera follows: its guns' or missiles' target, else what its missiles in
/// flight are after. /// flight are after.
pub fn watched(&self, sam: &Sam) -> Option<&Drone> { pub fn watched(&self, sam: &Sam) -> Option<&Drone> {
@@ -1482,6 +1653,12 @@ impl Sim {
{ {
return self.drones.iter().find(|d| d.id == id); return self.drones.iter().find(|d| d.id == id);
} }
// An optical post has no track: its camera looks where it last saw the contact in clear
// sight, and nowhere at all while it has not seen it (#136).
if sam.kind == SamKind::Optical {
let (id, _) = sam.optical.seen(self.tick)?;
return self.drones.iter().find(|d| d.id == id);
}
let id = sam let id = sam
.gun_target .gun_target
.or(sam.target) .or(sam.target)
@@ -1497,6 +1674,9 @@ impl Sim {
{ {
return Some(self.watched(sam).map_or(at, |d| d.pos)); return Some(self.watched(sam).map_or(at, |d| d.pos));
} }
if sam.kind == SamKind::Optical {
return sam.optical.seen(self.tick).map(|(_, p)| p);
}
self.watched(sam).map(|d| d.pos) self.watched(sam).map(|d| d.pos)
} }
@@ -1555,6 +1735,8 @@ impl Sim {
self.plan = None; self.plan = None;
self.retargets.clear(); self.retargets.clear();
self.known_relief = None; self.known_relief = None;
self.recon.clear_sorties();
self.refresh = None;
self.wave = None; self.wave = None;
// Ammunition still to cook off, flares in the sky. // Ammunition still to cook off, flares in the sky.
self.later.clear(); self.later.clear();
@@ -1593,23 +1775,27 @@ impl Sim {
}); });
} }
/// One game tick. /// One game tick. The named phases are timed for the CPU profile (#147 step
/// 3.1); the timing reads no randomness and changes no decision.
pub fn step(&mut self, ground: &mut Ground, player: Option<DVec3>, out: &mut Out) { pub fn step(&mut self, ground: &mut Ground, player: Option<DVec3>, out: &mut Out) {
profile::begin_step();
self.tick += 1; self.tick += 1;
self.plan_step(Some(&mut *ground), out); profile::time(profile::PLAN, || self.plan_step(Some(&mut *ground), out));
self.adapt(); profile::time(profile::ADAPT, || self.adapt());
self.step_refresh(out);
self.step_settling(ground); self.step_settling(ground);
self.release_queue(ground, out); self.release_queue(ground, out);
self.begin_recording_if_active(); self.begin_recording_if_active();
self.step_drones(ground, player, out); profile::time(profile::DRONES, || self.step_drones(ground, player, out));
self.step_recon(out);
self.step_later(ground, player, out); self.step_later(ground, player, out);
self.step_moves(ground, out); profile::time(profile::MOVES, || self.step_moves(ground, out));
self.step_supply(out); self.step_supply(out);
self.step_ew(out); self.step_ew(out);
self.update_sight(ground); profile::time(profile::SIGHT, || self.update_sight(ground));
self.step_lights(ground, out); self.step_lights(ground, out);
self.prepare_ground_strikes(out); self.prepare_ground_strikes(out);
self.step_sams(ground, out); profile::time(profile::SAMS, || self.step_sams(ground, out));
self.step_missiles(ground, out); self.step_missiles(ground, out);
self.step_strikes(ground, player, out); self.step_strikes(ground, player, out);
self.step_fx(ground, out); self.step_fx(ground, out);
@@ -1618,9 +1804,10 @@ impl Sim {
self.step_wrecks(out); self.step_wrecks(out);
self.step_fires(ground, out); self.step_fires(ground, out);
self.report_wave(out); self.report_wave(out);
self.record(); profile::time(profile::RECORD, || self.record());
let now = self.tick; let now = self.tick;
self.blasts.retain(|b| now - b.start < b.life as u64); self.blasts.retain(|b| now - b.start < b.life as u64);
profile::end_step();
} }
// ------------------------------------------------ drones // ------------------------------------------------ drones
@@ -2236,7 +2423,7 @@ impl Sim {
if self.hold { if self.hold {
for i in 0..self.sams.len() { for i in 0..self.sams.len() {
if self.sams[i].alive() && !self.sams[i].moving() { if self.sams[i].alive() && !self.sams[i].moving() && self.sams[i].kind != SamKind::Optical {
self.sams[i].state = SamState::Hold; self.sams[i].state = SamState::Hold;
} }
self.draw_sam(i, out); self.draw_sam(i, out);
@@ -2292,7 +2479,10 @@ impl Sim {
} }
if !self.sams[i].kind.armed() { if !self.sams[i].kind.armed() {
let sam = &mut self.sams[i]; let sam = &mut self.sams[i];
// An optical post's state is its optics' (#136), not the armed systems' search line.
if sam.kind != SamKind::Optical {
sam.state = SamState::Search; sam.state = SamState::Search;
}
// A searchlight's target is its beam's (step_lights): kept for its spot of light. // A searchlight's target is its beam's (step_lights): kept for its spot of light.
if sam.kind != SamKind::Light { if sam.kind != SamKind::Light {
retarget(&mut missile_on, sam.target.take(), None); retarget(&mut missile_on, sam.target.take(), None);
@@ -2314,7 +2504,7 @@ impl Sim {
let drone = |tr: &Track| drone_at.get(&tr.id).map(|&k| &self.drones[k]); let drone = |tr: &Track| drone_at.get(&tr.id).map(|&k| &self.drones[k]);
let claimed = |d: &Drone| why::claimed(d, &missile_on, had_target); let claimed = |d: &Drone| why::claimed(d, &missile_on, had_target);
let doc = &me.doctrine; let doc = &me.doctrine;
let needed = |d: &Drone| doc.needed(d); let needed = |tr: &Track, d: &Drone| doc.needed(d, tr.class);
let opts = why::Opts { last_chance: self.last_chance, far_shots: self.far_shots }; let opts = why::Opts { last_chance: self.last_chance, far_shots: self.far_shots };
let target = spec.missile.as_ref().map(|load| { let target = spec.missile.as_ref().map(|load| {
// A launcher with nothing to fire (reloading, empty, failed) claims no target: others take it. // A launcher with nothing to fire (reloading, empty, failed) claims no target: others take it.
@@ -2332,7 +2522,7 @@ impl Sim {
let stuck = me.held > why::HOLD_MAX; let stuck = me.held > why::HOLD_MAX;
let keep = had_target.filter(|t| !stuck && tracks.iter().any(|tr| tr.id == *t && basis(tr, 1.1, false).is_some())); let keep = had_target.filter(|t| !stuck && tracks.iter().any(|tr| tr.id == *t && basis(tr, 1.1, false).is_some()));
keep.or_else(|| { keep.or_else(|| {
let free = |tr: &Track| drone(tr).is_some_and(|d| claimed(d) < needed(d)); let free = |tr: &Track| drone(tr).is_some_and(|d| claimed(d) < needed(tr, d));
// Long shots only while nothing of the system's roles is in its normal reach. // Long shots only while nothing of the system's roles is in its normal reach.
let role_in_reach = !radars.is_empty() && tracks.iter().any(|tr| free(tr) && basis(tr, 1.0, true) == Some(why::Basis::Role)); let role_in_reach = !radars.is_empty() && tracks.iter().any(|tr| free(tr) && basis(tr, 1.0, true) == Some(why::Basis::Role));
tracks tracks
@@ -2381,7 +2571,10 @@ impl Sim {
} }
sam.target = target; sam.target = target;
} }
if let Some(gun_target) = gun_target { let gun_target = gun_target.flatten();
if gun_target.is_some() || had_gun.is_some() {
// A track that stopped being a candidate is let go (a class estimated out of the
// roles since it was taken, #133, included): the gun must not keep firing at it.
retarget(&mut guns_on, had_gun, gun_target); retarget(&mut guns_on, had_gun, gun_target);
self.sams[i].gun_target = gun_target; self.sams[i].gun_target = gun_target;
} }
@@ -2417,13 +2610,14 @@ impl Sim {
} else { } else {
SamState::Search SamState::Search
}; };
// Nothing to fire at: the mount watches the nearest track of its classes (a reaction a turn // Nothing to fire at: the mount watches the nearest track of its classes (by the class
// shorter), else it goes back to the rest position, under the drive's limits like any other turn. // the network estimates, the unknown among them: a reaction a turn shorter), else it
// goes back to the rest position, under the drive's limits like any other turn.
let (mount, _) = sam.mount(); let (mount, _) = sam.mount();
let watch = sam let watch = sam
.tracks .tracks
.iter() .iter()
.filter(|tr| tr.age(now) <= sight::MISSILE_AGE && drone_at.get(&tr.id).is_some_and(|&k| roles & self.drones[k].kind.spec().class.bit() != 0 && self.drones[k].alive())) .filter(|tr| tr.age(now) <= sight::MISSILE_AGE && tr.class.in_roles(roles) && drone_at.get(&tr.id).is_some_and(|&k| self.drones[k].alive()))
.min_by(|a, b| a.est(now).distance(mount).total_cmp(&b.est(now).distance(mount))) .min_by(|a, b| a.est(now).distance(mount).total_cmp(&b.est(now).distance(mount)))
.map(|tr| why::aim_wants(mount, tr.est(now), tr.vel, spec.gun.as_ref().map_or(5.0, |g| g.shell))); .map(|tr| why::aim_wants(mount, tr.est(now), tr.vel, spec.gun.as_ref().map_or(5.0, |g| g.shell)));
match (watch, spec.family) { match (watch, spec.family) {
+268
View File
@@ -0,0 +1,268 @@
//! The planner's one public observation (#149): a disclosure `Contact` and a recon `Mark` are
//! two channels hinting at the same game objects, on two different scales. This module projects
//! both into a single [`Observation`] — an area, a channel, an age, a confidence and the public
//! game features — and matches them by those public features alone: a mark whose area holds a
//! contact's fix and whose observed category agrees is the same hint, not a second target.
//!
//! A match is a belief, never a fact: it is made only on an exact public category agreement and
//! area overlap, it is flagged (`matched`), and it invents nothing — the contact keeps the kind
//! and place it was observed with, the mark only adds what it publicly saw (a refined radar role,
//! a fresher look). A coarse `Unknown` mark or a contradicting category is *not* matched: it stays
//! a separate hint. The observer's truth map and the units' real ids play no part here.
use super::*;
/// A contact fix this far inside a mark's area (on top of its radius) reads as the same public
/// hint. The fix is exact, the area is coarse: the slack is the cell jitter a report carries.
const MATCH_SLACK: f64 = 8.0;
/// One public hint about one game object, from either channel (#149). There is no health,
/// magazine, link, hidden switch or true place in it: `kind` is `Some` only for a disclosure
/// contact, whose type was identified at the observation; a mark carries its coarse category.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Observation {
/// The hint's public id: a contact's id, or a mark's synthetic one. Never a matched unit's truth.
pub id: u32,
/// The best public place: a contact's fix, or a mark's area centre.
pub at: DVec3,
/// 0 for an exact fix; the area's radius for a mark.
pub radius: f64,
/// The channel that showed it last: flyby, emission, jamming or launch.
pub channel: recon::Source,
/// The tick of the observation this hint rests on.
pub observed: u64,
pub category: recon::Category,
/// A radar's role, once a refined look told it.
pub role: Option<battery::RadarRole>,
/// The type identified at a disclosure observation; `None` for a recon mark.
pub kind: Option<SamKind>,
pub quality: recon::Quality,
/// A second public hint agreed by area and category. A belief for the diagnostic, not a fact.
pub matched: bool,
}
impl Observation {
pub fn age(&self, now: u64) -> u64 {
now.saturating_sub(self.observed)
}
pub fn confidence(&self, now: u64) -> Confidence {
ew::confidence_for_age(self.age(now))
}
/// An exact disclosure fix, rather than a coarse area.
pub fn exact(&self) -> bool {
self.radius == 0.0
}
pub fn live(&self, now: u64) -> bool {
self.age(now) < ew::CONTACT_TTL
}
/// The one ranking scale both channels share (#149): the mark's priority parts (freshness,
/// quality, observed role) plus a small premium for being a fix rather than an area.
pub fn rank(&self, now: u64) -> u8 {
let (f, q, r) = recon::priority_parts(self.confidence(now), self.quality, self.category, self.role);
f * 4 + q * 3 + r + u8::from(self.exact()) * 3
}
}
/// The disclosure channel in the one scale the marks already use.
pub(super) fn channel_of(seen: ew::Seen) -> recon::Source {
match seen {
ew::Seen::Launch => recon::Source::Launch,
ew::Seen::Emission => recon::Source::Emission,
ew::Seen::Jamming => recon::Source::Jamming,
}
}
/// Projects contacts and marks into one list of public hints, best first. A mark is matched to a
/// contact only by public features (area overlap and an exact category agreement); a matched mark
/// is consumed — the object is one hint, priced and assigned once. Unmatched marks stand as areas.
pub(super) fn merge(contacts: &[ew::Contact], marks: &[recon::Mark], now: u64) -> Vec<Observation> {
let mut out: Vec<Observation> = contacts
.iter()
.filter(|c| c.live(now))
.map(|c| Observation {
id: c.id,
at: c.at,
radius: 0.0,
channel: channel_of(c.seen),
observed: c.tick,
category: recon::Category::of(c.kind),
role: None,
kind: Some(c.kind),
quality: recon::Quality::Refined,
matched: false,
})
.collect();
let mut areas = Vec::new();
for m in marks.iter().filter(|m| m.live(now)) {
let hit = out.iter_mut().find(|o| {
o.kind.is_some()
&& m.category != recon::Category::Unknown
&& m.category == o.category
&& (m.role.is_none() || o.category == recon::Category::Radar)
&& horizontal(o.at - m.area).length() <= m.radius + MATCH_SLACK
});
match hit {
Some(o) => {
// The match is public evidence, not truth: the fresher look and the refined role
// are what the mark itself saw; the contact's kind and fix are never rewritten.
o.matched = true;
if m.observed > o.observed {
o.observed = m.observed;
o.channel = m.source;
}
if o.category == recon::Category::Radar && m.role.is_some() {
o.role = m.role;
}
}
None => areas.push(Observation {
id: m.id,
at: m.area,
radius: m.radius,
channel: m.source,
observed: m.observed,
category: m.category,
role: m.role,
kind: None,
quality: m.quality,
matched: false,
}),
}
}
out.extend(areas);
out.sort_by(|a, b| b.rank(now).cmp(&a.rank(now)).then(b.observed.cmp(&a.observed)).then(a.id.cmp(&b.id)));
out
}
/// The small game policy (#149): which observed categories a kind is worth turning onto. One
/// place for the fit both the plan's picks and the adaptive assignments read — no hidden state,
/// only the public category and the kind's published role.
pub(super) fn fits(kind: DroneKind, category: recon::Category) -> bool {
use recon::Category as C;
match kind {
DroneKind::Lancet => matches!(category, C::Gun | C::Launcher | C::Ew),
DroneKind::Kh22 | DroneKind::Zircon => matches!(category, C::Radar | C::Launcher | C::Ew),
DroneKind::Iskander | DroneKind::Kinzhal => matches!(category, C::Radar | C::Launcher),
DroneKind::Shahed | DroneKind::Geran3 => matches!(category, C::Radar | C::Launcher | C::Gun | C::Ew),
_ => false,
}
}
/// The public worst-case envelope of a category: the furthest missile reach and gun range any
/// published kind of that category has, for this drone at this height. What a mark's area may
/// hold is priced by the catalog, never by a hidden unit's actual load (#149).
pub(super) fn category_envelope(category: recon::Category) -> (f64, f64, f64) {
let mut lo = f64::INFINITY;
let mut hi = 0.0f64;
let mut gun = 0.0f64;
for k in SamKind::ALL {
if recon::Category::of(k) != category {
continue;
}
let sp = k.spec();
if let Some(m) = &sp.missile {
lo = lo.min(m.min);
hi = hi.max(m.max);
}
if let Some(g) = &sp.gun {
gun = gun.max(g.range);
}
}
(lo.min(hi), hi, gun)
}
/// The published reach of the strongest radar kind, for a mark that only says "a radar is here".
pub(super) fn radar_envelope(drone: DroneKind, height: f64) -> f64 {
SamKind::ALL
.into_iter()
.filter(|k| recon::Category::of(*k) == recon::Category::Radar)
.map(|k| ew::published_reach(k, drone, height))
.fold(0.0, f64::max)
}
#[cfg(test)]
mod tests {
use super::*;
fn contact(id: u32, kind: SamKind, at: DVec3, tick: u64) -> ew::Contact {
ew::Contact { id, kind, at, tick, seen: ew::Seen::Emission, emission: Some(tick), destroyed: None, launches: 0 }
}
fn mark(id: u32, at: DVec3, category: recon::Category, observed: u64) -> recon::Mark {
recon::Mark {
id,
area: at,
radius: recon::COARSE_AREA,
category,
role: None,
source: recon::Source::Flyby,
observed,
reported: observed,
quality: recon::Quality::Coarse,
looks: 1,
}
}
// #149: one object, two channels, one hint. A mark whose area holds the contact's fix and
// whose category agrees is matched and consumed — not a second target. The match reads only
// public features: two marks of different hidden truths but the same public area/category
// both fold into the one contact.
#[test]
fn a_matching_mark_is_one_hint_not_two() {
let at = DVec3::new(100.0, 70.0, 0.0);
let c = contact(16, SamKind::Radar, at, 100);
let m1 = mark(recon::ID_BASE + 1, at + DVec3::new(20.0, 0.0, 0.0), recon::Category::Radar, 120);
let m2 = mark(recon::ID_BASE + 2, at + DVec3::new(-30.0, 0.0, 10.0), recon::Category::Radar, 130);
let obs = merge(&[c], &[m1, m2], 200);
assert_eq!(obs.len(), 1, "the same public object stayed two hints");
assert!(obs[0].matched && obs[0].exact() && obs[0].kind == Some(SamKind::Radar));
assert_eq!(obs[0].observed, 130, "the fresher public look was not taken");
assert_eq!(obs[0].id, 16, "the hint kept the mark's synthetic id over the contact's");
}
// #149: an unconfirmed match is not a fact. A coarse Unknown mark, a contradicting category,
// or an area that does not hold the fix stays a separate hint — nothing is merged on a guess.
#[test]
fn an_unconfirmed_match_stays_separate() {
let at = DVec3::new(100.0, 70.0, 0.0);
let c = contact(16, SamKind::Radar, at, 100);
let unknown = mark(recon::ID_BASE + 1, at, recon::Category::Unknown, 120);
let wrong = mark(recon::ID_BASE + 2, at, recon::Category::Launcher, 120);
let far = mark(recon::ID_BASE + 3, at + DVec3::new(400.0, 0.0, 0.0), recon::Category::Radar, 120);
let obs = merge(&[c], &[unknown, wrong, far], 200);
assert_eq!(obs.len(), 4, "a weak match was treated as a fact");
assert!(obs.iter().filter(|o| o.kind.is_some()).all(|o| !o.matched));
// A refined role is public only for a radar; a launcher mark never lends one.
let mut radar = mark(recon::ID_BASE + 4, at, recon::Category::Radar, 140);
radar.quality = recon::Quality::Refined;
radar.role = Some(battery::RadarRole::Engagement);
let obs = merge(&[c], &[radar], 200);
assert_eq!(obs.len(), 1);
assert_eq!(obs[0].role, Some(battery::RadarRole::Engagement));
}
// #149: one scale. A fresh confirmed fix outranks an old doubtful area; a refined big-role
// mark outranks a coarse modest one of the same age; the order never reads an id or a truth.
#[test]
fn the_rank_is_one_public_scale() {
let fresh = contact(16, SamKind::Radar, DVec3::ZERO, 190);
let old = mark(recon::ID_BASE + 1, DVec3::X * 500.0, recon::Category::Launcher, 0);
let obs = merge(&[fresh], &[old], 200);
assert_eq!(obs[0].id, 16, "a fresh fix did not lead an old area");
let mut big = mark(recon::ID_BASE + 2, DVec3::X * 900.0, recon::Category::Radar, 190);
big.quality = recon::Quality::Refined;
big.role = Some(battery::RadarRole::Engagement);
let modest = mark(recon::ID_BASE + 3, DVec3::X * 1300.0, recon::Category::Radar, 190);
let obs = merge(&[], &[modest, big], 200);
assert_eq!(obs[0].id, big.id, "the bigger observed role did not lead");
assert!(obs[0].rank(200) > obs[1].rank(200));
}
// #149: the policy fit is the public category, the same for the plan and the adaptive picks.
#[test]
fn the_fit_is_the_public_category() {
assert!(fits(DroneKind::Lancet, recon::Category::Gun));
assert!(!fits(DroneKind::Lancet, recon::Category::Radar));
assert!(fits(DroneKind::Kh22, recon::Category::Radar));
assert!(!fits(DroneKind::Iskander, recon::Category::Gun));
assert!(!fits(DroneKind::Gerbera, recon::Category::Launcher));
}
}
File diff suppressed because it is too large Load Diff
+2 -2
View File
@@ -18,9 +18,9 @@ impl SamKind {
Family::Truck => 10, Family::Truck => 10,
} }
} }
/// A depot doesn't drive. /// A depot and a fixed optical post don't drive.
pub fn mobile(self) -> bool { pub fn mobile(self) -> bool {
self != SamKind::Depot !matches!(self, SamKind::Depot | SamKind::Optical)
} }
} }
+149
View File
@@ -0,0 +1,149 @@
//! Per-phase wall time of `Sim::step` (#147 step 3.1): observation only, never
//! a combat input. The simulation stays SDK-independent (it is also built as
//! `airdef-core`), so the adapter installs the host clock
//! (`game.monotonic-nanos`, API level 32) with [`set_clock`] before the first
//! tick; native tests fall back to `std::time::Instant`. The counters are
//! fixed-size and per-thread (a mod instance is single-threaded); timing reads
//! no randomness and changes no decision, so the ordered combat trace is
//! identical with or without it.
use std::cell::RefCell;
/// The named phases of `Sim::step`, as indices into the counters.
pub const PLAN: usize = 0;
pub const ADAPT: usize = 1;
pub const DRONES: usize = 2;
pub const MOVES: usize = 3;
pub const SIGHT: usize = 4;
pub const SAMS: usize = 5;
pub const RECORD: usize = 6;
const NAMED: usize = 7;
/// The phases' report names, in index order.
const NAMES: [&str; NAMED] = ["plan", "adapt", "drones", "moves", "sight", "sams", "record"];
#[derive(Default)]
struct Prof {
total_ns: [u64; NAMED],
max_ns: [u64; NAMED],
steps: u64,
step_ns: u64,
step_max_ns: u64,
other_ns: u64,
other_max_ns: u64,
cur_start: u64,
cur_named: u64,
}
thread_local! {
static PROF: RefCell<Prof> = const { RefCell::new(Prof {
total_ns: [0; NAMED],
max_ns: [0; NAMED],
steps: 0,
step_ns: 0,
step_max_ns: 0,
other_ns: 0,
other_max_ns: 0,
cur_start: 0,
cur_named: 0,
}) };
}
/// The clock the adapter installs (the host's monotonic import); none in native
/// tests, which use the process clock below.
static CLOCK: std::sync::OnceLock<fn() -> u64> = std::sync::OnceLock::new();
/// Installs the monotonic clock, once, before the first timed step.
pub fn set_clock(f: fn() -> u64) {
let _ = CLOCK.set(f);
}
fn now_ns() -> u64 {
match CLOCK.get() {
Some(f) => f(),
None => native_now_ns(),
}
}
#[cfg(not(target_arch = "wasm32"))]
fn native_now_ns() -> u64 {
use std::time::Instant;
static EPOCH: std::sync::OnceLock<Instant> = std::sync::OnceLock::new();
EPOCH.get_or_init(Instant::now).elapsed().as_nanos() as u64
}
/// Only reached if the adapter never installed a clock; the mod always does in
/// `init`, so the counters stay zero rather than reading an unsupported clock.
#[cfg(target_arch = "wasm32")]
fn native_now_ns() -> u64 {
0
}
/// Marks the start of one `Sim::step`.
pub fn begin_step() {
let start = now_ns();
PROF.with(|p| {
let p = &mut *p.borrow_mut();
p.cur_start = start;
p.cur_named = 0;
});
}
/// Times one named phase: its wall time joins the phase's counters and the
/// step's named sum, so `end_step` can derive the untimed remainder.
pub fn time<T>(phase: usize, f: impl FnOnce() -> T) -> T {
let start = now_ns();
let out = f();
let dt = now_ns().saturating_sub(start);
PROF.with(|p| {
let p = &mut *p.borrow_mut();
p.total_ns[phase] += dt;
p.max_ns[phase] = p.max_ns[phase].max(dt);
p.cur_named += dt;
});
out
}
/// Marks the end of one `Sim::step`: the whole step and its untimed remainder.
pub fn end_step() {
let end = now_ns();
PROF.with(|p| {
let p = &mut *p.borrow_mut();
let total = end.saturating_sub(p.cur_start);
let other = total.saturating_sub(p.cur_named);
p.steps += 1;
p.step_ns += total;
p.step_max_ns = p.step_max_ns.max(total);
p.other_ns += other;
p.other_max_ns = p.other_max_ns.max(other);
});
}
/// Clears the counters (a new world opens).
pub fn reset() {
PROF.with(|p| *p.borrow_mut() = Prof::default());
}
/// Parseable chat lines for `/airdef stats`: each `PROFILE key=value ...` with
/// millisecond totals and per-step maxima (three decimals) and the step count.
/// `other` is the whole step minus the named phases. Split to stay under the
/// game's 256-character chat line; the bench merges every `PROFILE` line.
pub fn report() -> Vec<String> {
PROF.with(|p| {
let p = p.borrow();
let ms = |ns: u64| ns as f64 / 1e6;
let phase = |i: usize| {
format!(
"{}_ms={:.3} {}_max_ms={:.3}",
NAMES[i], ms(p.total_ns[i]), NAMES[i], ms(p.max_ns[i]),
)
};
vec![
format!(
"PROFILE steps={} step_ms={:.3} step_max_ms={:.3} other_ms={:.3} other_max_ms={:.3}",
p.steps, ms(p.step_ns), ms(p.step_max_ns), ms(p.other_ns), ms(p.other_max_ns),
),
format!("PROFILE {} {} {} {}", phase(0), phase(1), phase(2), phase(3)),
format!("PROFILE {} {} {}", phase(4), phase(5), phase(6)),
]
})
}
+226 -31
View File
@@ -100,6 +100,9 @@ struct Item {
/// A raid being planned: its drones, the prices and routes so far, and the planned ones. /// A raid being planned: its drones, the prices and routes so far, and the planned ones.
pub(super) struct Plan { pub(super) struct Plan {
grid: Grid, grid: Grid,
/// The one knowledge version the whole order was chosen on and is routed on (#146): every
/// kind's prices are worked out on it, whenever the budget reaches that kind.
knowledge: ew::KnowledgeSnapshot,
prices: HashMap<DroneKind, Vec<f32>>, prices: HashMap<DroneKind, Vec<f32>>,
routes: HashMap<(DroneKind, i32, i32, i32), Vec<DVec3>>, routes: HashMap<(DroneKind, i32, i32, i32), Vec<DVec3>>,
items: Vec<Item>, items: Vec<Item>,
@@ -124,6 +127,23 @@ pub(super) struct Plan {
mapped: bool, mapped: bool,
} }
impl Plan {
/// What the plan holds, about: the grid's heights, prices, routes and items (see `sim::memory`).
pub(super) fn bytes(&self) -> usize {
use super::memory::{map_bytes, vec_bytes};
map_bytes(self.prices.len(), std::mem::size_of::<DroneKind>() + std::mem::size_of::<Vec<f32>>())
+ self.prices.values().map(|p| vec_bytes(p)).sum::<usize>()
+ map_bytes(self.routes.len(), std::mem::size_of::<(DroneKind, i32, i32, i32)>() + std::mem::size_of::<Vec<DVec3>>())
+ self.routes.values().map(|r| vec_bytes(r)).sum::<usize>()
+ vec_bytes(&self.items)
+ vec_bytes(&self.done)
+ vec_bytes(&self.wants)
+ vec_bytes(&self.heights)
+ vec_bytes(&self.unanswered)
+ self.knowledge.bytes()
}
}
/// The raid in progress: the counts at its start, for the report. /// The raid in progress: the counts at its start, for the report.
pub(super) struct WaveStats { pub(super) struct WaveStats {
kills: u32, kills: u32,
@@ -280,10 +300,14 @@ impl Sim {
return 0; return 0;
} }
let smart = order.aim == Aim::Smart; let smart = order.aim == Aim::Smart;
// The planner's picture of the layout: one snapshot for the whole order. It is // The planner's picture of the layout: one snapshot for the whole order, kept in the plan
// read-only while the plan is built, and taking it per drone made a big second order // (#146). It is read-only while the plan is built, and taking it per drone made a big second
// quadratic in the force's size (#122); a map of contacts makes it linear in them (#127). // order quadratic in the force's size (#122); a map of contacts makes it linear in them (#127).
let picture = self.picture_of_defences(); let knowledge = self.knowledge_now();
let picture = &knowledge.contacts;
// The partial picture the recon flights have radioed home. It is memory, not the
// force: a mark has an area, a category and an age, never a unit's exact place (#135).
let leads = &knowledge.marks;
// A smart enemy comes from where its raids got through best. // A smart enemy comes from where its raids got through best.
let bearing = if smart { self.best_bearing() } else { self.rng.f() * TAU }; let bearing = if smart { self.best_bearing() } else { self.rng.f() * TAU };
// The raid's sides (1, 2, or 4-5): its launch sites go there (#100). // The raid's sides (1, 2, or 4-5): its launch sites go there (#100).
@@ -296,7 +320,7 @@ impl Sim {
let grid = Grid { min: centre - DVec3::new(span, 0.0, span), cell, size: (2.0 * span / cell) as i32 + 1 }; let grid = Grid { min: centre - DVec3::new(span, 0.0, span), cell, size: (2.0 * span / cell) as i32 + 1 };
let mut items = Vec::new(); let mut items = Vec::new();
// A smart raid goes for the radars too (a few strikers each); the others pick as they always did. // A smart raid goes for the radars too (a few strikers each); the others pick as they always did.
let radar_jobs = if smart { self.radar_strikes(&order.kinds, &picture) } else { Vec::new() }; let radar_jobs = if smart { self.radar_strikes(&order.kinds, picture, leads) } else { Vec::new() };
let mut index = 0usize; let mut index = 0usize;
for (group, &(kind, count)) in order.kinds.iter().enumerate() { for (group, &(kind, count)) in order.kinds.iter().enumerate() {
let spec = kind.spec(); let spec = kind.spec();
@@ -312,7 +336,7 @@ impl Sim {
index += 1; index += 1;
let (target, at_sam) = match job { let (target, at_sam) = match job {
Some((at, id)) => (at, Some(id)), Some((at, id)) => (at, Some(id)),
None => self.choose_target(kind, object, order.aim, &picture), None => self.choose_target(kind, object, order.aim, &picture, &leads),
}; };
let aim = target + DVec3::new(self.rng.s() * 4.0, 0.0, self.rng.s() * 4.0); let aim = target + DVec3::new(self.rng.s() * 4.0, 0.0, self.rng.s() * 4.0);
let dist = spec.ballistic.map_or(order.dist, |far| far.max(order.dist)) + self.rng.f() * 50.0; let dist = spec.ballistic.map_or(order.dist, |far| far.max(order.dist)) + self.rng.f() * 50.0;
@@ -323,7 +347,11 @@ impl Sim {
// The plan's own decision, recorded as such (#127): a radar job is SEAD, a unit // The plan's own decision, recorded as such (#127): a radar job is SEAD, a unit
// chosen for the raid is the plan's objective, anything else is a marked object. // chosen for the raid is the plan's objective, anything else is a marked object.
if let Some(id) = at_sam { if let Some(id) = at_sam {
let confidence = picture.iter().find(|c| c.id == id).map(|c| c.confidence(self.tick)); let confidence = picture
.iter()
.find(|c| c.id == id)
.map(|c| c.confidence(knowledge.tick))
.or_else(|| leads.iter().find(|c| c.id == id).map(|c| c.confidence(knowledge.tick)));
d.intent = if job.is_some() { ew::Intent::Sead } else { ew::Intent::Plan }; d.intent = if job.is_some() { ew::Intent::Sead } else { ew::Intent::Plan };
d.aim = confidence.map_or_else(|| ew::Aim::point(self.tick), |c| ew::Aim::unit(id, self.tick, c)); d.aim = confidence.map_or_else(|| ew::Aim::point(self.tick), |c| ew::Aim::unit(id, self.tick, c));
} else { } else {
@@ -345,6 +373,7 @@ impl Sim {
} }
self.plan = Some(Plan { self.plan = Some(Plan {
grid, grid,
knowledge,
prices: HashMap::new(), prices: HashMap::new(),
routes: HashMap::new(), routes: HashMap::new(),
items, items,
@@ -363,6 +392,11 @@ impl Sim {
waited: 0, waited: 0,
mapped: !smart, mapped: !smart,
}); });
// The smart enemy may send a small recon flight ahead of the strike -- physically in
// the air, not a pause: the strike is planned while they fly (#135).
if smart {
self.start_recon(objects, bearing, order.dist, out);
}
// A raid without routes is ready at once. // A raid without routes is ready at once.
self.plan_step(None, out); self.plan_step(None, out);
total total
@@ -453,7 +487,7 @@ impl Sim {
None => { None => {
if !plan.prices.contains_key(&kind) { if !plan.prices.contains_key(&kind) {
let heights = (!plan.heights.is_empty()).then_some(plan.heights.as_slice()); let heights = (!plan.heights.is_empty()).then_some(plan.heights.as_slice());
let (p, cost) = self.price_grid_on(&plan.grid, kind, heights); let (p, cost) = self.price_grid_on(&plan.grid, kind, heights, &plan.knowledge);
work += cost; work += cost;
plan.prices.insert(kind, p); plan.prices.insert(kind, p);
} }
@@ -502,6 +536,13 @@ impl Sim {
if plan.smart && !plan.heights.is_empty() { if plan.smart && !plan.heights.is_empty() {
self.known_relief = Some(std::sync::Arc::new(ew::KnownRelief::new(plan.grid, std::mem::take(&mut plan.heights)))); self.known_relief = Some(std::sync::Arc::new(ew::KnownRelief::new(plan.grid, std::mem::take(&mut plan.heights))));
} }
// The bounded refresh moment for the unreleased portion (#149): a recon flight is still
// out, so a report may arrive while the drones wait to launch, and the plan's own picks
// may be re-aimed once on it. The deadline is absolute and the launches keep their times
// — no report never pauses the raid.
if plan.smart && !self.smart_legacy && !self.recon.sorties.is_empty() {
self.refresh = Some(ew::Refresh { deadline: self.tick + ew::REFRESH_WINDOW, reports: self.recon.reports });
}
self.wave = Some(WaveStats { self.wave = Some(WaveStats {
kills: self.kills, kills: self.kills,
hits: self.hits, hits: self.hits,
@@ -534,6 +575,13 @@ impl Sim {
self.plan.as_ref().map(|p| p.items.iter().map(|i| (i.d.aim.unit, i.d.intent)).collect()).unwrap_or_default() self.plan.as_ref().map(|p| p.items.iter().map(|i| (i.d.aim.unit, i.d.intent)).collect()).unwrap_or_default()
} }
/// The plan's grid, land, knowledge version and the prices worked out so far (#146; tests).
#[cfg(test)]
pub(super) fn plan_pricing(&self) -> Option<(Grid, Vec<f32>, ew::KnowledgeSnapshot, HashMap<DroneKind, Vec<f32>>)> {
let p = self.plan.as_ref()?;
Some((p.grid, p.heights.clone(), p.knowledge.clone(), p.prices.clone()))
}
/// A drone ready to fly from `from`, not yet in the sky. /// A drone ready to fly from `from`, not yet in the sky.
pub(super) fn make_drone(&mut self, kind: DroneKind, from: DVec3, dir: DVec3, target: DVec3) -> Drone { pub(super) fn make_drone(&mut self, kind: DroneKind, from: DVec3, dir: DVec3, target: DVec3) -> Drone {
let id = self.id(); let id = self.id();
@@ -579,13 +627,36 @@ impl Sim {
/// the last observed place and id for those that go for one. Each radar /// the last observed place and id for those that go for one. Each radar
/// gets two or three, the fast strikers first, and all together no more than about a quarter of the raid. /// gets two or three, the fast strikers first, and all together no more than about a quarter of the raid.
/// Only contacts the picture still trusts: a doubtful one (aged, never re-seen) is not worth a missile. /// Only contacts the picture still trusts: a doubtful one (aged, never re-seen) is not worth a missile.
pub(super) fn radar_strikes(&self, kinds: &[(DroneKind, u32)], picture: &[ew::Contact]) -> Vec<Option<(DVec3, u32)>> { pub(super) fn radar_strikes(&self, kinds: &[(DroneKind, u32)], picture: &[ew::Contact], leads: &[recon::Mark]) -> Vec<Option<(DVec3, u32)>> {
let mut radars: Vec<(u32, DVec3)> = picture // Radars the picture trusts, best first. The candidate ranks the one merged hint list on
// the single public scale (#149): a mark matched to a contact is not a second radar. The
// legacy mode keeps the two chains and their old scales. The order is the observed role,
// freshness and quality -- never the id (#135). Both lists are the order's own knowledge
// version, not a later picture (#146).
let now = self.tick;
let mut radars: Vec<(u8, u64, u32, DVec3)> = if self.smart_legacy {
picture
.iter() .iter()
.filter(|c| c.kind == SamKind::Radar && c.confidence(self.tick) >= ew::Confidence::Probable) .filter(|c| c.kind == SamKind::Radar && c.confidence(now) >= ew::Confidence::Probable)
.map(|c| (c.id, c.at)) .map(|c| {
.collect(); let seen = match c.confidence(now) {
radars.sort_by_key(|(id, _)| *id); ew::Confidence::Confirmed => 4,
ew::Confidence::Probable => 2,
ew::Confidence::Doubtful => 0,
};
(seen * 10 + 3, c.tick, c.id, c.at)
})
.chain(leads.iter().copied().filter(|m| m.category == recon::Category::Radar && m.confidence(now) >= ew::Confidence::Probable).map(|m| (m.priority(now), m.observed, m.id, m.area)))
.collect()
} else {
observe::merge(picture, leads, now)
.into_iter()
.filter(|o| o.category == recon::Category::Radar && o.confidence(now) >= ew::Confidence::Probable)
.map(|o| (o.rank(now), o.observed, o.id, o.at))
.collect()
};
radars.sort_by(|a, b| b.0.cmp(&a.0).then(b.1.cmp(&a.1)).then(a.2.cmp(&b.2)));
let radars: Vec<(u32, DVec3)> = radars.into_iter().map(|(_, _, id, at)| (id, at)).collect();
let flat: Vec<DroneKind> = kinds.iter().flat_map(|&(k, n)| std::iter::repeat_n(k, n as usize)).collect(); let flat: Vec<DroneKind> = kinds.iter().flat_map(|&(k, n)| std::iter::repeat_n(k, n as usize)).collect();
let mut jobs = vec![None; flat.len()]; let mut jobs = vec![None; flat.len()];
if radars.is_empty() { if radars.is_empty() {
@@ -609,8 +680,8 @@ impl Sim {
/// point and the unit's id. The planner has only the picture (#93, #127): what it knows of a /// point and the unit's id. The planner has only the picture (#93, #127): what it knows of a
/// unit is the last observation — the place seen then, the type identified then — never where /// unit is the last observation — the place seen then, the type identified then — never where
/// the unit actually is or what it has become since. /// the unit actually is or what it has become since.
fn choose_target(&mut self, kind: DroneKind, object: DVec3, aim: Aim, picture: &[ew::Contact]) -> (DVec3, Option<u32>) { fn choose_target(&mut self, kind: DroneKind, object: DVec3, aim: Aim, picture: &[ew::Contact], leads: &[recon::Mark]) -> (DVec3, Option<u32>) {
if picture.is_empty() || kind.spec().decoy || aim == Aim::Objects { if (picture.is_empty() && leads.is_empty()) || kind.spec().decoy || aim == Aim::Objects {
return (object, None); return (object, None);
} }
let pick = |list: &[ew::Contact], r: f64| -> Option<(DVec3, u32)> { let pick = |list: &[ew::Contact], r: f64| -> Option<(DVec3, u32)> {
@@ -622,7 +693,42 @@ impl Sim {
if aim == Aim::ObjectsAndSams { if aim == Aim::ObjectsAndSams {
return if roll < 0.33 { pick(picture, r).map_or((object, None), |(p, id)| (p, Some(id))) } else { (object, None) }; return if roll < 0.33 { pick(picture, r).map_or((object, None), |(p, id)| (p, Some(id))) } else { (object, None) };
} }
// Smart: each kind at what it is good against; what gave itself away first (a jamming // The candidate picks from the one merged hint list (#149): a matched mark is not a
// second target, and the fit is the small public policy, not a per-kind guess.
if !self.smart_legacy {
let obs = observe::merge(picture, leads, self.tick);
let pick_o = |list: &[&Observation], r: f64| -> Option<(DVec3, u32)> {
let o = list.get((r * list.len() as f64) as usize)?;
Some((o.at, o.id))
};
let jammers: Vec<&Observation> = obs.iter().filter(|o| o.category == recon::Category::Ew && o.channel == recon::Source::Jamming).collect();
if matches!(kind, DroneKind::Lancet | DroneKind::Kh22) && !jammers.is_empty() && roll < 0.6 {
if let Some((at, id)) = pick_o(&jammers, r) {
return (at, Some(id));
}
}
let guns: Vec<&Observation> = obs.iter().filter(|o| o.category == recon::Category::Gun || o.kind.is_some_and(|k| k.armed() && k.range() <= 300.0)).collect();
let long: Vec<&Observation> = obs.iter().filter(|o| o.category == recon::Category::Radar || o.kind.is_some_and(|k| k.range() >= 450.0)).collect();
let all: Vec<&Observation> = obs.iter().collect();
let choice = match kind {
DroneKind::Lancet if roll < 0.75 => pick_o(&guns, r).or_else(|| pick_o(&all, r)),
DroneKind::Kh22 | DroneKind::Zircon if roll < 0.45 => pick_o(&long, r),
DroneKind::Iskander | DroneKind::Kinzhal if roll < 0.3 => pick_o(&long, r),
DroneKind::Shahed | DroneKind::Geran3 if roll < 0.2 => pick_o(&all, r),
_ => None,
};
if let Some((at, id)) = choice {
return (at, Some(id));
}
// Nothing the kind's usual preference picked: an unmerged mark whose observed
// category fits is the next best reason to turn a strike off the object.
let fits: Vec<&Observation> = obs.iter().filter(|o| o.kind.is_none() && observe::fits(kind, o.category)).collect();
if let Some((at, id)) = pick_o(&fits, r) {
return (at, Some(id));
}
return (object, None);
}
// Legacy smart: each kind at what it is good against; what gave itself away first (a jamming
// station, a radar, a system that fired). // station, a radar, a system that fired).
let known_ew: Vec<ew::Contact> = picture.iter().copied().filter(|c| c.kind == SamKind::Ew).collect(); let known_ew: Vec<ew::Contact> = picture.iter().copied().filter(|c| c.kind == SamKind::Ew).collect();
if matches!(kind, DroneKind::Lancet | DroneKind::Kh22) && !known_ew.is_empty() && roll < 0.6 { if matches!(kind, DroneKind::Lancet | DroneKind::Kh22) && !known_ew.is_empty() && roll < 0.6 {
@@ -641,32 +747,43 @@ impl Sim {
DroneKind::Shahed | DroneKind::Geran3 if roll < 0.2 => pick(picture, r), DroneKind::Shahed | DroneKind::Geran3 if roll < 0.2 => pick(picture, r),
_ => None, _ => None,
}; };
choice.map_or((object, None), |(p, id)| (p, Some(id))) if let Some((p, id)) = choice {
return (p, Some(id));
}
// Nothing disclosed and nothing the kind's usual preference picked: a recon mark
// whose observed role fits is the next best reason to turn a strike off the object.
if let Some(m) = recon_pick(kind, leads, r) {
return (m.area, Some(m.id));
}
(object, None)
} }
/// The price of each cell of `grid` for this kind flying low: 1, and much more where a /// The price of each cell of `grid` for this kind flying low: 1, and much more where a
/// system sees it there (its radar's reach for it, the land) and can shoot it. /// system sees it there (its radar's reach for it, the land) and can shoot it.
#[cfg(test)] #[cfg(test)]
pub(super) fn price_grid(&self, grid: &Grid, kind: DroneKind) -> (Vec<f32>, usize) { pub(super) fn price_grid(&self, grid: &Grid, kind: DroneKind) -> (Vec<f32>, usize) {
self.price_grid_on(grid, kind, None) self.price_grid_on(grid, kind, None, &self.knowledge_now())
} }
/// The same over the picture this moment holds: a smart plan's own prices are priced on the /// The same over a knowledge version given explicitly: a smart plan's prices are priced on the
/// picture the plan was ordered with (#127). Later observations change nothing here. /// snapshot the plan was ordered with (#127, #146), whenever the budget reaches this kind.
pub(super) fn price_grid_on(&self, grid: &Grid, kind: DroneKind, land: Option<&[f32]>) -> (Vec<f32>, usize) { /// Later observations change nothing here.
self.price_grid_known(grid, kind, land, &self.picture_of_defences()) pub(super) fn price_grid_on(&self, grid: &Grid, kind: DroneKind, land: Option<&[f32]>, knowledge: &ew::KnowledgeSnapshot) -> (Vec<f32>, usize) {
self.price_grid_known(grid, kind, land, knowledge)
} }
/// The same over a picture of the defences: a retarget is priced on the picture its target was /// The same over a snapshot of the defences: a retarget is priced on the knowledge its target was
/// chosen from, so the jobs of one adaptive tick do not each see a different world (#127). Every /// chosen from, so the jobs of one adaptive tick do not each see a different world (#127), and a
/// job reached on a later tick still ages its contacts at its own version's tick (#146). Every
/// capability read here is the contact's published kind and the contact's own observations — /// capability read here is the contact's published kind and the contact's own observations —
/// never the unit's actual switch settings, damage, roles, link health or magazine. /// never the unit's actual switch settings, damage, roles, link health or magazine.
pub(super) fn price_grid_known(&self, grid: &Grid, kind: DroneKind, land: Option<&[f32]>, picture: &[ew::Contact]) -> (Vec<f32>, usize) { pub(super) fn price_grid_known(&self, grid: &Grid, kind: DroneKind, land: Option<&[f32]>, knowledge: &ew::KnowledgeSnapshot) -> (Vec<f32>, usize) {
let mut cost = 0; let mut cost = 0;
let spec = kind.spec(); let spec = kind.spec();
let height = spec.clearance.max(6.0); let height = spec.clearance.max(6.0);
let n = grid.size; let n = grid.size;
let now = self.tick; let now = knowledge.tick;
let picture = &knowledge.contacts;
let mut prices = vec![1.0f32; (n * n) as usize]; let mut prices = vec![1.0f32; (n * n) as usize];
// Known jamming stations: drones that navigate by satellite keep away. // Known jamming stations: drones that navigate by satellite keep away.
if kind.jammable() { if kind.jammable() {
@@ -697,6 +814,17 @@ impl Sim {
.filter(|d| d.kind == SamKind::Radar && d.id != c.id && d.at.distance(pos) <= sight::LINK) .filter(|d| d.kind == SamKind::Radar && d.id != c.id && d.at.distance(pos) <= sight::LINK)
.map(|d| ew::published_reach(d.kind, kind, height)) .map(|d| ew::published_reach(d.kind, kind, height))
.fold(0.0, f64::max); .fold(0.0, f64::max);
// A trusted radar mark near the observed place feeds the network too (#149): the
// strongest published radar reach, since the mark does not name the kind.
let net = if self.smart_legacy {
net
} else {
knowledge.marks
.iter()
.filter(|m| m.category == recon::Category::Radar && m.confidence(now) >= ew::Confidence::Probable && m.area.distance(pos) <= sight::LINK)
.map(|_| observe::radar_envelope(kind, height))
.fold(net, f64::max)
};
let (hi, gun) = (hi.min(own.max(net)), gun.min(own)); let (hi, gun) = (hi.min(own.max(net)), gun.min(own));
let far = hi.max(gun); let far = hi.max(gun);
// Only the cells round it. // Only the cells round it.
@@ -719,6 +847,53 @@ impl Sim {
} }
} }
} }
// The marks the contacts do not already stand for (#149): an area is priced by its public
// category's published envelope, weighted by the confidence the age alone gives. A mark
// matched to a contact is one hint and was priced through the contact above.
if !self.smart_legacy {
for o in knowledge.observations().into_iter().filter(|o| o.kind.is_none() && o.confidence(now) >= ew::Confidence::Probable) {
let scale: f32 = if o.confidence(now) == ew::Confidence::Confirmed { 1.0 } else { 0.5 };
let pos = o.at;
match o.category {
recon::Category::Ew if kind.jammable() => {
let reach = ew::EW_RADIUS + o.radius;
let (ci, cj) = grid.index(pos);
let r = (reach / grid.cell).ceil() as i32;
for i in (ci - r).max(0)..=(ci + r).min(n - 1) {
for j in (cj - r).max(0)..=(cj + r).min(n - 1) {
cost += 1;
if horizontal(grid.centre((i, j), pos.y) - pos).length() < reach {
prices[(i * n + j) as usize] += 12.0 * scale;
}
}
}
}
recon::Category::Launcher | recon::Category::Gun => {
let (lo, hi, gun) = observe::category_envelope(o.category);
let far = hi.max(gun) + o.radius;
let (ci, cj) = grid.index(pos);
let r = (far / grid.cell).ceil() as i32 + 1;
for i in (ci - r).max(0)..=(ci + r).min(n - 1) {
for j in (cj - r).max(0)..=(cj + r).min(n - 1) {
cost += 1;
let ground = land.map(|l| l[(i * n + j) as usize]).filter(|g| g.is_finite());
let p = grid.centre((i, j), ground.map_or(pos.y + height, |g| f64::from(g) + height));
let d = horizontal(p - pos).length();
if d > far {
continue;
}
let missile = (lo..hi).contains(&d);
if !(missile || d < gun) {
continue;
}
prices[(i * n + j) as usize] += (if missile { 30.0 } else { 18.0 }) * scale;
}
}
}
_ => {}
}
}
}
(prices, cost) (prices, cost)
} }
@@ -935,6 +1110,11 @@ const AIR_START_WAIT: u32 = 120;
if !why.is_empty() { if !why.is_empty() {
out.messages.push(format!("Неудачи ПВО: {why}")); out.messages.push(format!("Неудачи ПВО: {why}"));
} }
// What the enemy's recon flights saw: the marks are memory, so the picture may be old (#135).
let marks = self.recon.marks.values().filter(|m| m.live(self.tick)).count();
if marks > 0 {
out.messages.push(format!("Разведка противника: в картине {marks} отметок (возраст и качество — в разборе)"));
}
// What the counter-strikes did to the raid (#101): the launches that never happened. // What the counter-strikes did to the raid (#101): the launches that never happened.
let cut: u32 = self.strikes.cancelled.iter().map(|c| c.1).sum(); let cut: u32 = self.strikes.cancelled.iter().map(|c| c.1).sum();
if cut > 0 { if cut > 0 {
@@ -956,6 +1136,21 @@ fn route_length(from: DVec3, route: &[DVec3], to: DVec3) -> f64 {
len len
} }
/// A recon mark whose observed category fits this kind. The list is already in priority
/// order, so the first fit is the best reason.
fn recon_pick(kind: DroneKind, leads: &[recon::Mark], r: f64) -> Option<recon::Mark> {
use recon::Category as C;
let fits = |c: C| match kind {
DroneKind::Lancet => matches!(c, C::Gun | C::Launcher | C::Ew),
DroneKind::Kh22 | DroneKind::Zircon => matches!(c, C::Radar | C::Launcher | C::Ew),
DroneKind::Iskander | DroneKind::Kinzhal => matches!(c, C::Radar | C::Launcher),
DroneKind::Shahed | DroneKind::Geran3 => matches!(c, C::Radar | C::Launcher | C::Gun | C::Ew),
_ => false,
};
let fits: Vec<&recon::Mark> = leads.iter().filter(|m| fits(m.category)).collect();
fits.get((r * fits.len() as f64) as usize).copied().copied()
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
@@ -1014,23 +1209,23 @@ mod tests {
sim.sams.push(radar); sim.sams.push(radar);
let kinds = [(DroneKind::Kh22, 8)]; let kinds = [(DroneKind::Kh22, 8)];
let none = Vec::new(); let none = Vec::new();
assert!(sim.radar_strikes(&kinds, &none).iter().all(Option::is_none)); assert!(sim.radar_strikes(&kinds, &none, &[]).iter().all(Option::is_none));
sim.tick = 20; sim.tick = 20;
sim.intel.observe(&sim.sams[0], sim.tick, ew::Seen::Emission); sim.intel.observe(&sim.sams[0], sim.tick, ew::Seen::Emission);
// The truth moving after the fix is not an observation: the strike goes to the seen place. // The truth moving after the fix is not an observation: the strike goes to the seen place.
sim.sams[0].pos = DVec3::new(900.0, 70.0, 900.0); sim.sams[0].pos = DVec3::new(900.0, 70.0, 900.0);
sim.tick = 40; sim.tick = 40;
let picture = sim.picture_of_defences(); let picture = sim.picture_of_defences();
let jobs = sim.radar_strikes(&kinds, &picture); let jobs = sim.radar_strikes(&kinds, &picture, &[]);
assert_eq!(jobs.iter().flatten().count(), 2); assert_eq!(jobs.iter().flatten().count(), 2);
assert!(jobs.iter().flatten().all(|job| *job == (old, 1))); assert!(jobs.iter().flatten().all(|job| *job == (old, 1)));
// An old contact is not worth a strike either. // An old contact is not worth a strike either.
sim.tick = 3021; sim.tick = 3021;
let picture = sim.picture_of_defences(); let picture = sim.picture_of_defences();
assert!(sim.radar_strikes(&kinds, &picture).iter().all(Option::is_none), "a doubtful contact was struck"); assert!(sim.radar_strikes(&kinds, &picture, &[]).iter().all(Option::is_none), "a doubtful contact was struck");
sim.tick = 6020; sim.tick = 6020;
let picture = sim.picture_of_defences(); let picture = sim.picture_of_defences();
assert!(sim.radar_strikes(&kinds, &picture).iter().all(Option::is_none)); assert!(sim.radar_strikes(&kinds, &picture, &[]).iter().all(Option::is_none));
} }
#[test] #[test]
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+195 -28
View File
@@ -297,7 +297,9 @@ fn wall_relief() -> std::sync::Arc<super::ew::KnownRelief> {
for j in 0..g.size { for j in 0..g.size {
let x = g.min.x + (f64::from(i) + 0.5) * g.cell; let x = g.min.x + (f64::from(i) + 0.5) * g.cell;
let z = g.min.z + (f64::from(j) + 0.5) * g.cell; let z = g.min.z + (f64::from(j) + 0.5) * g.cell;
if (x + 1000.0).abs() < 80.0 && z.abs() < 420.0 { // The wall spans every approach lane: whichever drone the adaptive tick leaves last,
// its east-west route crosses the ridge, so the two relief versions must differ (#149).
if (x + 1000.0).abs() < 80.0 && z.abs() < 2000.0 {
h[(i * g.size + j) as usize] = 1000.0; h[(i * g.size + j) as usize] = 1000.0;
} }
} }
@@ -382,14 +384,14 @@ fn same_relief_different_known_snapshots_do_not_share_prices_or_routes() {
destroyed: None, destroyed: None,
launches: 0, launches: 0,
}; };
let known_all = std::sync::Arc::new(vec![contact(threat, threat_at), contact(target, aim)]); let known_all = std::sync::Arc::new(super::ew::KnowledgeSnapshot { tick: 1, contacts: vec![contact(threat, threat_at), contact(target, aim)], marks: Vec::new() });
let known_target = std::sync::Arc::new(vec![contact(target, aim)]); let known_target = std::sync::Arc::new(super::ew::KnowledgeSnapshot { tick: 2, contacts: vec![contact(target, aim)], marks: Vec::new() });
// The picture holds both units: a job's unit is alive only while the picture believes in it. // The picture holds both units: a job's unit is alive only while the picture believes in it.
for c in known_all.iter() { for c in known_all.contacts.iter() {
sim.intel.note(c.id, c.kind, c.at, true, 0, super::ew::Seen::Emission); sim.intel.note(c.id, c.kind, c.at, true, 0, super::ew::Seen::Emission);
} }
let mut add = |known: std::sync::Arc<Vec<super::ew::Contact>>, version: u64| -> u32 { let mut add = |known: std::sync::Arc<super::ew::KnowledgeSnapshot>, version: u64| -> u32 {
let mut d = sim.make_drone(DroneKind::Kh22, start, DVec3::X, aim); let mut d = sim.make_drone(DroneKind::Kh22, start, DVec3::X, aim);
d.smart = true; d.smart = true;
d.err = DVec3::ZERO; d.err = DVec3::ZERO;
@@ -420,24 +422,162 @@ fn same_relief_different_known_snapshots_do_not_share_prices_or_routes() {
assert_eq!(r1, r3, "jobs of one knowledge version did not reuse their route cache"); assert_eq!(r1, r3, "jobs of one knowledge version did not reuse their route cache");
} }
// #31: a big cache of fresh columns is not scanned on every answer // #146: one Smart order, two kinds, the land answers starved while the plan waits and a visible
// contact disclosed mid-wait: every kind's targets and routes stay on the snapshot the order was
// chosen with, not on whatever the picture holds when the budget reaches that kind. The plan is
// driven by `plan_step` alone so no adaptive tick retargets the queue before it is read.
#[test] #[test]
fn big_ground_cache_is_swept_rarely() { fn smart_order_routes_every_kind_on_the_snapshot_it_was_ordered_with() {
use super::sites::testland::{serve, Land};
// What the order's drones end up with: kind, aim and route, in the plan's own order.
fn fly(extra_at_order: bool, extra_mid_wait: bool) -> Vec<(DroneKind, DVec3, Vec<DVec3>)> {
let mut sim = Sim::new(146);
let radar = sim.id();
sim.sams.push(Sam::new(radar, SamKind::Radar, DVec3::new(120.0, 70.0, 0.0), 0.0));
sim.intel.observe(&sim.sams[0], sim.tick, ew::Seen::Emission);
sim.targets.push(DVec3::new(0.0, 70.0, 0.0));
sim.target_health.push(100.0);
let extra = sim.id();
let extra_at = DVec3::new(0.0, 70.0, 150.0);
if extra_at_order {
sim.intel.note(extra, SamKind::S400, extra_at, true, sim.tick, ew::Seen::Emission);
}
let mut ground = Ground::default(); let mut ground = Ground::default();
ground.known.extend((0..300_001).map(|x| ((x, 0), (64, 2000)))); let land = Land(|_, _| 64);
let mut out = Out::default();
let order = RaidOrder { kinds: vec![(DroneKind::Shahed, 6), (DroneKind::Geran3, 4)], approach: Approach::AllSides, dist: 300.0, aim: Aim::Smart };
let at = sim.tick;
assert_eq!(sim.order_raid(&order, &sim.targets.clone(), &mut out), 10);
let (_, _, knowledge, _) = sim.plan_pricing().expect("the order was not accepted");
assert_eq!(knowledge.tick, at, "the plan does not keep the tick it was ordered at");
assert!(knowledge.contacts.iter().any(|c| c.id == radar));
assert_eq!(knowledge.contacts.iter().any(|c| c.id == extra), extra_at_order);
let (mut starved, mut added) = (0, !extra_mid_wait);
for _ in 0..600 {
if !sim.planning() {
break;
}
let mapping = sim.plan_pricing().is_some_and(|(_, h, _, _)| !h.is_empty());
if mapping && !added {
// The game tells of no land for a while: the plan waits for the relief, and the
// contact arrives while it waits, after the targets were already chosen.
if starved < 10 {
sim.plan_step(Some(&mut ground), &mut out);
sim.tick += 1;
starved += 1;
continue;
}
sim.intel.note(extra, SamKind::S400, extra_at, true, sim.tick, ew::Seen::Emission);
added = true;
}
serve(&mut ground, &land, sim.tick);
sim.plan_step(Some(&mut ground), &mut out);
sim.tick += 1;
}
assert!(!sim.planning(), "the plan never finished");
assert!(added, "the mid-wait contact was never disclosed");
if extra_mid_wait {
assert!(sim.picture_of_defences().iter().any(|c| c.id == extra), "the disclosure did not reach the picture");
}
sim.queue.iter().map(|(_, d)| (d.kind, d.target, d.route.clone())).collect()
}
// The S400 engages jet drones, not propeller ones: Geran3 is the kind its report moves.
let waited = fly(false, true);
assert_eq!(waited, fly(false, false), "a contact disclosed while the plan waited for the land changed its routes");
assert_ne!(waited, fly(true, false), "the test does not distinguish the order's picture from a later one");
}
// #146: two jobs of one knowledge version, worked out on different ticks across the boundary
// where the current picture would stop believing a contact's own sensor, price the same world.
// An explicitly new retarget, with a fresh report of its own, may use the new report.
#[test]
fn retarget_jobs_of_one_version_age_at_their_own_tick() {
let mut sim = Sim::new(146);
let flat = flat_relief();
let start = DVec3::new(-1000.0, 100.0, 0.0);
let aim = DVec3::new(1000.0, 70.0, 0.0);
let threat = sim.id();
let threat_at = DVec3::new(0.0, 70.0, 0.0);
sim.sams.push(Sam::new(threat, SamKind::S400, threat_at, 0.0));
let target = sim.id();
sim.sams.push(Sam::new(target, SamKind::S400, aim, 0.0));
// The version sits one tick inside the emission belief's TTL: at the version the threat is
// believed to see on its own radar; one tick later the current picture would not believe it.
let version = ew::CONTACT_TTL - 1;
let contact = |id: u32, at: DVec3, tick: u64| ew::Contact { id, kind: SamKind::S400, at, tick, seen: ew::Seen::Emission, emission: Some(tick), destroyed: None, launches: 0 };
let known = std::sync::Arc::new(ew::KnowledgeSnapshot { tick: version, contacts: vec![contact(threat, threat_at, 0), contact(target, aim, version)], marks: Vec::new() });
sim.intel.note(target, SamKind::S400, aim, true, version, ew::Seen::Emission);
fn add(sim: &mut Sim, version: u64, known: std::sync::Arc<ew::KnowledgeSnapshot>, target: u32, start: DVec3, aim: DVec3, flat: &std::sync::Arc<ew::KnownRelief>) -> u32 {
// A jet drone: the S400's published roles engage it, so the belief in its radar prices it.
let mut d = sim.make_drone(DroneKind::Geran3, start, DVec3::X, aim);
d.smart = true;
d.err = DVec3::ZERO;
d.target = aim;
d.route = vec![start, aim];
// Past the switch cap: the adaptive tick may not turn these drones onto anything else.
d.aim = ew::Aim { unit: target, since: version, switches: ew::SWITCH_CAP, confidence: Some(ew::Confidence::Confirmed) };
let id = d.id;
sim.queue.push((0, d));
sim.retargets.push_back(ew::RouteJob::for_test(id, aim, target, version, known, Some(flat.clone())));
id
}
let first = add(&mut sim, version, known.clone(), target, start, aim, &flat);
sim.tick = version;
sim.adapt();
assert!(sim.retargets.is_empty(), "the first job was not finished");
let r1 = retarget_route(&sim, first);
// The same version and the same snapshot, reached one tick past the boundary.
let second = add(&mut sim, version, known.clone(), target, start, aim, &flat);
sim.tick = version + 1;
sim.adapt();
assert!(sim.retargets.is_empty(), "the second job was not finished");
let r2 = retarget_route(&sim, second);
assert_eq!(r1, r2, "a job of the same version aged its contacts with the current tick");
// An explicitly new retarget: a fresh report of the threat at the new version is priced again.
sim.intel.note(threat, SamKind::S400, threat_at, true, version + 1, ew::Seen::Emission);
let fresh = std::sync::Arc::new(ew::KnowledgeSnapshot { tick: version + 1, contacts: vec![contact(threat, threat_at, version + 1), contact(target, aim, version)], marks: Vec::new() });
let third = add(&mut sim, version + 1, fresh, target, start, aim, &flat);
sim.adapt();
assert!(sim.retargets.is_empty(), "the new job was not finished");
let r3 = retarget_route(&sim, third);
assert_eq!(r1, r3, "an explicitly new retarget could not use the new report");
// A new version without a new report: its own tick is past the boundary, so it no longer
// believes the threat's radar and flies the direct line. This is what the same-version job
// above must NOT do, and what makes the two versions distinguishable.
let stale = std::sync::Arc::new(ew::KnowledgeSnapshot { tick: version + 1, contacts: known.contacts.clone(), marks: Vec::new() });
let fourth = add(&mut sim, version + 1, stale, target, start, aim, &flat);
sim.adapt();
assert!(sim.retargets.is_empty(), "the fourth job was not finished");
let r4 = retarget_route(&sim, fourth);
assert_ne!(r1, r4, "the test does not distinguish believing the threat from not believing it");
assert_ne!(r3, r4, "a new version without a new report kept the old belief");
}
// #31: the ground cache is bounded — beyond the cap the oldest answers go, and the sweep
// lands well under the cap so it is not every answer (the fullscreen-map OOM: a cache that
// only swept above 300_000 fresh columns grew without bound under a wide query pattern).
#[test]
fn big_ground_cache_is_bounded_and_swept_rarely() {
let mut ground = Ground::default();
ground.known.extend((0..KNOWN_MAX as i32).map(|x| ((x, 0), (64, 2000))));
ground.known.insert((-1, 0), (64, 0)); ground.known.insert((-1, 0), (64, 0));
// The first answer past the threshold sweeps what is stale and keeps what is fresh. // The answer past the cap sweeps: the stale column goes, the fresh stay, and the cache
// lands at three quarters of the cap.
ground.answer(vec![(-2, 0, 64)], 2100); ground.answer(vec![(-2, 0, 64)], 2100);
assert!(!ground.known.contains_key(&(-1, 0)), "a stale column was never swept"); assert!(!ground.known.contains_key(&(-1, 0)), "a stale column was never swept");
assert!(ground.known.len() > 300_000); assert!(ground.known.len() <= KNOWN_MAX * 3 / 4 + 1, "the sweep did not bound the cache: {}", ground.known.len());
// The next ones wait their pause: a stale column added now survives them. assert!(ground.known.len() > KNOWN_MAX / 2, "the sweep took too much: {}", ground.known.len());
// The next answers do not sweep again at once: a stale column added now survives them.
ground.known.insert((-1, 0), (64, 0)); ground.known.insert((-1, 0), (64, 0));
let swept = ground.swept; let len = ground.known.len();
ground.answer(vec![(-3, 0, 64)], 2101); ground.answer(vec![(-3, 0, 64)], 2101);
assert_eq!(ground.swept, swept, "swept again at once"); assert_eq!(ground.known.len(), len + 1, "swept again at once");
assert!(ground.known.contains_key(&(-1, 0))); assert!(ground.known.contains_key(&(-1, 0)));
ground.answer(vec![(-4, 0, 64)], 2100 + SWEEP_EVERY); // An evicted column is asked again when it is next needed: the cache is reconstructible.
assert!(!ground.known.contains_key(&(-1, 0)), "never swept again"); let evicted = (0, 0);
assert!(!ground.known.contains_key(&evicted));
assert!(ground.at(DVec3::new(evicted.0 as f64, 0.0, 0.0), 2102).is_none());
assert!(ground.take_wanted().contains(&evicted), "an evicted column was not asked again");
} }
// #32: the pieces of an Oreshnik teach the enemy about the sector it came from // #32: the pieces of an Oreshnik teach the enemy about the sector it came from
@@ -990,7 +1130,7 @@ fn fires_start_merge_and_are_limited() {
// interceptors keep clear of it. A synthetic land (a height function) stands in for the game. // interceptors keep clear of it. A synthetic land (a height function) stands in for the game.
/// Land from a height function: blocks below it are solid, and the game's height map says the same. /// Land from a height function: blocks below it are solid, and the game's height map says the same.
struct Land<F: Fn(i32, i32) -> i32>(F); pub(super) struct Land<F: Fn(i32, i32) -> i32>(F);
impl<F: Fn(i32, i32) -> i32> world::WorldSource for Land<F> { impl<F: Fn(i32, i32) -> i32> world::WorldSource for Land<F> {
fn solid(&self, x: i32, y: i32, z: i32) -> Option<bool> { fn solid(&self, x: i32, y: i32, z: i32) -> Option<bool> {
Some(y < (self.0)(x, z)) Some(y < (self.0)(x, z))
@@ -998,7 +1138,7 @@ impl<F: Fn(i32, i32) -> i32> world::WorldSource for Land<F> {
} }
/// What the game answers a tick after the sim asked: land heights, and the sections it needs. /// What the game answers a tick after the sim asked: land heights, and the sections it needs.
fn answer_land<F: Fn(i32, i32) -> i32>(ground: &mut Ground, land: &Land<F>, now: u64) { pub(super) fn answer_land<F: Fn(i32, i32) -> i32>(ground: &mut Ground, land: &Land<F>, now: u64) {
let columns = ground.take_wanted().into_iter().map(|(x, z)| (x, z, (land.0)(x, z))).collect(); let columns = ground.take_wanted().into_iter().map(|(x, z)| (x, z, (land.0)(x, z))).collect();
ground.answer(columns, now); ground.answer(columns, now);
let sections = ground.world.take_wanted(now); let sections = ground.world.take_wanted(now);
@@ -1010,7 +1150,7 @@ fn ridge(rise: i32, half: i32) -> Land<impl Fn(i32, i32) -> i32> {
ridge_at(300, rise, half) ridge_at(300, rise, half)
} }
fn ridge_at(crest: i32, rise: i32, half: i32) -> Land<impl Fn(i32, i32) -> i32> { pub(super) fn ridge_at(crest: i32, rise: i32, half: i32) -> Land<impl Fn(i32, i32) -> i32> {
Land(move |x, _| 64 + (rise - (x - crest).abs() * rise / half).max(0)) Land(move |x, _| 64 + (rise - (x - crest).abs() * rise / half).max(0))
} }
@@ -1103,9 +1243,23 @@ fn behind_ridge(land: &Land<impl Fn(i32, i32) -> i32>, crest: i32, kind: SamKind
// It crawls along the far side of the ridge, 20 blocks over the land. // It crawls along the far side of the ridge, 20 blocks over the land.
let there = (land.0)(x as i32, 0) as f64; let there = (land.0)(x as i32, 0) as f64;
sim.add_drone(DroneKind::Shahed, DVec3::new(x, there + 20.0, -100.0), DVec3::Z, DVec3::new(x, there, 3000.0)); sim.add_drone(DroneKind::Shahed, DVec3::new(x, there + 20.0, -100.0), DVec3::Z, DVec3::new(x, there, 3000.0));
let id = sim.drones[0].id;
for _ in 0..ticks { for _ in 0..ticks {
sim.step(&mut ground, None, &mut out); sim.step(&mut ground, None, &mut out);
answer_land(&mut ground, land, sim.tick); answer_land(&mut ground, land, sim.tick);
// The scenario is about the interceptor's path over the ridge, not about
// where the plot came from: give the system the crest radar's plot as its
// own confirmed fire measurement (separate authority is tested in
// `a_system_does_not_fire_at_a_target_masked_by_a_hill`).
if let Some(t) = sim.sams[1].track(id).copied() {
let mut own = t;
own.source = sim.sams[0].id;
own.own_tick = sim.tick;
own.own_product = battery::Measure::Fire;
own.own_quality = 90;
sim.sams[0].tracks.retain(|o| o.id != id);
sim.sams[0].tracks.push(own);
}
} }
sim sim
} }
@@ -1131,27 +1285,25 @@ fn a_system_does_not_fire_at_a_target_masked_by_a_hill() {
answer_land(&mut ground, land, sim.tick); answer_land(&mut ground, land, sim.tick);
} }
sim.add_drone(DroneKind::Gerbera, DVec3::new(200.0, 84.0, -60.0), DVec3::Z, DVec3::new(200.0, 64.0, 3000.0)); sim.add_drone(DroneKind::Gerbera, DVec3::new(200.0, 84.0, -60.0), DVec3::Z, DVec3::new(200.0, 64.0, 3000.0));
let mut masked = 0u32;
let mut seen = false; let mut seen = false;
let mut told = false; let mut told = false;
for _ in 0..300 { for _ in 0..300 {
sim.step(&mut ground, None, &mut out); sim.step(&mut ground, None, &mut out);
answer_land(&mut ground, land, sim.tick); answer_land(&mut ground, land, sim.tick);
seen |= sim.sams[0].seen.len() == 1; seen |= sim.sams[0].seen.len() == 1;
masked += sim.sams[0].terrain.values().filter(|(_, b)| *b == terrain::MASKED).count() as u32; // The network shows the target, but the Tor has no own confirmed plot,
// `why` names the reason while the verdict stands. // so `why` must say that no launch is authorized.
told |= sim.why(0).iter().any(|c| !c.ok && c.legacy_text().contains("за рельефом")); told |= sim.why(0).iter().any(|c| !c.ok && c.legacy_text().contains("право на пуск: нет"));
} }
(sim, seen, masked, told) (sim, seen, told)
}; };
let (open, seen, _, _) = shot(&flat); let (open, seen, _) = shot(&flat);
assert!(seen && open.sams[0].fired > 0, "control: with a clear line the Tor must fire (seen {seen}, fired {})", open.sams[0].fired); assert!(seen && open.sams[0].fired > 0, "control: with a clear line the Tor must fire (seen {seen}, fired {})", open.sams[0].fired);
let (shut, seen, masked, told) = shot(&hill); let (shut, seen, told) = shot(&hill);
assert!(seen, "the network must have shown the target to the Tor"); assert!(seen, "the network must have shown the target to the Tor");
assert_eq!(shut.sams[0].fired, 0, "the Tor fired at a target behind the hill"); assert_eq!(shut.sams[0].fired, 0, "the Tor fired at a target behind the hill");
assert!(masked > 0, "no launch was judged and refused for the land");
assert_eq!(shut.tally.blocked + shut.tally.scrubbed, 0); assert_eq!(shut.tally.blocked + shut.tally.scrubbed, 0);
assert!(told, "`why` never named the land as the reason"); assert!(told, "`why` never named the missing own fire plot");
} }
// A long-range system lofts over a low ridge (its interceptor does not hit it) but not over a mountain. // A long-range system lofts over a low ridge (its interceptor does not hit it) but not over a mountain.
@@ -2433,7 +2585,22 @@ fn recorded_ignition_is_cold_ticks_after_ejection_and_replay_follows_it() {
// the test is about the launch stages, not about the scan's chance. // the test is about the launch stages, not about the scan's chance.
let now = sim.tick; let now = sim.tick;
let tracks: Vec<sight::Track> = sim.drones.iter().filter(|d| d.alive()) let tracks: Vec<sight::Track> = sim.drones.iter().filter(|d| d.alive())
.map(|d| sight::Track { id: d.id, kind: d.kind, pos: d.pos, vel: d.vel, tick: now, own_tick: now, ttl: 400, hits: 3, locked: false }) .map(|d| sight::Track {
id: d.id,
class: ClassEst::Firm(d.kind.spec().class),
pos: d.pos,
vel: d.vel,
tick: now,
own_tick: now,
source: 1,
product: battery::Measure::Fire,
quality: 90,
own_product: battery::Measure::Fire,
own_quality: 90,
ttl: 400,
hits: 3,
locked: false,
})
.collect(); .collect();
sim.sams[0].tracks.retain(|t| !tracks.iter().any(|n| n.id == t.id)); sim.sams[0].tracks.retain(|t| !tracks.iter().any(|n| n.id == t.id));
sim.sams[0].tracks.extend(tracks); sim.sams[0].tracks.extend(tracks);
+17
View File
@@ -563,6 +563,23 @@ pub(super) struct Routes {
} }
impl Routes { impl Routes {
/// What the routes and their searches hold, about (see `sim::memory`).
pub(super) fn bytes(&self) -> usize {
use super::memory::{map_bytes, vec_bytes};
let cell = std::mem::size_of::<(i32, i32)>();
let mut n = map_bytes(self.map.len(), std::mem::size_of::<u32>() + std::mem::size_of::<Route>())
+ map_bytes(self.unreachable.len(), std::mem::size_of::<(u32, u32)>() + std::mem::size_of::<u64>());
for r in self.map.values() {
n += map_bytes(r.cells.len(), cell + std::mem::size_of::<Info>())
+ map_bytes(r.bad.len(), cell)
+ map_bytes(r.g.len(), cell + std::mem::size_of::<f32>())
+ map_bytes(r.came.len(), 2 * cell)
+ r.open.capacity() * std::mem::size_of::<Open>()
+ vec_bytes(&r.parked)
+ vec_bytes(&r.pts);
}
n
}
pub(super) fn out_of_reach(&self, truck: u32, job: u32, now: u64) -> bool { pub(super) fn out_of_reach(&self, truck: u32, job: u32, now: u64) -> bool {
self.unreachable.get(&(truck, job)).is_some_and(|&t| t > now) self.unreachable.get(&(truck, job)).is_some_and(|&t| t > now)
} }
+618 -1
View File
@@ -1,5 +1,7 @@
//! Radar scan cycles with ageing tracks (#46) and damage to a system's parts (#50). //! Radar scan cycles with ageing tracks (#46) and damage to a system's parts (#50).
use super::sight::{swept, FORECAST_AGE}; use super::battery::{Measure, RadarRole};
use super::regress::{answer_land, ridge_at};
use super::sight::{swept, FIRE_QUALITY, FORECAST_AGE};
use super::*; use super::*;
fn flat() -> (Ground, Out) { fn flat() -> (Ground, Out) {
@@ -122,6 +124,9 @@ fn a_failed_radar_gives_no_own_tracks_but_the_network_still_feeds_it() {
let early = radar_at(&mut sim, SamKind::Radar, 120.0); let early = radar_at(&mut sim, SamKind::Radar, 120.0);
let id = drone_from(&mut sim, -150.0); let id = drone_from(&mut sim, -150.0);
sim.sams[p].comps.0[Part::Sensor as usize] = 0.0; sim.sams[p].comps.0[Part::Sensor as usize] = 0.0;
// Hold fire: the fed track is now acted on (an unidentified contact is a candidate under the
// general rules, #133), and this test is about the feed, not about the intercept.
sim.sams[p].roles = 0;
for _ in 0..500 { for _ in 0..500 {
sim.step(&mut ground, None, &mut out); sim.step(&mut ground, None, &mut out);
} }
@@ -254,3 +259,615 @@ fn the_same_seed_rolls_the_same_scan_and_damage() {
}; };
assert_eq!(run(), run()); assert_eq!(run(), run());
} }
// ---------------------------------------------------------------- #133: the class estimate
#[test]
fn the_classifier_steps_by_the_measurements_alone() {
// The same observed speeds give the same estimate whatever the contact truly is, and a
// contrary measurement replaces the hypothesis instead of being ignored.
let mut est = ClassEst::Unknown;
assert_eq!(est.step(1, 0.6), ClassEst::Unknown, "one blip says nothing of the class");
est = est.step(2, 0.6);
assert_eq!(est, ClassEst::Probable(Class::Drone));
est = est.step(3, 0.62);
assert_eq!(est, ClassEst::Firm(Class::Drone), "agreeing measurements firm the guess");
// The contact proves much faster (or the first readings misled): the hypothesis gives way,
// and one measurement is not enough to firm the new one.
est = est.step(4, 5.0);
assert_eq!(est, ClassEst::Probable(Class::Supersonic));
est = est.step(5, 5.1);
assert_eq!(est, ClassEst::Firm(Class::Supersonic));
// Whatever the true kind, the same observations read the same: a Kinzhal measured as a slow
// propeller is, to the network, a drone until its measurements say otherwise.
assert_eq!(ClassEst::Unknown.step(2, 0.5), ClassEst::Probable(Class::Drone));
}
#[test]
fn the_speed_bands_read_the_games_own_kinds_right() {
// The bands sit between the game's speed clusters: the measured speed of a kind reads as its
// class, so a slow Lancet is no jet and a Shahed no cruise missile. A fast ballistic and a
// supersonic missile fly alike (the Iskander and the Zircon): speed alone leaves that
// ambiguity, documented on `Class::of_speed`.
for kind in DroneKind::ALL {
let spec = kind.spec();
if spec.class == Class::Ballistic && spec.speed < 6.5 {
continue;
}
assert_eq!(Class::of_speed(spec.speed), spec.class, "{kind:?} at {} blocks a tick", spec.speed);
}
assert_eq!(Class::of_speed(5.0), Class::Supersonic, "a fast ballistic and a supersonic fly alike");
}
#[test]
fn the_first_blip_gives_no_class_and_no_speed() {
let mut sim = Sim::new(5);
let (mut ground, mut out) = flat();
let r = radar_at(&mut sim, SamKind::Radar, 0.0);
let id = drone_from(&mut sim, -150.0);
let mut first = None;
for _ in 0..300 {
sim.step(&mut ground, None, &mut out);
if let Some(t) = sim.sams[r].track(id) {
first = Some(*t);
break;
}
}
let t = first.expect("a track of the drone");
assert_eq!(t.hits, 1);
assert_eq!(t.class, ClassEst::Unknown, "the first measurement must not name a class");
assert_eq!(t.vel, DVec3::ZERO, "the true velocity must not leak into the track");
}
#[test]
fn tracks_of_different_kinds_one_class_firm_the_same_estimate() {
// A Shahed and a Gerbera are different machines of one class, flying alike; the picture both
// networks end up holding is the same: a firm slow drone, never a model name. (Faster kinds
// cross this little radar's reach between beam passes: too few measurements to firm anything.)
let roles = SamKind::S400.spec().roles;
let mut seen = Vec::new();
for kind in [DroneKind::Shahed, DroneKind::Gerbera] {
let mut sim = Sim::new(7);
let (mut ground, mut out) = flat();
// One radar: an uninterrupted chain of measurements (two early-warning radars do not
// exchange tracks — a radar is fed only when it serves fire control — so the second one
// would measure from a blank picture, its own chain apart).
radar_at(&mut sim, SamKind::Radar, 0.0);
let from = DVec3::new(-150.0, 95.0, 40.0);
sim.add_drone(kind, from, DVec3::X, DVec3::new(5000.0, 95.0, 40.0));
let id = sim.drones.last().unwrap().id;
let mut est = None;
for _ in 0..700 {
sim.step(&mut ground, None, &mut out);
if let Some(t) = sim.picture().get(&id) {
est = Some(t.class);
}
}
assert_eq!(est, Some(ClassEst::Firm(Class::Drone)), "{kind:?}: {est:?}");
// The wording and the class-dependent decisions come from the estimate, not the machine.
let est = est.unwrap();
seen.push((est, est.name(), est.mark(), est.in_roles(roles)));
}
assert_eq!(seen[0], seen[1], "the same observations read differently for two kinds: {seen:?}");
}
#[test]
fn the_role_policy_keeps_the_unidentified_and_holds_fire_with_no_roles() {
let some = Class::Drone.bit() | Class::Jet.bit();
// An unidentified contact is not a block: it stays a candidate under the general rules.
assert!(ClassEst::Unknown.in_roles(some));
// No roles at all is holding fire: nothing is a candidate, the unidentified included.
assert!(!ClassEst::Unknown.in_roles(0), "hold fire must block the unidentified too");
// A probable guess is a block when its class is out of the roles, and a pass when in them.
assert!(ClassEst::Probable(Class::Drone).in_roles(some));
assert!(!ClassEst::Probable(Class::Cruise).in_roles(some));
assert!(ClassEst::Firm(Class::Jet).in_roles(some));
assert!(!ClassEst::Firm(Class::Ballistic).in_roles(0));
}
#[test]
fn a_gun_lets_go_of_a_track_classified_out_of_its_roles() {
// The Gepard's roles are drones, jets and cruise missiles: a supersonic missile is out of them.
assert_eq!(SamKind::Gepard.spec().roles & Class::Supersonic.bit(), 0);
let mut sim = Sim::new(11);
let (mut ground, mut out) = flat();
let p = radar_at(&mut sim, SamKind::Gepard, 0.0);
sim.add_drone(DroneKind::Zircon, DVec3::new(0.0, 95.0, -60.0), DVec3::Z, DVec3::new(0.0, 70.0, -700.0));
let id = sim.drones.last().unwrap().id;
sim.tick = 10;
let seed = |sim: &mut Sim, class| {
let d = sim.drones[0].clone();
sim.sams[p].tracks.retain(|t| t.id != d.id);
let source = sim.sams[p].id;
sim.sams[p].tracks.push(Track { id: d.id, class, pos: d.pos, vel: d.vel, tick: sim.tick, own_tick: sim.tick, source, product: battery::Measure::Fire, quality: 90, own_product: battery::Measure::Fire, own_quality: 90, ttl: 400, hits: 3, locked: false });
};
// Taken while the class was unknown: the general rules make it a candidate.
seed(&mut sim, ClassEst::Unknown);
sim.step_sams(&mut ground, &mut out);
assert_eq!(sim.sams[p].gun_target, Some(id), "an unidentified track is not its gun target");
// Classified: no longer a class the gun engages, and it is let go instead of being fired at.
seed(&mut sim, ClassEst::Firm(Class::Supersonic));
sim.step_sams(&mut ground, &mut out);
assert_eq!(sim.sams[p].gun_target, None, "the gun kept a track its roles do not cover");
}
#[test]
fn forecasts_and_relays_add_no_confidence() {
let mut sim = Sim::new(7);
let (mut ground, mut out) = flat();
let a = radar_at(&mut sim, SamKind::Radar, 0.0);
let _b = radar_at(&mut sim, SamKind::Radar, 500.0);
let n = radar_at(&mut sim, SamKind::P1sun, 250.0);
let id = drone_from(&mut sim, -50.0);
// The source's own track: while no new measurement lands (the tick unchanged, the track only
// forecast onwards) the estimate must not move — a forecast is not data.
let mut prev: Option<(u64, ClassEst)> = None;
let mut relayed = 0;
for _ in 0..800 {
sim.step(&mut ground, None, &mut out);
if let Some(t) = sim.sams[a].track(id).copied() {
if let Some((tick, class)) = prev {
assert!(t.tick > tick || t.class == class, "a forecast or a re-read firmed the class: {tick}->{:?} {:?}->{:?}", t.tick, class, t.class);
}
prev = Some((t.tick, t.class));
}
// The network's copy carries the estimate as it was, with its measurement's age; passing
// it on adds nothing (the receiver never measures: own_tick stays 0).
if let Some(t) = sim.sams[n].track(id).copied() {
relayed += 1;
assert_eq!(t.own_tick, 0);
let freshest = sim.sams.iter().filter(|s| s.id != sim.sams[n].id).filter_map(|s| s.track(id)).max_by_key(|t| t.tick);
assert_eq!(Some(t.class), freshest.map(|f| f.class), "a relay altered the estimate");
}
}
assert!(relayed > 100, "the network never passed the track ({relayed})");
assert!(prev.is_some_and(|(_, c)| c.class().is_some()), "the source never classified the contact");
}
// ---------------------------------------------------------------- separate radar profiles (#134)
fn radar_with_role(sim: &mut Sim, role: RadarRole, x: f64) -> usize {
let id = sim.id();
let mut sam = Sam::new(id, SamKind::Radar, DVec3::new(x, 70.0, 0.0), 0.0);
sam.set_radar_role(role);
sim.sams.push(sam);
sim.sams.len() - 1
}
fn bearing(from: DVec3, to: DVec3) -> f64 {
(to.x - from.x).atan2(-(to.z - from.z))
}
/// The beam of every radar is pointed at one of `targets` in turn, so a test
/// does not depend on where the initial phase happened to be.
fn sweep(sim: &mut Sim, ground: &mut Ground, radars: &[usize], targets: &[DVec3], tick: u64) {
sim.tick = tick;
for (k, &i) in radars.iter().enumerate() {
let at = targets[(tick as usize + k) % targets.len()];
sim.sams[i].beam = bearing(sim.sams[i].pos, at);
}
sim.update_sight(ground);
}
#[derive(Default, Debug, PartialEq, Eq)]
struct ProfileStats {
first_high: Option<u64>,
first_low_refined: Option<u64>,
first_close_fire: Option<u64>,
max_channels: usize,
search_or_height_authorized: bool,
}
/// A low contact at 330 blocks (above the search/engagement horizon but below
/// the mast's), a high contact at 700/430 (inside the search reach but outside
/// the mast's and engagement's local search), and two close contacts for the
/// tracked-contact channels.
fn profile_world(roles: &[RadarRole]) -> (Sim, Vec<usize>, Vec<u32>, Ground) {
let mut sim = Sim::new(134);
let radars: Vec<usize> = roles.iter().map(|role| radar_with_role(&mut sim, *role, 0.0)).collect();
sim.add_drone(DroneKind::Shahed, DVec3::new(330.0, 95.0, 0.0), DVec3::Z, DVec3::new(330.0, 95.0, 0.0));
let low = sim.drones.last().unwrap().id;
sim.add_drone(DroneKind::Shahed, DVec3::new(700.0, 500.0, 0.0), DVec3::Z, DVec3::new(700.0, 500.0, 0.0));
let high = sim.drones.last().unwrap().id;
sim.add_drone(DroneKind::Gerbera, DVec3::new(120.0, 120.0, 0.0), DVec3::Z, DVec3::new(120.0, 120.0, 0.0));
let close1 = sim.drones.last().unwrap().id;
sim.add_drone(DroneKind::Gerbera, DVec3::new(180.0, 130.0, 40.0), DVec3::Z, DVec3::new(180.0, 130.0, 40.0));
let close2 = sim.drones.last().unwrap().id;
(sim, radars, vec![low, high, close1, close2], Ground::default())
}
fn run_profile_world(roles: &[RadarRole], ticks: u64) -> (ProfileStats, Sim, Vec<usize>, Vec<u32>) {
let (mut sim, radars, ids, mut ground) = profile_world(roles);
let [low, high, close1, close2] = [ids[0], ids[1], ids[2], ids[3]];
let targets: Vec<DVec3> = sim.drones.iter().map(|d| d.pos).collect();
let mut stats = ProfileStats::default();
for tick in 1..=ticks {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
for &i in &radars {
let sam = &sim.sams[i];
for t in sam.tracks.iter().filter(|t| t.own_tick > 0) {
match t.id {
id if id == high && stats.first_high.is_none() => stats.first_high = Some(tick),
id if id == low && t.product == Measure::Refine && stats.first_low_refined.is_none() => stats.first_low_refined = Some(tick),
id if (id == close1 || id == close2) && t.product == Measure::Fire && t.own_authorizes(sim.tick) && stats.first_close_fire.is_none() => stats.first_close_fire = Some(tick),
_ => {}
}
}
if sam.radar_profile().id == "radar_search" || sam.radar_profile().id == "radar_height" {
stats.search_or_height_authorized |= sam.tracks.iter().any(|t| t.own_authorizes(sim.tick));
}
stats.max_channels = stats.max_channels.max(sam.own_channels_used(sim.tick));
}
}
(stats, sim, radars, ids)
}
#[test]
fn each_profile_is_useful_alone_and_the_full_set_covers_all_three_jobs() {
let search = run_profile_world(&[RadarRole::Search], 500).0;
assert!(search.first_high.is_some(), "the search radar gives no early high plot: {search:?}");
assert!(search.first_low_refined.is_none(), "search refined a low contact it does not reach: {search:?}");
assert!(search.first_close_fire.is_none(), "search authorized a launch: {search:?}");
let height = run_profile_world(&[RadarRole::Height], 500).0;
assert!(height.first_high.is_none(), "the mast radar searched beyond its local patch: {height:?}");
assert!(height.first_low_refined.is_some(), "the mast radar did not refine the low contact: {height:?}");
assert!(height.first_close_fire.is_none(), "the mast radar authorized a launch: {height:?}");
let engagement = run_profile_world(&[RadarRole::Engagement], 500).0;
assert!(engagement.first_high.is_none(), "the engagement radar searched beyond its local patch: {engagement:?}");
assert!(engagement.first_low_refined.is_none(), "the engagement radar reached a low contact below the horizon: {engagement:?}");
assert!(engagement.first_close_fire.is_some(), "the engagement radar gave no fire plot: {engagement:?}");
assert!(engagement.max_channels <= 2, "more than two tracked contacts: {engagement:?}");
let search_height = run_profile_world(&[RadarRole::Search, RadarRole::Height], 500).0;
assert!(search_height.first_high.is_some() && search_height.first_low_refined.is_some());
assert!(search_height.first_close_fire.is_none(), "a search/height pair authorized a launch: {search_height:?}");
let search_engagement = run_profile_world(&[RadarRole::Search, RadarRole::Engagement], 500).0;
assert!(search_engagement.first_high.is_some() && search_engagement.first_close_fire.is_some());
assert!(search_engagement.first_low_refined.is_none(), "the pair covered the mast's low gap: {search_engagement:?}");
let height_engagement = run_profile_world(&[RadarRole::Height, RadarRole::Engagement], 500).0;
assert!(height_engagement.first_low_refined.is_some() && height_engagement.first_close_fire.is_some());
assert!(height_engagement.first_high.is_none(), "the pair covered the search's far picture: {height_engagement:?}");
let full = run_profile_world(&[RadarRole::Search, RadarRole::Height, RadarRole::Engagement], 500).0;
assert!(full.first_high.is_some() && full.first_low_refined.is_some() && full.first_close_fire.is_some(), "{full:?}");
assert!(!full.search_or_height_authorized, "a non-fire radar authorized a launch");
// There is no set bonus in the profile table: a duplicated station adds no
// function, and the full set's advantage is only the union of the three jobs.
let duplicate = run_profile_world(&[RadarRole::Search, RadarRole::Search], 500).0;
assert!(duplicate.first_low_refined.is_none() && duplicate.first_close_fire.is_none(), "two search radars invented another function: {duplicate:?}");
}
#[test]
fn network_relay_keeps_source_age_and_quality_but_not_launch_authority() {
let mut sim = Sim::new(1341);
let search = radar_with_role(&mut sim, RadarRole::Search, 0.0);
let engagement = radar_with_role(&mut sim, RadarRole::Engagement, 10.0);
let receiver = {
let id = sim.id();
let mut s400 = Sam::new(id, SamKind::S400, DVec3::new(20.0, 70.0, 0.0), 0.0);
// A blind receiver: only the network can give it a track.
s400.comps.0[Part::Sensor as usize] = 0.0;
s400.roles = 0xff;
sim.sams.push(s400);
sim.sams.len() - 1
};
sim.add_drone(DroneKind::Shahed, DVec3::new(200.0, 120.0, 0.0), DVec3::Z, DVec3::new(200.0, 120.0, 0.0));
let id = sim.drones[0].id;
let mut ground = Ground::default();
let targets = vec![sim.drones[0].pos];
let radars = [search, engagement];
for tick in 1..=120 {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
}
let own = sim.sams[engagement].track(id).expect("the engagement radar measured the target");
assert_eq!(own.source, sim.sams[engagement].id);
assert_eq!(own.product, Measure::Fire);
assert!(own.quality >= FIRE_QUALITY && own.own_authorizes(sim.tick));
let relayed = sim.sams[receiver].track(id).expect("the network shared the plot");
assert_eq!(relayed.own_tick, 0, "a relay became the receiver's own measurement");
assert_eq!(relayed.tick, own.tick, "a relay refreshed the measurement's age");
assert!(relayed.product == Measure::Fire && relayed.quality == own.quality, "relay lost product/quality");
assert_eq!(relayed.source, sim.sams[engagement].id, "relay lost the measuring station");
assert!(!relayed.own_authorizes(sim.tick));
let opts = why::Opts { last_chance: false, far_shots: false };
{
let load = sim.sams[receiver].kind.spec().missile.as_ref().unwrap();
let drone = &sim.drones[0];
assert!(why::basis(&sim.sams[receiver], load, relayed, drone, sim.tick, 0, 1.0, opts, true, false).is_none(), "a relayed plot authorized a launch");
}
// A launcher without a radar may use the supporting radar's own confirmed plot.
sim.sams[receiver].set_mode(battery::SamMode::LauncherOnly);
for tick in 121..=122 {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
}
let relayed = *sim.sams[receiver].track(id).expect("the launcher re-received the network plot");
assert!(why::radar_cue(&sim.sams[receiver], &[&sim.sams[engagement]], id, sim.tick));
{
let load = sim.sams[receiver].kind.spec().missile.as_ref().unwrap();
let drone = &sim.drones[0];
assert!(why::basis(&sim.sams[receiver], load, &relayed, drone, sim.tick, 0, 1.0, opts, true, false).is_some());
}
// The search radar's plot is coarse: it does not authorize even a launcher.
assert!(!why::radar_cue(&sim.sams[receiver], &[&sim.sams[search]], id, sim.tick));
// A broken data link ends the cue even while the radar itself still measures.
sim.sams[engagement].comps.0[Part::Comms as usize] = 0.0;
assert_eq!(sim.sams[engagement].link_range(), 0.0);
assert!(!why::radar_cue(&sim.sams[receiver], &[&sim.sams[engagement]], id, sim.tick), "a broken link still cued a launch");
}
#[test]
fn a_network_plot_cues_a_separate_fire_radar_but_not_the_embedded_one() {
// #145: a fire-quality radar is cued to look at a network contact, but the weapon's own
// embedded radar is not — cueing every relayed contact each tick flooded the embedded fire
// control with one-tick plots and degraded the intercepts. The embedded radar keeps its
// beam/revisit/lock acquisition; a separate engagement radar still takes the cue.
let mut sim = Sim::new(145);
let search = radar_with_role(&mut sim, RadarRole::Search, 0.0);
let engagement = radar_with_role(&mut sim, RadarRole::Engagement, 10.0);
let embedded = {
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::S400, DVec3::new(20.0, 70.0, 0.0), 0.0));
sim.sams.len() - 1
};
sim.add_drone(DroneKind::Shahed, DVec3::new(150.0, 120.0, 0.0), DVec3::Z, DVec3::new(150.0, 120.0, 0.0));
let id = sim.drones[0].id;
let at = sim.drones[0].pos;
let away = DVec3::new(-600.0, 120.0, 0.0);
let mut ground = Ground::default();
for tick in 1..=8 {
sim.tick = tick;
// The search radar measures the contact; the embedded and engagement radars look away,
// so only a cue (not the beam, a revisit or a lock) could give them an own plot.
sim.sams[search].beam = bearing(sim.sams[search].pos, at);
sim.sams[embedded].beam = bearing(sim.sams[embedded].pos, away);
sim.sams[engagement].beam = bearing(sim.sams[engagement].pos, away);
sim.update_sight(&mut ground);
}
let emb = sim.sams[embedded].track(id).expect("the embedded radar holds the network track");
assert_eq!(emb.own_tick, 0, "the embedded radar cue-measured a relayed contact (#145)");
assert!(!emb.own_authorizes(sim.tick), "a relayed plot gave the embedded radar fire authority");
let eng = sim.sams[engagement].track(id).expect("the engagement radar holds the track");
assert!(eng.own_tick > 0, "a separate fire-quality radar was not cued by the network plot");
}
#[test]
fn the_air_picture_prefers_the_better_plot_at_one_tick() {
let mut sim = Sim::new(1345);
let search = radar_with_role(&mut sim, RadarRole::Search, 0.0);
let track = radar_with_role(&mut sim, RadarRole::Engagement, 10.0);
sim.add_drone(DroneKind::Gerbera, DVec3::new(120.0, 120.0, 0.0), DVec3::Z, DVec3::new(120.0, 120.0, 0.0));
let id = sim.drones[0].id;
let mut ground = Ground::default();
let targets = vec![sim.drones[0].pos];
for tick in 1..=5 {
sweep(&mut sim, &mut ground, &[search, track], &targets, tick);
}
let pic = sim.air_picture();
let t = pic.tracks.iter().find(|t| t.id == id).expect("the raid is on the picture");
assert_eq!(t.source, sim.sams[track].id, "a coarse plot won over the better one at the same tick");
assert_eq!(t.product, Measure::Fire);
assert!(t.own_authorizes(sim.tick));
}
#[test]
fn tracked_channels_are_a_hard_limit_but_the_rest_keep_search_plots() {
let mut sim = Sim::new(1344);
let engagement = radar_with_role(&mut sim, RadarRole::Engagement, 0.0);
for x in [100.0, 140.0, 180.0, 220.0] {
sim.add_drone(DroneKind::Gerbera, DVec3::new(x, 120.0, 0.0), DVec3::Z, DVec3::new(x, 120.0, 0.0));
}
let mut ground = Ground::default();
let targets: Vec<DVec3> = sim.drones.iter().map(|d| d.pos).collect();
for tick in 1..=40 {
sweep(&mut sim, &mut ground, &[engagement], &targets, tick);
}
let own: Vec<&Track> = sim.sams[engagement].tracks.iter().filter(|t| t.own_tick > 0).collect();
let precise = own.iter().filter(|t| t.own_product != Measure::Search).count();
assert_eq!(precise, 2, "the station refined more contacts than its channels: {own:?}");
assert_eq!(sim.sams[engagement].own_channels_used(sim.tick), 2);
assert_eq!(own.len(), 4, "a full station stopped giving coarse search plots: {own:?}");
assert!(own.iter().filter(|t| t.own_product == Measure::Search).all(|t| !t.own_authorizes(sim.tick)));
}
// #140: a network heartbeat keeps an old contact's track fresh, but never holds the station's
// channel: two stale own fire plots free the channels for a new contact, and the survey tracks
// of the old ones stay on the picture — with the search radar left running.
#[test]
fn stale_own_plots_free_their_channels_while_the_network_keeps_the_tracks() {
let mut sim = Sim::new(140);
let engagement = radar_with_role(&mut sim, RadarRole::Engagement, 0.0);
let search = radar_with_role(&mut sim, RadarRole::Search, 1550.0);
for x in [100.0, 140.0] {
sim.add_drone(DroneKind::Gerbera, DVec3::new(x, 120.0, 0.0), DVec3::Z, DVec3::new(x, 120.0, 0.0));
}
let old: Vec<u32> = sim.drones.iter().map(|d| d.id).collect();
let mut ground = Ground::default();
let radars = [engagement, search];
for tick in 1..=40 {
let targets: Vec<DVec3> = sim.drones.iter().map(|d| d.pos).collect();
sweep(&mut sim, &mut ground, &radars, &targets, tick);
}
let frozen: Vec<u64> = old
.iter()
.map(|&id| {
let t = sim.sams[engagement].track(id).expect("the station took the contact");
assert_ne!(t.own_product, Measure::Search, "the station took no channel: {t:?}");
t.own_tick
})
.collect();
assert_eq!(sim.sams[engagement].own_channels_used(sim.tick), 2);
// The two contacts leave the station's reach for the search radar beside them; the new one
// arrives close to the station. Only the network keeps the old tracks alive now.
for (k, d) in sim.drones.iter_mut().enumerate() {
d.pos = DVec3::new(1600.0 + 20.0 * k as f64, 120.0, 0.0);
}
sim.add_drone(DroneKind::Gerbera, DVec3::new(180.0, 120.0, 0.0), DVec3::Z, DVec3::new(180.0, 120.0, 0.0));
let fresh = sim.drones.last().unwrap().id;
for tick in 41..=750 {
let targets: Vec<DVec3> = sim.drones.iter().map(|d| d.pos).collect();
sweep(&mut sim, &mut ground, &radars, &targets, tick);
}
let now = sim.tick;
let station = &sim.sams[engagement];
assert_eq!(station.own_channels_used(now), 1, "the stale channels still hold: {:?}", station.tracks);
for (&id, &own_tick) in old.iter().zip(&frozen) {
let t = station.track(id).expect("the survey track was thrown away with its channel");
assert_eq!(t.own_tick, own_tick, "the network renewed the station's own plot");
assert!(t.tick > 500, "the network stopped relaying the old contact: {t:?}");
assert_eq!(t.product, Measure::Search, "the relayed survey plot is gone: {t:?}");
assert!(!t.holds_channel(now, station.track_ttl() as u64), "an old own plot still holds a channel: {t:?}");
assert!(!t.own_authorizes(now));
}
let new = station.track(fresh).expect("the new contact is not held");
assert_eq!(new.own_product, Measure::Fire, "the new contact never got a channel: {new:?}");
assert!(new.own_authorizes(now), "the new contact's own fire plot does not authorize: {new:?}");
}
#[test]
fn off_and_damage_remove_the_station_and_its_quality_without_touching_neighbours() {
let mut sim = Sim::new(1342);
let search = radar_with_role(&mut sim, RadarRole::Search, 0.0);
let engagement = radar_with_role(&mut sim, RadarRole::Engagement, 20.0);
sim.add_drone(DroneKind::Gerbera, DVec3::new(150.0, 120.0, 0.0), DVec3::Z, DVec3::new(150.0, 120.0, 0.0));
let id = sim.drones[0].id;
let mut ground = Ground::default();
let targets = vec![sim.drones[0].pos];
let radars = [search, engagement];
for tick in 1..=80 {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
}
assert!(sim.sams[engagement].track(id).is_some_and(|t| t.own_authorizes(sim.tick)));
let healthy = sim.sams[engagement].track(id).unwrap().own_quality;
// Off: the station emits nothing, its own plots stop, the neighbour still feeds the network.
sim.sams[engagement].radar_on = false;
let before = sim.sams[engagement].track(id).map(|t| t.own_tick);
for tick in 81..=110 {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
}
assert!(!sim.sams[engagement].radar_up());
assert_eq!(sim.sams[engagement].track(id).map(|t| t.own_tick), before, "a silent radar renewed its own plot");
assert!(sim.sams[search].track(id).is_some_and(|t| t.own_tick > 0));
// Damage: a worn sensor still measures, with worse quality and no launch right.
sim.sams[engagement].radar_on = true;
sim.sams[engagement].comps.0[Part::Sensor as usize] = 0.2;
for tick in 111..=180 {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
}
let worn = sim.sams[engagement].track(id).expect("a worn radar still measures");
assert!(worn.own_quality < healthy, "damage did not lower quality: {worn:?}");
assert!(!worn.own_authorizes(sim.tick), "a worn sensor still authorized a launch");
}
#[test]
fn multifunction_and_embedded_radars_keep_their_fire_authority() {
let mut sim = Sim::new(1343);
let multi = radar_with_role(&mut sim, RadarRole::Multifunction, 0.0);
let pantsir = radar_at(&mut sim, SamKind::Pantsir, 20.0);
sim.add_drone(DroneKind::Gerbera, DVec3::new(120.0, 120.0, 0.0), DVec3::Z, DVec3::new(120.0, 120.0, 0.0));
let id = sim.drones[0].id;
let mut ground = Ground::default();
let targets = vec![sim.drones[0].pos];
let radars = [multi, pantsir];
for tick in 1..=100 {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
}
assert!(sim.sams[multi].track(id).is_some_and(|t| t.own_authorizes(sim.tick)), "the universal profile lost its own fire plot");
assert!(sim.sams[pantsir].track(id).is_some_and(|t| t.own_authorizes(sim.tick)), "an embedded radar lost its own fire plot");
}
#[test]
fn profiles_keep_their_jobs_over_a_ridge_on_one_seed_and_land() {
// One seed and one ridge: the low contact hides behind it, the high one flies over it,
// and two close contacts compete for the engagement channels on the far side.
let targets = [
DVec3::new(250.0, 84.0, 0.0),
DVec3::new(700.0, 500.0, 0.0),
DVec3::new(240.0, 90.0, 30.0),
DVec3::new(260.0, 95.0, -20.0),
];
#[derive(Default, Debug)]
struct RidgeStats {
low_marked: bool,
low_refined: bool,
low_fire: bool,
high_marked: bool,
track_channels: usize,
nonfire_authorized: bool,
}
let run = |stations: &[(RadarRole, DVec3)], land| -> RidgeStats {
let mut sim = Sim::new(134);
let radars: Vec<usize> = stations
.iter()
.map(|(role, pos)| {
let id = sim.id();
let mut sam = Sam::new(id, SamKind::Radar, *pos, 0.0);
sam.set_radar_role(*role);
sim.sams.push(sam);
sim.sams.len() - 1
})
.collect();
for (k, pos) in targets.iter().enumerate() {
let kind = if k < 2 { DroneKind::Shahed } else { DroneKind::Gerbera };
sim.add_drone(kind, *pos, DVec3::Z, *pos);
}
let ids: Vec<u32> = sim.drones.iter().map(|d| d.id).collect();
let mut ground = Ground::default();
// Unknown land hides nothing: let the heights answer before any measurement counts.
for tick in 1..=60 {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
answer_land(&mut ground, land, tick);
}
for i in &radars {
sim.sams[*i].tracks.clear();
}
let mut stats = RidgeStats::default();
for tick in 61..=560 {
sweep(&mut sim, &mut ground, &radars, &targets, tick);
answer_land(&mut ground, land, tick);
for &i in &radars {
let sam = &sim.sams[i];
let profile = sam.radar_profile();
for t in sam.tracks.iter().filter(|t| t.own_tick > 0) {
if t.id == ids[0] {
stats.low_marked = true;
stats.low_refined |= t.product == Measure::Refine;
stats.low_fire |= t.own_authorizes(sim.tick);
}
stats.high_marked |= t.id == ids[1];
}
if profile.id == "radar_track" {
stats.track_channels = stats.track_channels.max(sam.own_channels_used(sim.tick));
}
if profile.id == "radar_search" || profile.id == "radar_height" {
stats.nonfire_authorized |= sam.tracks.iter().any(|t| t.own_authorizes(sim.tick));
}
}
}
stats
};
let near = DVec3::new(0.0, 64.0, 0.0);
let far = DVec3::new(220.0, 64.0, 0.0);
let ridge = ridge_at(150, 100, 60);
let search = run(&[(RadarRole::Search, near)], &ridge);
assert!(search.high_marked, "the search radar lost the high contact over the ridge: {search:?}");
assert!(!search.low_marked, "the search radar saw through the ridge: {search:?}");
// The same station on flat land does mark the low contact: the ridge is what hides it.
let flat = ridge_at(150, 0, 60);
let control = run(&[(RadarRole::Search, near)], &flat);
assert!(control.low_marked, "the control lost the low contact on flat land: {control:?}");
let height = run(&[(RadarRole::Height, far)], &ridge);
assert!(height.low_refined, "the mast did not refine the low contact behind the ridge: {height:?}");
assert!(!height.high_marked && !height.low_fire, "the mast left its patch or authorized a launch: {height:?}");
let engagement = run(&[(RadarRole::Engagement, far)], &ridge);
assert!(engagement.low_fire, "the engagement radar gave no fire plot on the low contact: {engagement:?}");
assert!(!engagement.high_marked, "the engagement radar searched beyond its patch: {engagement:?}");
assert!(engagement.track_channels <= 2, "more than two tracked contacts: {engagement:?}");
let full = run(&[(RadarRole::Search, near), (RadarRole::Height, far), (RadarRole::Engagement, far)], &ridge);
assert!(full.high_marked && full.low_refined && full.low_fire, "the full set lost a job on the ridge: {full:?}");
assert!(!full.nonfire_authorized, "a non-fire radar authorized a launch: {full:?}");
assert!(full.track_channels <= 2, "the engagement radar exceeded its channels: {full:?}");
}
+246 -34
View File
@@ -8,12 +8,15 @@
//! (a period by the kind of radar; an electronic one also revisits what it holds //! (a period by the kind of radar; an electronic one also revisits what it holds
//! more often), a target is measured when the beam passes it, with a chance that //! more often), a target is measured when the beam passes it, with a chance that
//! falls with range and size, and the measurement is kept as a *track*: where it //! falls with range and size, and the measurement is kept as a *track*: where it
//! was and how fast it went then, and when. Between measurements the track is //! was measured, how fast it then seemed to go (from the measured places, never
//! the target's own figures), and when. Between measurements the track is
//! carried on by that velocity (a forecast, shown as one), and after three missed //! carried on by that velocity (a forecast, shown as one), and after three missed
//! scans it is dropped. A fire-control lock on a target the system is engaging is //! scans it is dropped. A fire-control lock on a target the system is engaging is
//! a dedicated channel: it measures every tick while the target is in reach and in //! a dedicated channel: it measures every tick while the target is in reach and in
//! sight. The network passes tracks with the age of their measurement; relaying //! sight. The track also carries what the measurements say of the contact's class,
//! makes none of them fresher. //! the estimate growing only on real measurements: a forecast, a relayed copy adds
//! nothing to it. The network passes tracks with the age of their measurement;
//! relaying makes none of them fresher.
use super::*; use super::*;
/// Rays round a radar, and blocks between the land's samples along them. /// Rays round a radar, and blocks between the land's samples along them.
@@ -24,6 +27,8 @@ pub(super) const LINK: f64 = 2250.0;
/// A launcher fires on a track no older than this (ticks); a gun needs its own radar's, newer than `GUN_AGE`. /// A launcher fires on a track no older than this (ticks); a gun needs its own radar's, newer than `GUN_AGE`.
pub(super) const MISSILE_AGE: u64 = 120; pub(super) const MISSILE_AGE: u64 = 120;
pub(super) const GUN_AGE: u64 = 3; pub(super) const GUN_AGE: u64 = 3;
/// A fire plot below this quality is not confirmed enough to authorize a launch.
pub const FIRE_QUALITY: u8 = 50;
/// A gun takes a target its radar measured this recently (then the lock refreshes it every tick). /// A gun takes a target its radar measured this recently (then the lock refreshes it every tick).
pub(super) const GUN_PICK_AGE: u64 = 40; pub(super) const GUN_PICK_AGE: u64 = 40;
/// A track older than this is shown as a forecast. /// A track older than this is shown as a forecast.
@@ -87,7 +92,7 @@ pub(super) fn antenna(sam: &Sam) -> DVec3 {
} }
fn sensor_span(sam: &Sam) -> f64 { fn sensor_span(sam: &Sam) -> f64 {
sam.kind.spec().sensor * if sam.kind == SamKind::Radar { sam.radar_role.reach_factor() } else { 1.0 } sam.kind.spec().sensor * sam.radar_profile().reach
} }
/// How far a system's search radar reaches for this kind at `height` over the land: /// How far a system's search radar reaches for this kind at `height` over the land:
@@ -97,7 +102,7 @@ pub(super) fn reach(sam: &Sam, kind: DroneKind, height: f64) -> f64 {
if spec.sensor <= 0.0 { if spec.sensor <= 0.0 {
return 0.0; return 0.0;
} }
let radar = spec.sensor * sam.radar_fit() * if sam.kind == SamKind::Radar { sam.radar_role.reach_factor() } else { 1.0 } * kind.rcs().powf(0.25); let radar = spec.sensor * sam.radar_fit() * sam.radar_profile().reach * kind.rcs().powf(0.25);
let horizon = HORIZON * (sam.sensor_mast().sqrt() + height.max(0.0).sqrt()); let horizon = HORIZON * (sam.sensor_mast().sqrt() + height.max(0.0).sqrt());
radar.min(horizon).max(NEAR) radar.min(horizon).max(NEAR)
} }
@@ -142,7 +147,7 @@ impl Sim {
let fit = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).map_or(1.0, |s| s.radar_fit()); let fit = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).map_or(1.0, |s| s.radar_fit());
let height = LOW_KIND.spec().clearance; let height = LOW_KIND.spec().clearance;
let mast = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).map_or(spec.mast, |s| s.sensor_mast()); let mast = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).map_or(spec.mast, |s| s.sensor_mast());
let factor = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).filter(|s| s.kind == SamKind::Radar).map_or(1.0, |s| s.radar_role.reach_factor()); let factor = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).map_or(1.0, |s| s.radar_profile().reach);
let radar = spec.sensor * fit * factor * LOW_KIND.rcs().powf(0.25); let radar = spec.sensor * fit * factor * LOW_KIND.rcs().powf(0.25);
let reach = radar.min(HORIZON * (mast.sqrt() + height.sqrt())).max(NEAR); let reach = radar.min(HORIZON * (mast.sqrt() + height.sqrt())).max(NEAR);
let terrain = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).is_some_and(|s| self.horizons.get(&s.id).is_some_and(|h| h.matches(s))); let terrain = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).is_some_and(|s| self.horizons.get(&s.id).is_some_and(|h| h.matches(s)));
@@ -243,17 +248,31 @@ impl Ident {
} }
/// What a system knows of one target: the last measurement, not the target itself. /// What a system knows of one target: the last measurement, not the target itself.
///
/// The track never carries the target's type or its true velocity (#133): `class` is what the
/// radars inferred from the measurements so far, `vel` the speed those measurements showed —
/// none from the first blip, then the change of the measured places between real measurements,
/// smoothed a little. The forecast and the guns live with that.
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
pub struct Track { pub struct Track {
pub id: u32, pub id: u32,
/// What the radar made of it when it measured (the class the picture shows). /// What the radars make of it from the measurements (never the target's own type).
pub kind: DroneKind, pub class: ClassEst,
/// Where it was and how it went when last measured (blocks, blocks a tick). /// Where it was measured and how fast it seemed to go then (blocks, blocks a tick).
pub pos: DVec3, pub pos: DVec3,
pub vel: DVec3, pub vel: DVec3,
/// When that was, and when this system's own radar last measured it (0: never, the network's only). /// When that was, and when this system's own radar last measured it (0: never, the network's only).
pub tick: u64, pub tick: u64,
pub own_tick: u64, pub own_tick: u64,
/// The station that measured the latest plot, and what it is good for.
pub source: u32,
pub product: battery::Measure,
/// Measurement quality (0..100), separate from identification (`hits`).
pub quality: u8,
/// This system's own measurement provenance. A fresher relay may replace
/// the published plot without granting or erasing the station's own right.
pub own_product: battery::Measure,
pub own_quality: u8,
/// Ticks the track lives without a new measurement. /// Ticks the track lives without a new measurement.
pub ttl: u32, pub ttl: u32,
pub hits: u8, pub hits: u8,
@@ -294,6 +313,34 @@ impl Track {
pub fn own_within(&self, now: u64, age: u64) -> bool { pub fn own_within(&self, now: u64, age: u64) -> bool {
self.own_tick > 0 && now.saturating_sub(self.own_tick) <= age self.own_tick > 0 && now.saturating_sub(self.own_tick) <= age
} }
/// The station's own measurement was a confirmed fire plot, fresh enough.
/// A relayed plot has `own_tick == 0` and never passes this test.
pub fn own_fire_within(&self, now: u64, age: u64) -> bool {
self.own_within(now, age) && self.own_product.allows_fire() && self.own_quality >= FIRE_QUALITY
}
/// Own plot good enough for a launcher's ordinary shot.
pub fn own_authorizes(&self, now: u64) -> bool {
self.own_fire_within(now, MISSILE_AGE)
}
/// The station's own refine/fire channel on this contact is still live: the plot is its own,
/// finer than a search, and no older than the station keeps a contact without a fresh
/// measurement. A relayed plot never holds a channel: the network's heartbeat keeps the
/// track fresh, not the station's own tracking (#140).
pub fn holds_channel(&self, now: u64, ttl: u64) -> bool {
self.own_tick > 0
&& self.own_product != battery::Measure::Search
&& now.saturating_sub(self.own_tick) <= ttl
}
/// Who measured the latest plot, as an ID (`0`: no station).
pub fn measured_by(&self) -> Option<u32> {
(self.source != 0).then_some(self.source)
}
/// One passive optical look at this contact (#136): refines the class alone. The plot, its
/// age, source, quality and the station's own fire rights are untouched — optics never
/// authorize a shot and never make a track fresher.
pub fn refine_class_optical(&mut self, class: Class, uncertainty: f64) {
self.class = self.class.step_optical(class, uncertainty);
}
pub fn ident(&self) -> Ident { pub fn ident(&self) -> Ident {
match self.hits { match self.hits {
0 | 1 => Ident::Unknown, 0 | 1 => Ident::Unknown,
@@ -310,16 +357,12 @@ impl Track {
impl Sam { impl Sam {
/// Fictional antenna height and scan characteristics for gameplay roles. /// Fictional antenna height and scan characteristics for gameplay roles.
pub(super) fn sensor_mast(&self) -> f64 { pub(super) fn sensor_mast(&self) -> f64 {
self.kind.spec().mast + if self.kind == SamKind::Radar && self.radar_role == battery::RadarRole::Height { 8.0 } else { 0.0 } self.kind.spec().mast + self.radar_profile().mast
} }
pub(super) fn scan_profile(&self) -> Scan { pub(super) fn scan_profile(&self) -> Scan {
if self.kind != SamKind::Radar { return self.kind.scan(); } if self.kind != SamKind::Radar { return self.kind.scan(); }
match self.radar_role { let profile = self.radar_profile();
battery::RadarRole::Multifunction => self.kind.scan(), Scan { period: profile.cycle, agile: profile.agile }
battery::RadarRole::Search => Scan { period: 170, agile: false },
battery::RadarRole::Engagement => Scan { period: 70, agile: true },
battery::RadarRole::Height => Scan { period: 140, agile: false },
}
} }
/// Ticks for its beam to go round (longer when the radar is damaged). /// Ticks for its beam to go round (longer when the radar is damaged).
pub(super) fn scan_ticks(&self) -> f64 { pub(super) fn scan_ticks(&self) -> f64 {
@@ -329,9 +372,24 @@ impl Sam {
pub fn radar_up(&self) -> bool { pub fn radar_up(&self) -> bool {
self.radar_on && self.mode != battery::SamMode::LauncherOnly && self.alive() && !self.moving() && self.kind.spec().sensor > 0.0 && self.part(Part::Sensor) > 0.0 self.radar_on && self.mode != battery::SamMode::LauncherOnly && self.alive() && !self.moving() && self.kind.spec().sensor > 0.0 && self.part(Part::Sensor) > 0.0
} }
/// Its jammer is really on the air: the switch, a live station and a deployed one. The same
/// state `step_ew` transmits in, so a look names jamming only while the transmitter works.
pub fn ew_up(&self) -> bool {
self.ew_on && !self.ew_lock && self.alive() && !self.moving()
}
pub fn track(&self, id: u32) -> Option<&Track> { pub fn track(&self, id: u32) -> Option<&Track> {
self.tracks.iter().find(|t| t.id == id) self.tracks.iter().find(|t| t.id == id)
} }
/// Ticks a contact stays this station's own without a fresh measurement: three missed turns, at least 60.
pub(super) fn track_ttl(&self) -> u32 {
((self.scan_ticks() * 3.0) as u32).max(60)
}
/// Refined/fire channels this station is currently using: the same test the planner applies,
/// so the panel and the allocation never disagree about a stale channel.
pub fn own_channels_used(&self, now: u64) -> usize {
let ttl = self.track_ttl() as u64;
self.tracks.iter().filter(|t| t.holds_channel(now, ttl)).count()
}
} }
/// Whether a beam that moved from `from` by `w` radians this tick passed `bearing` (all angles taken round 2π, /// Whether a beam that moved from `from` by `w` radians this tick passed `bearing` (all angles taken round 2π,
@@ -345,10 +403,18 @@ fn merge(tracks: &mut Vec<Track>, index: &mut HashMap<u32, usize>, t: Track) {
match index.get(&t.id) { match index.get(&t.id) {
Some(&k) => { Some(&k) => {
let mine = &mut tracks[k]; let mine = &mut tracks[k];
if t.tick > mine.tick { // Prefer the fresher plot; at the same tick the better one (a fire plot
let (own_tick, locked) = (mine.own_tick, if t.own_tick > 0 { t.locked } else { mine.locked }); // over a coarse search plot), without making anything newer.
if t.tick > mine.tick || (t.tick == mine.tick && t.quality > mine.quality) {
// A relayed plot is published with its source/quality, but it
// neither refreshes nor erases this station's own measurement and its right.
let (own_tick, own_product, own_quality, locked) = if t.own_tick > 0 {
(t.own_tick, t.own_product, t.own_quality, t.locked)
} else {
(mine.own_tick, mine.own_product, mine.own_quality, mine.locked)
};
let hits = mine.hits.max(t.hits); let hits = mine.hits.max(t.hits);
*mine = Track { own_tick: if t.own_tick > 0 { t.own_tick } else { own_tick }, hits, locked, ..t }; *mine = Track { own_tick, own_product, own_quality, hits, locked, ..t };
} }
} }
None => { None => {
@@ -358,6 +424,23 @@ fn merge(tracks: &mut Vec<Track>, index: &mut HashMap<u32, usize>, t: Track) {
} }
} }
/// A plot's quality (0..100). It uses only the measured geometry and the
/// station's own fit, never the target's hidden state.
fn plot_quality(sam: &Sam, profile: battery::RadarProfile, product: battery::Measure, ratio: f64, height: f64) -> u8 {
let ratio = ratio.clamp(0.0, 1.0);
let base = match profile.id {
"radar_search" => 46.0 - 14.0 * ratio,
"radar_height" => 74.0 - 12.0 * ratio + if height < 120.0 { 8.0 } else if height < 200.0 { 3.0 } else { 0.0 },
"radar_track" => 88.0 - 12.0 * ratio,
"radar_multi" => 72.0 - 14.0 * ratio,
_ => 78.0 - 14.0 * ratio,
};
// A search plot is coarse whatever the profile; only a matched refinement or
// a fire plot gets the profile's accuracy.
let base = if product == battery::Measure::Search { base.min(48.0) } else { base };
(base * sam.radar_fit()).round().clamp(5.0, 99.0) as u8
}
impl Sim { impl Sim {
/// Rebuilds the systems' horizons in turn, then lets each radar's beam pass the sky: new measurements /// Rebuilds the systems' horizons in turn, then lets each radar's beam pass the sky: new measurements
/// into the tracks, old tracks out, and the network's tracks shared. /// into the tracks, old tracks out, and the network's tracks shared.
@@ -401,13 +484,18 @@ impl Sim {
index.clear(); index.clear();
index.extend(sam.tracks.iter().enumerate().map(|(k, t)| (t.id, k))); index.extend(sam.tracks.iter().enumerate().map(|(k, t)| (t.id, k)));
let spec = sam.kind.spec(); let spec = sam.kind.spec();
let profile = sam.radar_profile();
let scan = sam.scan_profile(); let scan = sam.scan_profile();
let period = sam.scan_ticks(); let period = sam.scan_ticks();
let w = TAU / period; let w = TAU / period;
let (b0, ttl) = (sam.beam, ((period * 3.0) as u32).max(60)); let (b0, ttl) = (sam.beam, sam.track_ttl());
sam.beam = (b0 + w) % TAU; sam.beam = (b0 + w) % TAU;
let at = antenna(sam); let at = antenna(sam);
let horizon = self.horizons.get(&sam.id); let horizon = self.horizons.get(&sam.id);
let local = spec.sensor * profile.local;
// Channels already refining or holding fire plots, by the same test the UI shows:
// a stale own plot (the network may keep the track) no longer occupies one.
let mut used = sam.own_channels_used(now);
let mut fresh: Vec<Track> = Vec::new(); let mut fresh: Vec<Track> = Vec::new();
for (d, h) in self.drones.iter().zip(&heights) { for (d, h) in self.drones.iter().zip(&heights) {
if !d.alive() { if !d.alive() {
@@ -415,7 +503,7 @@ impl Sim {
} }
let rel = d.pos - at; let rel = d.pos - at;
let dist = rel.length(); let dist = rel.length();
if dist > spec.sensor * if sam.kind == SamKind::Radar { sam.radar_role.reach_factor().max(1.0) * 1.2 } else { 1.2 } { if dist > spec.sensor * profile.reach.max(1.0) * 1.2 {
continue; continue;
} }
let locked = sam.target == Some(d.id) || sam.gun_target == Some(d.id); let locked = sam.target == Some(d.id) || sam.gun_target == Some(d.id);
@@ -423,13 +511,38 @@ impl Sim {
// The beam passes its bearing this tick (the angle wraps at 2π: the difference is taken round). // The beam passes its bearing this tick (the angle wraps at 2π: the difference is taken round).
let in_beam = swept(rel.x.atan2(-rel.z), b0, w); let in_beam = swept(rel.x.atan2(-rel.z), b0, w);
let revisit = scan.agile && held.is_some_and(|t| t.own_tick > 0 && now - t.own_tick >= (period / 3.0) as u64); let revisit = scan.agile && held.is_some_and(|t| t.own_tick > 0 && now - t.own_tick >= (period / 3.0) as u64);
// A search radar's network track cues this fictional tracking radar to look, but is // A network plot cues a *separate* fire-quality radar to look, but is never itself
// never itself a measurement: reach, terrain, probability and noise still apply. // a measurement: reach, terrain, probability and noise still apply. The weapon's
let cue = sam.kind == SamKind::Radar && sam.radar_role == battery::RadarRole::Engagement // own embedded radar is not cued: measuring every relayed contact each tick flooded
// its fire control with one-tick plots whose noisy velocity degraded the intercepts
// (#145); it keeps its beam/revisit/lock acquisition, as before the profiles (#134).
let cue = sam.kind == SamKind::Radar && profile.allows(battery::Measure::Fire)
&& held.is_some_and(|t| t.own_tick == 0 && t.age(now) <= MISSILE_AGE); && held.is_some_and(|t| t.own_tick == 0 && t.age(now) <= MISSILE_AGE);
if !(in_beam || locked || revisit || cue) { if !(in_beam || locked || revisit || cue) {
continue; continue;
} }
// The separate stations search their own patch; a cue or an already held
// contact may be followed beyond it, never an arbitrary target of the map.
if profile.local < 1.0 && dist > local && !locked && !(cue || held.is_some_and(|t| t.own_tick > 0)) {
continue;
}
// The tracked-contact channels are a hard limit: work per tick stays bounded
// and a full station does not silently refine the whole sky. A station already
// refining a contact keeps its channel; a new refinement needs a free one, and
// without one the station still publishes its ordinary coarse search plot.
let holds_channel = held.is_some_and(|t| t.holds_channel(now, ttl as u64));
let mut product = if profile.allows(battery::Measure::Fire) {
battery::Measure::Fire
} else if profile.allows(battery::Measure::Refine) && held.is_some() {
// Refinement only applies to a contact already matched, own or network.
battery::Measure::Refine
} else {
battery::Measure::Search
};
let wants_channel = product != battery::Measure::Search && !holds_channel;
if profile.channels > 0 && wants_channel && used >= profile.channels as usize {
product = battery::Measure::Search;
}
let height = h.unwrap_or(d.pos.y - sam.pos.y); let height = h.unwrap_or(d.pos.y - sam.pos.y);
let reach = reach(sam, d.kind, height); let reach = reach(sam, d.kind, height);
if dist > reach || (dist > NEAR && horizon.is_some_and(|hz| hz.hides(at, d.pos))) { if dist > reach || (dist > NEAR && horizon.is_some_and(|hz| hz.hides(at, d.pos))) {
@@ -446,17 +559,40 @@ impl Sim {
if dist > NEAR && dice(seed, now, key, 0) >= p { if dist > NEAR && dice(seed, now, key, 0) >= p {
continue; continue;
} }
let sigma = if locked { 0.3 } else if sam.kind == SamKind::Radar && sam.radar_role == battery::RadarRole::Engagement { 0.45 + dist * 0.002 } else { 0.8 + dist * 0.004 }; let sigma = if locked { 0.3 } else { profile.sigma + dist * profile.spread };
let noise = DVec3::new(dice(seed, now, key, 1) - 0.5, (dice(seed, now, key, 2) - 0.5) * 0.5, dice(seed, now, key, 3) - 0.5) * 2.0 * sigma; let noise = DVec3::new(dice(seed, now, key, 1) - 0.5, (dice(seed, now, key, 2) - 0.5) * profile.vertical, dice(seed, now, key, 3) - 0.5) * 2.0 * sigma;
let measured = d.pos + noise;
let quality = plot_quality(sam, profile, product, dist / reach.max(1.0), height);
if profile.channels > 0 && wants_channel && product != battery::Measure::Search {
used += 1;
}
let hits = held.map_or(1, |t| t.hits.saturating_add(1));
// What this measurement says of the contact's class and speed, from the measured
// places alone: the first blip gives neither; a later one, the change of place over
// the ticks since the last real measurement (not a forecast's), smoothed into what
// the track held so the class does not flap on one noisy pair (#133).
let (vel, class) = match held {
Some(p) if p.tick < now => {
let seen = (measured - p.pos) / (now - p.tick) as f64;
let vel = if p.hits <= 1 { seen } else { p.vel + (seen - p.vel) / f64::from(p.hits.min(4)) };
(vel, p.class.step(hits, vel.length()))
}
_ => (DVec3::ZERO, ClassEst::Unknown),
};
fresh.push(Track { fresh.push(Track {
id: d.id, id: d.id,
kind: d.kind, class,
pos: d.pos + noise, pos: measured,
vel: d.vel, vel,
tick: now, tick: now,
own_tick: now, own_tick: now,
source: sam.id,
product,
quality,
own_product: product,
own_quality: quality,
ttl, ttl,
hits: held.map_or(1, |t| t.hits.saturating_add(1)), hits,
locked, locked,
}); });
} }
@@ -482,7 +618,37 @@ impl Sim {
.map(|s| (s.id, s.pos, s.link_range(), s.tracks.iter().filter(|t| t.own_tick > 0 && t.own_tick == t.tick).copied().collect::<Vec<_>>())) .map(|s| (s.id, s.pos, s.link_range(), s.tracks.iter().filter(|t| t.own_tick > 0 && t.own_tick == t.tick).copied().collect::<Vec<_>>()))
.filter(|s| !s.3.is_empty()) .filter(|s| !s.3.is_empty())
.collect(); .collect();
// One freshest track per radar is all a cue needs: the posts never walk every contact.
let cues: Vec<(u32, DVec3, f64, Track)> = if self.sams.iter().any(|s| s.kind == SamKind::Optical) {
shared
.iter()
.filter_map(|(id, at, range, tracks)| tracks.iter().max_by_key(|t| t.tick).map(|t| (*id, *at, *range, *t)))
.collect()
} else {
Vec::new()
};
for sam in &mut self.sams { for sam in &mut self.sams {
if sam.kind == SamKind::Optical {
// An optical post receives a cue, not a track: the freshest network measurement within
// link range only points its head, and none of it enters `tracks`, `seen` or `own`.
sam.seen.clear();
sam.own.clear();
if sam.alive() && !sam.moving() && sam.link_range() > 0.0 {
let mine = sam.link_range();
let mut best: Option<Track> = None;
for (id, at, range, t) in &cues {
if *id != sam.id && at.distance(sam.pos) <= range.min(mine)
&& best.is_none_or(|b: Track| t.tick > b.tick)
{
best = Some(*t);
}
}
if let Some(t) = best {
sam.optical.offer_cue(t);
}
}
continue;
}
if sam.alive() && !sam.moving() && (sam.kind.armed() || (sam.kind == SamKind::Radar && sam.radar_role == battery::RadarRole::Engagement)) && sam.link_range() > 0.0 && !shared.is_empty() { if sam.alive() && !sam.moving() && (sam.kind.armed() || (sam.kind == SamKind::Radar && sam.radar_role == battery::RadarRole::Engagement)) && sam.link_range() > 0.0 && !shared.is_empty() {
index.clear(); index.clear();
index.extend(sam.tracks.iter().enumerate().map(|(k, t)| (t.id, k))); index.extend(sam.tracks.iter().enumerate().map(|(k, t)| (t.id, k)));
@@ -490,7 +656,7 @@ impl Sim {
for (id, at, range, tracks) in &shared { for (id, at, range, tracks) in &shared {
if *id != sam.id && at.distance(sam.pos) <= range.min(mine) { if *id != sam.id && at.distance(sam.pos) <= range.min(mine) {
for t in tracks { for t in tracks {
merge(&mut sam.tracks, &mut index, Track { own_tick: 0, ..*t }); merge(&mut sam.tracks, &mut index, Track { own_tick: 0, own_product: battery::Measure::Search, own_quality: 0, ..*t });
} }
} }
} }
@@ -504,6 +670,9 @@ impl Sim {
} }
} }
} }
// Passive optics (#136) look after the network has spoken: a cue is only a cue, and every
// observation it makes is its own, never a track and never an emission.
self.update_optics(ground);
} }
/// Whether any system's radar holds this drone (the player's radar shows only those). /// Whether any system's radar holds this drone (the player's radar shows only those).
@@ -520,8 +689,25 @@ impl Sim {
let mut tracks: Vec<Track> = if unaided { let mut tracks: Vec<Track> = if unaided {
self.drones self.drones
.iter() .iter()
// No system is deployed: no estimation happens, the fallback is the sky as it is
// (the screens have always had it), with the figures a system would show.
.filter(|d| d.alive()) .filter(|d| d.alive())
.map(|d| Track { id: d.id, kind: d.kind, pos: d.pos, vel: d.vel, tick: now, own_tick: now, ttl: 1, hits: 3, locked: false }) .map(|d| Track {
id: d.id,
class: ClassEst::Firm(d.kind.spec().class),
pos: d.pos,
vel: d.vel,
tick: now,
own_tick: now,
source: 0,
product: battery::Measure::Fire,
quality: 100,
own_product: battery::Measure::Fire,
own_quality: 100,
ttl: 1,
hits: 3,
locked: false,
})
.collect() .collect()
} else { } else {
self.picture().into_values().collect() self.picture().into_values().collect()
@@ -530,11 +716,12 @@ impl Sim {
AirPicture { now, tracks, unaided } AirPicture { now, tracks, unaided }
} }
/// The freshest track of each drone any system holds: the air picture. /// The freshest track of each drone any system holds: the air picture. At one
/// tick the better plot (quality, then product) is the one the player sees.
pub fn picture(&self) -> HashMap<u32, Track> { pub fn picture(&self) -> HashMap<u32, Track> {
let mut best: HashMap<u32, Track> = HashMap::new(); let mut best: HashMap<u32, Track> = HashMap::new();
for t in self.sams.iter().flat_map(|s| s.tracks.iter()) { for t in self.sams.iter().flat_map(|s| s.tracks.iter()) {
if best.get(&t.id).is_none_or(|b| t.tick > b.tick) { if best.get(&t.id).is_none_or(|b| (t.tick, t.quality, t.product) > (b.tick, b.quality, b.product)) {
best.insert(t.id, *t); best.insert(t.id, *t);
} }
} }
@@ -612,3 +799,28 @@ mod low_view_tests {
assert!(seen > 0 && tint.as_millis() < 100, "{tint:?}"); assert!(seen > 0 && tint.as_millis() < 100, "{tint:?}");
} }
} }
#[cfg(test)]
mod relay_tests {
use super::*;
/// A relayed measurement: its class and hits arrive as they were, the receiver's own age is
/// kept, and passing the same message again adds nothing (#133).
#[test]
fn a_repeated_relay_adds_no_confidence_and_stays_foreign() {
let ours = Track { id: 7, class: ClassEst::Unknown, pos: DVec3::new(0.0, 100.0, 0.0), vel: DVec3::ZERO, tick: 90, own_tick: 90, source: 1, product: battery::Measure::Fire, quality: 80, own_product: battery::Measure::Fire, own_quality: 80, ttl: 400, hits: 1, locked: false };
let relay = Track { id: 7, class: ClassEst::Probable(Class::Drone), pos: DVec3::new(0.0, 100.0, -10.0), vel: DVec3::X, tick: 100, own_tick: 0, source: 2, product: battery::Measure::Fire, quality: 90, own_product: battery::Measure::Search, own_quality: 0, ttl: 400, hits: 2, locked: false };
let mut tracks = vec![ours];
let mut index: HashMap<u32, usize> = HashMap::from([(7, 0)]);
merge(&mut tracks, &mut index, relay);
assert_eq!(tracks[0].own_tick, 90, "a relayed track is not the receiver's own measurement");
for _ in 0..5 {
merge(&mut tracks, &mut index, relay);
}
assert_eq!(tracks.len(), 1, "a relay of a held measurement is one track");
assert_eq!(tracks[0].hits, 2, "a repeated relay added confidence");
assert_eq!(tracks[0].class, ClassEst::Probable(Class::Drone), "a relay altered the estimate");
assert_eq!(tracks[0].tick, 100, "a relay refreshed the measurement");
assert_eq!(tracks[0].own_tick, 90, "a relay became the receiver's own");
}
}
+5
View File
@@ -184,6 +184,11 @@ pub(super) enum Slot {
} }
impl Sites { impl Sites {
/// What the sites hold, about (see `sim::memory`).
pub(super) fn bytes(&self) -> usize {
use super::memory::vec_bytes;
vec_bytes(&self.list) + vec_bytes(&self.jobs) + vec_bytes(&self.holding) + vec_bytes(&self.flying)
}
pub fn get(&self, id: u32) -> Option<&LaunchSite> { pub fn get(&self, id: u32) -> Option<&LaunchSite> {
self.list.iter().find(|s| s.id == id) self.list.iter().find(|s| s.id == id)
} }
+312
View File
@@ -0,0 +1,312 @@
//! Smart v2 (#149): the merged public picture, one knowledge version per order, the bounded
//! refresh of the unreleased portion, and the bearing window — and the metamorphic guarantee
//! that a hidden permutation nothing observed changes no decision.
use super::*;
use super::sites::testland::{Land, serve};
fn grid() -> raid::Grid {
raid::Grid { min: DVec3::new(-800.0, 0.0, -800.0), cell: 16.0, size: 100 }
}
fn mark(id: u32, at: DVec3, category: recon::Category, observed: u64) -> recon::Mark {
recon::Mark {
id,
area: at,
radius: recon::COARSE_AREA,
category,
role: None,
source: recon::Source::Flyby,
observed,
reported: observed,
quality: recon::Quality::Coarse,
looks: 1,
}
}
fn contact(id: u32, kind: SamKind, at: DVec3, tick: u64) -> ew::Contact {
ew::Contact { id, kind, at, tick, seen: ew::Seen::Emission, emission: Some(tick), destroyed: None, launches: 0 }
}
fn order() -> RaidOrder {
RaidOrder { kinds: vec![(DroneKind::Shahed, 4), (DroneKind::Kh22, 2)], approach: Approach::Sector, dist: 900.0, aim: Aim::Smart }
}
// #149: the metamorphic guarantee. Two worlds with the same seed and the same observed radar,
// whose hidden forces are a permutation of one another (kinds swapped between places), order
// the same recon flight, the same aims and intents, and the same prices — nothing unobserved
// leaks into a decision.
#[test]
fn a_hidden_permutation_changes_nothing_before_observation() {
let object = DVec3::new(0.0, 70.0, 0.0);
let build = |perm: bool| {
let mut sim = Sim::new(149);
let id = sim.id();
let radar = Sam::new(id, SamKind::Radar, DVec3::new(150.0, 70.0, -80.0), 0.0);
sim.intel.observe(&radar, 0, ew::Seen::Emission);
sim.sams.push(radar);
let spots = [DVec3::new(-200.0, 70.0, 100.0), DVec3::new(300.0, 70.0, 200.0), DVec3::new(-50.0, 70.0, -300.0)];
let kinds = if perm { [SamKind::Pantsir, SamKind::S400, SamKind::Tor] } else { [SamKind::S400, SamKind::Tor, SamKind::Pantsir] };
for (k, p) in kinds.into_iter().zip(spots) {
let id = sim.id();
sim.sams.push(Sam::new(id, k, p, 0.0));
}
sim.targets.push(object);
sim.target_health.push(100.0);
let mut out = Out::default();
sim.order_raid(&order(), &[object], &mut out);
let flight: Vec<_> = sim.recon.sorties.iter().map(|s| s.zones.iter().map(|z| (z.center, z.radius)).collect::<Vec<_>>()).collect();
let aims = sim.planned_aims();
let intents = sim.planned_intents();
let (prices, _) = sim.price_grid(&grid(), DroneKind::Kh101);
(flight, aims, intents, prices)
};
assert_eq!(build(false), build(true), "a hidden permutation changed the flight, the plan or the prices");
}
// #149: the same guarantee after a look. Once a radar is observed, permuting only the units
// nothing saw changes neither the structured picture nor the prices.
#[test]
fn a_hidden_permutation_changes_nothing_after_observation() {
let build = |perm: bool| {
let mut sim = Sim::new(149);
let id = sim.id();
let radar = Sam::new(id, SamKind::Radar, DVec3::new(150.0, 70.0, -80.0), 0.0);
sim.intel.observe(&radar, 0, ew::Seen::Emission);
sim.sams.push(radar);
let spots = [DVec3::new(-200.0, 70.0, 100.0), DVec3::new(300.0, 70.0, 200.0)];
let kinds = if perm { [SamKind::S400, SamKind::Pantsir] } else { [SamKind::Pantsir, SamKind::S400] };
for (k, p) in kinds.into_iter().zip(spots) {
let id = sim.id();
sim.sams.push(Sam::new(id, k, p, 0.0));
}
sim.tick = 100;
let (prices, _) = sim.price_grid(&grid(), DroneKind::Kh101);
(sim.enemy_picture(), prices)
};
assert_eq!(build(false), build(true), "a hidden permutation moved the picture or the prices after a look");
}
// #149: price_grid_known accounts for marks. A fresh probable mark raises the cells its public
// category covers; a doubtful one prices nothing; a mark matched to a contact is priced once,
// exactly as the contact alone. The legacy mode prices contacts only.
#[test]
fn a_fresh_mark_prices_the_map_and_a_doubtful_one_does_not() {
let mut sim = Sim::new(149);
let g = grid();
let m = mark(recon::ID_BASE + 1, DVec3::new(0.0, 70.0, 0.0), recon::Category::Launcher, 0);
let fresh = ew::KnowledgeSnapshot::new(100, Vec::new(), vec![m]);
let (prices, _) = sim.price_grid_known(&g, DroneKind::Kh101, None, &fresh);
assert!(prices.iter().any(|p| *p > 1.0), "a fresh launcher mark priced nothing");
let old = ew::KnowledgeSnapshot::new(4000, Vec::new(), vec![m]);
let (prices, _) = sim.price_grid_known(&g, DroneKind::Kh101, None, &old);
assert!(prices.iter().all(|p| *p == 1.0), "a doubtful mark was priced");
// Merged into a contact of the same public category: one hint, priced once.
let c = contact(16, SamKind::S400, m.area, 100);
let merged = ew::KnowledgeSnapshot::new(100, vec![c], vec![m]);
let only = ew::KnowledgeSnapshot::new(100, vec![c], Vec::new());
assert_eq!(
sim.price_grid_known(&g, DroneKind::Kh101, None, &merged).0,
sim.price_grid_known(&g, DroneKind::Kh101, None, &only).0,
"a matched mark was priced twice"
);
// The legacy mode does not price marks at all.
sim.smart_legacy = true;
let (prices, _) = sim.price_grid_known(&g, DroneKind::Kh101, None, &fresh);
assert!(prices.iter().all(|p| *p == 1.0), "the legacy mode priced a mark");
}
// #146/#149: one order prices every kind over the snapshot its targets were chosen from. A
// contact disclosed while the plan is still being worked out changes neither mode's routes:
// the #146 versioning is preserved for the candidate and the legacy picker alike.
#[test]
fn one_order_prices_every_kind_over_its_own_snapshot() {
let object = DVec3::new(0.0, 70.0, 300.0);
let build = |legacy: bool, disclose: bool| {
let mut sim = Sim::new(149);
sim.smart_legacy = legacy;
let id = sim.id();
let radar = Sam::new(id, SamKind::Radar, DVec3::new(600.0, 70.0, -600.0), 0.0);
sim.intel.observe(&radar, 0, ew::Seen::Emission);
sim.sams.push(radar);
sim.targets.push(object);
sim.target_health.push(100.0);
let mut ground = Ground::default();
let land = Land(|_, _| 64);
let mut out = Out::default();
for _ in 0..20 {
serve(&mut ground, &land, sim.tick);
sim.step(&mut ground, None, &mut out);
}
let order = RaidOrder { kinds: vec![(DroneKind::Kh101, 6), (DroneKind::Shahed, 8)], approach: Approach::Sector, dist: 600.0, aim: Aim::Smart };
sim.order_raid(&order, &[object], &mut out);
if disclose {
// A jamming station gives itself away at the objective while the plan waits for its
// land: every satellite-nav kind prices it, so the live picture bends the routes.
let id = sim.id();
let threat = Sam::new(id, SamKind::Ew, object, 0.0);
sim.intel.observe(&threat, sim.tick, ew::Seen::Jamming);
sim.sams.push(threat);
}
// Work the plan alone (no adaptive ticks): the queue's routes are the plan's own.
while sim.planning() {
serve(&mut ground, &land, sim.tick);
sim.tick += 1;
sim.plan_step(Some(&mut ground), &mut out);
}
sim.queue.iter().map(|(_, d)| (d.id, d.route.clone())).collect::<Vec<_>>()
};
assert_eq!(build(false, false), build(false, true), "the candidate mixed two knowledge versions in one order");
assert_eq!(build(true, false), build(true, true), "the legacy mode lost the #146 one-version pricing");
}
// #149: a report arriving while the raid's drones still wait re-aims the plan's own picks once,
// on a fresh snapshot, within the switch cap — and then the refresh is spent.
#[test]
fn a_report_refreshes_the_unreleased_portion_once() {
let object = DVec3::new(0.0, 70.0, 0.0);
let mut sim = Sim::new(149);
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::S400, object + DVec3::new(20.0, 0.0, 10.0), 0.0));
sim.targets.push(object);
sim.target_health.push(100.0);
let mut ground = Ground::default();
let land = Land(|_, _| 64);
let mut out = Out::default();
for _ in 0..20 {
serve(&mut ground, &land, sim.tick);
sim.step(&mut ground, None, &mut out);
}
sim.order_raid(&order(), &[object], &mut out);
// Force the first sortie's look so a report is pending, then finish the plan: the refresh
// moment is armed only because a report is actually on its way.
let s = sim.recon.sorties.first().expect("no recon sortie").clone();
let d = sim.drones.iter_mut().find(|d| d.id == s.drone).expect("the sortie has no aircraft");
d.pos = s.zones[s.next].center + DVec3::Y * 40.0;
sim.tick += 1;
sim.step_recon(&mut out);
let report_at = sim.recon.sorties.first().unwrap().report_at.expect("no pending report");
while sim.planning() {
serve(&mut ground, &land, sim.tick);
sim.tick += 1;
sim.plan_step(Some(&mut ground), &mut out);
}
assert!(sim.refresh.is_some(), "a pending report did not arm the bounded refresh");
// The report arrives: the mark is in the picture.
sim.tick = report_at;
sim.step_recon(&mut out);
assert!(sim.recon.reports > 0);
let m = *sim.recon.marks.values().next().expect("the report left no mark");
// One drone is past the switch cap: it keeps its aim.
sim.queue[0].1.aim.switches = ew::SWITCH_CAP;
let capped = sim.queue[0].1.id;
sim.step_refresh(&mut out);
assert!(sim.refresh.is_none(), "the refresh was not spent");
assert!(sim.refresh_applied > 0, "the report re-aimed nobody");
assert!(sim.queue.iter().any(|(_, d)| d.intent == ew::Intent::Refresh && d.aim.unit == m.id), "no drone was refreshed onto the mark");
assert!(sim.queue.iter().find(|(_, d)| d.id == capped).unwrap().1.intent != ew::Intent::Refresh, "a drone past the cap was refreshed");
// Spent: a second call changes nothing.
let applied = sim.refresh_applied;
sim.step_refresh(&mut out);
assert_eq!(sim.refresh_applied, applied);
}
// #149: no report never pauses the raid. Past the deadline the refresh is dropped and the
// launches keep the times the plan gave them.
#[test]
fn no_report_never_pauses_the_raid() {
let object = DVec3::new(0.0, 70.0, 0.0);
let mut sim = Sim::new(149);
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::S400, object + DVec3::new(20.0, 0.0, 10.0), 0.0));
sim.targets.push(object);
sim.target_health.push(100.0);
let mut ground = Ground::default();
let land = Land(|_, _| 64);
let mut out = Out::default();
for _ in 0..20 {
serve(&mut ground, &land, sim.tick);
sim.step(&mut ground, None, &mut out);
}
sim.order_raid(&order(), &[object], &mut out);
let s = sim.recon.sorties.first().expect("no recon sortie").clone();
let d = sim.drones.iter_mut().find(|d| d.id == s.drone).unwrap();
d.pos = s.zones[s.next].center + DVec3::Y * 40.0;
sim.tick += 1;
sim.step_recon(&mut out);
while sim.planning() {
serve(&mut ground, &land, sim.tick);
sim.tick += 1;
sim.plan_step(Some(&mut ground), &mut out);
}
let deadline = sim.refresh.as_ref().expect("the refresh was not armed").deadline;
let times: Vec<u64> = sim.queue.iter().map(|(t, _)| *t).collect();
// The report never arrives (the aircraft is lost); the deadline passes.
sim.drones.retain(|d| !recon::is_drone_id(d.id));
sim.tick = deadline + 1;
sim.step_refresh(&mut out);
assert!(sim.refresh.is_none(), "the refresh outlived its deadline");
assert_eq!(sim.refresh_applied, 0);
assert_eq!(sim.queue.iter().map(|(t, _)| *t).collect::<Vec<_>>(), times, "a missing report delayed a launch");
}
// #149: the bearing window forgets, and names why it explores. Few observations, a stale
// result and changed public conditions are distinct typed reasons; the legacy mode keeps its
// fixed share.
#[test]
fn the_bearing_window_forgets_and_names_its_reason() {
let mut sim = Sim::new(149);
sim.tick = 100;
for _ in 0..8 {
sim.learn(3, false);
}
sim.best_bearing();
let r = sim.bearing_report();
assert_eq!(r.reason, ew::BearingReason::Exploiting);
assert_eq!(r.observations, 8);
sim.tick = 100 + ew::OUTCOME_STALE + 1;
sim.best_bearing();
assert_eq!(sim.bearing_report().reason, ew::BearingReason::StaleResults);
sim.tick = 100 + ew::OUTCOME_WINDOW + 1;
sim.best_bearing();
let r = sim.bearing_report();
assert_eq!(r.reason, ew::BearingReason::FewObservations);
assert_eq!(r.observations, 0, "the window did not forget the old outcomes");
let mut sim = Sim::new(149);
sim.tick = 100;
for _ in 0..8 {
sim.learn(3, false);
}
let id = sim.id();
let radar = Sam::new(id, SamKind::Radar, DVec3::ZERO, 0.0);
sim.intel.observe(&radar, 100, ew::Seen::Emission);
sim.sams.push(radar);
sim.best_bearing();
assert_eq!(sim.bearing_report().reason, ew::BearingReason::ConditionsChanged);
sim.smart_legacy = true;
sim.best_bearing();
assert_eq!(sim.bearing_report().reason, ew::BearingReason::FixedShare);
}
// #149: the bearing window and a refresh intent are durable: a save writes them, a load reads
// them back, and an older save without the window loads with an empty one.
#[test]
fn the_bearing_window_and_a_refresh_intent_survive_a_save() {
let mut sim = Sim::new(149);
sim.tick = 500;
sim.learn(2, true);
sim.learn(5, false);
let mut d = sim.make_drone(DroneKind::Shahed, DVec3::new(-500.0, 120.0, 0.0), DVec3::X, DVec3::ZERO);
d.smart = true;
d.intent = ew::Intent::Refresh;
d.aim = ew::Aim::unit(recon::ID_BASE + 1, 500, Confidence::Confirmed);
sim.queue.push((600, d));
let text = sim.air_text().expect("the window and the queue are durable");
assert!(text.contains("airlearn"), "the bearing window was not written");
assert!(text.contains("refresh"), "the refresh intent was not written");
let mut back = Sim::new(1);
back.restore_air(Sim::parse_air(&text).expect("the save reads").expect("the air section is there"));
assert_eq!(back.intel.outcomes().len(), 2);
assert_eq!(back.queue[0].1.intent, ew::Intent::Refresh);
assert_eq!(back.queue[0].1.aim.unit, recon::ID_BASE + 1);
}
+29 -3
View File
@@ -349,6 +349,13 @@ pub struct Strikes {
} }
impl Strikes { impl Strikes {
/// What the counter-strikes hold, about (see `sim::memory`).
pub(super) fn bytes(&self) -> usize {
use super::memory::vec_bytes;
vec_bytes(&self.known) + vec_bytes(&self.flights) + vec_bytes(&self.pending) + vec_bytes(&self.flown)
+ vec_bytes(&self.wrecks) + vec_bytes(&self.cancelled)
+ self.news.iter().map(|s| s.capacity()).sum::<usize>()
}
pub fn new() -> Self { pub fn new() -> Self {
Strikes { stock: TUNE.stock, ..Default::default() } Strikes { stock: TUNE.stock, ..Default::default() }
} }
@@ -1083,7 +1090,22 @@ mod tests {
sim.drones.push(d); sim.drones.push(d);
sim.tick = hidden_launch_tick; sim.tick = hidden_launch_tick;
sim.scout_launch(drone, id, DroneKind::Shahed, DVec3::new(hidden_x, 70.0, 700.0)); sim.scout_launch(drone, id, DroneKind::Shahed, DVec3::new(hidden_x, 70.0, 700.0));
let track = sight::Track { id: drone, kind: DroneKind::Shahed, pos: DVec3::new(0.0, 100.0, 1000.0), vel: -DVec3::Z * 5.0, tick: 100, own_tick: 100, ttl: 100, hits: 3, locked: false }; let track = sight::Track {
id: drone,
class: ClassEst::Firm(Class::Drone),
pos: DVec3::new(0.0, 100.0, 1000.0),
vel: -DVec3::Z * 5.0,
tick: 100,
own_tick: 100,
source: 1,
product: battery::Measure::Fire,
quality: 90,
own_product: battery::Measure::Fire,
own_quality: 90,
ttl: 100,
hits: 3,
locked: false,
};
sim.sams[0].tracks.push(track); sim.sams[0].tracks.push(track);
sim.tick = 100; sim.tick = 100;
sim.step_strikes(&mut ground, None, &mut out); sim.step_strikes(&mut ground, None, &mut out);
@@ -1429,10 +1451,14 @@ mod tests {
fn an_off_map_site_is_found_by_bearing_and_a_strike_there_only_ends_its_launches() { fn an_off_map_site_is_found_by_bearing_and_a_strike_there_only_ends_its_launches() {
let mut sim = Sim::new(5); let mut sim = Sim::new(5);
// Two radars apart watch the start of an off-map site's drones. // Two radars apart watch the start of an off-map site's drones. They hold fire: this test
// is about the sighting and the strike, not about intercepting drones flown at 2 blocks a
// tick (which measure as cruise missiles, #133, and would be engaged on the roles).
for x in [-150.0, 150.0] { for x in [-150.0, 150.0] {
let id = sim.id(); let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::Patriot, DVec3::new(x, 64.0, 0.0), 0.0)); let mut sam = Sam::new(id, SamKind::Patriot, DVec3::new(x, 64.0, 0.0), 0.0);
sam.roles = 0;
sim.sams.push(sam);
} }
let id = sim.sites.add(LaunchSite { let id = sim.sites.add(LaunchSite {
id: 0, id: 0,
+28 -1
View File
@@ -380,6 +380,31 @@ const UNIT_SPEC_LIGHT: SamSpec = SamSpec {
mast: 1.5, mast: 1.5,
}; };
const UNIT_SPEC_OPTICAL: SamSpec = SamSpec {
name: "Оптический пост",
key: "optical",
missile: None,
gun: None,
reload: 0,
scale: 1.0,
rest_pitch: 0.0,
roles: 0,
family: Family::Static,
parts: Parts {
body: "airdef:radar_truck",
launcher: None,
pack: None,
dish: None,
fixed: &[],
spinner: Some(("airdef:radar_panel", 1.2, 0.0, 0.6, -0.2)),
},
mount: (0.0, 0.0),
pivot: DVec3::ZERO,
muzzle: Muzzle::None,
sensor: 0.0,
mast: 2.5,
};
impl SamKind { impl SamKind {
/// Its row of numbers from `catalog/specs.json`. /// Its row of numbers from `catalog/specs.json`.
pub fn spec(self) -> &'static SamSpec { pub fn spec(self) -> &'static SamSpec {
@@ -399,13 +424,14 @@ impl SamKind {
SamKind::Tzm => &UNIT_SPEC_TZM, SamKind::Tzm => &UNIT_SPEC_TZM,
SamKind::Ew => &UNIT_SPEC_EW, SamKind::Ew => &UNIT_SPEC_EW,
SamKind::Light => &UNIT_SPEC_LIGHT, SamKind::Light => &UNIT_SPEC_LIGHT,
SamKind::Optical => &UNIT_SPEC_OPTICAL,
} }
} }
} }
/// Save keys by kind; a rename needs an explicit migration. /// Save keys by kind; a rename needs an explicit migration.
#[cfg(test)] #[cfg(test)]
pub(super) const UNIT_SPEC_KEYS: [(SamKind, &str); 15] = [ pub(super) const UNIT_SPEC_KEYS: [(SamKind, &str); 16] = [
(SamKind::Patriot, "patriot"), (SamKind::Patriot, "patriot"),
(SamKind::Gepard, "gepard"), (SamKind::Gepard, "gepard"),
(SamKind::Pantsir, "pantsir"), (SamKind::Pantsir, "pantsir"),
@@ -421,4 +447,5 @@ pub(super) const UNIT_SPEC_KEYS: [(SamKind, &str); 15] = [
(SamKind::Tzm, "tzm"), (SamKind::Tzm, "tzm"),
(SamKind::Ew, "ew"), (SamKind::Ew, "ew"),
(SamKind::Light, "light"), (SamKind::Light, "light"),
(SamKind::Optical, "optical"),
]; ];
@@ -0,0 +1,8 @@
// Generated by tools/gen_catalog.py from catalog/content.json. Do not edit.
pub const VARIANTS: &[UnitVariant] = &[
UnitVariant { id: "s400_launcher", deploy_item: "airdef:deploy_s400_launcher", kind: SamKind::S400, mode: SamMode::LauncherOnly, role: RadarRole::Multifunction, label: "С-400 — отдельная пусковая", description: "Пусковая С-400 без своей РЛС: работает по данным сети." },
UnitVariant { id: "s500_launcher", deploy_item: "airdef:deploy_s500_launcher", kind: SamKind::S500, mode: SamMode::LauncherOnly, role: RadarRole::Multifunction, label: "С-500 — отдельная пусковая", description: "Пусковая С-500 без своей РЛС: работает по данным сети." },
UnitVariant { id: "radar_search", deploy_item: "airdef:deploy_radar_search", kind: SamKind::Radar, mode: SamMode::Integrated, role: RadarRole::Search, label: "РЛС обзора", description: "Дальний обзор: редкие грубые отметки и область поиска; права на пуск не даёт." },
UnitVariant { id: "radar_track", deploy_item: "airdef:deploy_radar_track", kind: SamKind::Radar, mode: SamMode::Integrated, role: RadarRole::Engagement, label: "РЛС сопровождения", description: "Сопровождение: локальный поиск, два канала точных треков; собственное измерение даёт право на пуск." },
UnitVariant { id: "radar_height", deploy_item: "airdef:deploy_radar_height", kind: SamKind::Radar, mode: SamMode::Integrated, role: RadarRole::Height, label: "Мачтовая РЛС", description: "Мачтовая: поднятая антенна уточняет низкие контакты над рельефом; права на пуск не даёт." },
];
+11 -1
View File
@@ -27,6 +27,8 @@ pub enum SamKind {
Ew, Ew,
/// A searchlight: lights up targets at night for the guns. /// A searchlight: lights up targets at night for the guns.
Light, Light,
/// A passive optical observation post: no radar, no weapon, one class observation at a time (#136).
Optical,
} }
/// How a vehicle is put together: how its launcher or turret moves and is drawn. /// How a vehicle is put together: how its launcher or turret moves and is drawn.
@@ -179,6 +181,14 @@ impl SamKind {
let s = self.spec(); let s = self.spec();
s.missile.is_some() || s.gun.is_some() s.missile.is_some() || s.gun.is_some()
} }
/// Missiles its launcher's magazine holds; `None` without a launcher.
pub fn missile_magazine(self) -> Option<u32> {
self.spec().missile.as_ref().map(|m| m.magazine)
}
/// Whether it has a gun (its bursts are read by the status line).
pub fn has_gun(self) -> bool {
self.spec().gun.is_some()
}
} }
impl Sam { impl Sam {
@@ -325,7 +335,7 @@ pub(super) fn draw_sam_model(sam: &Sam, rng: &mut Rng, out: &mut Out) {
part(out, model, sam.pos + up + DVec3::Y * h * s + base * DVec3::new(0.0, 0.0, back * s), base, s); part(out, model, sam.pos + up + DVec3::Y * h * s + base * DVec3::new(0.0, 0.0, back * s), base, s);
} }
if let Some((model, h, back, size, tilt)) = parts.spinner { if let Some((model, h, back, size, tilt)) = parts.spinner {
let extra = if sam.kind == SamKind::Radar && sam.radar_role == battery::RadarRole::Height { 8.0 } else { 0.0 }; let extra = if sam.kind == SamKind::Radar { sam.radar_profile().mast } else { 0.0 };
let foot = sam.pos + up + DVec3::Y * h * s + base * DVec3::new(0.0, 0.0, back * s); let foot = sam.pos + up + DVec3::Y * h * s + base * DVec3::new(0.0, 0.0, back * s);
for segment in 0..(extra as u32 / 2) { for segment in 0..(extra as u32 / 2) {
part(out, "airdef:radar_mast", foot + DVec3::Y * (segment as f64 * 2.0 + 0.5), base, 1.0); part(out, "airdef:radar_mast", foot + DVec3::Y * (segment as f64 * 2.0 + 0.5), base, 1.0);
+879 -47
View File
File diff suppressed because it is too large Load Diff
+19
View File
@@ -232,6 +232,25 @@ impl WorldCache {
.map(|e| 48 + if matches!(e.fill, Fill::Mixed(_)) { 512 } else { 0 }) .map(|e| 48 + if matches!(e.fill, Fill::Mixed(_)) { 512 } else { 0 })
.sum() .sum()
} }
/// What the cache holds, about: `(sections, other)` — the sections' table and mixed
/// bits, then the rays, queues, questions and blasts expected (see `sim::memory`).
pub fn memory(&self) -> (usize, usize) {
use super::memory::{map_bytes, vec_bytes};
let entry = std::mem::size_of::<Sec>() + std::mem::size_of::<Entry>();
let sections = map_bytes(self.secs.len(), entry)
+ self.secs.values().filter(|e| matches!(e.fill, Fill::Mixed(_))).count() * 512;
let ray_entry = std::mem::size_of::<(u32, [i32; 3])>() + std::mem::size_of::<RayEntry>();
let other = map_bytes(self.rays.entries.len(), ray_entry)
+ map_bytes(self.rays.by_id.len(), std::mem::size_of::<u32>() + std::mem::size_of::<(u32, [i32; 3])>())
+ vec_bytes(&self.rays.out)
+ vec_bytes(&self.urgent)
+ vec_bytes(&self.ahead)
+ map_bytes(self.queued.len(), std::mem::size_of::<Sec>())
+ map_bytes(self.asked.len(), std::mem::size_of::<Sec>() + std::mem::size_of::<u64>())
+ vec_bytes(&self.expected)
+ map_bytes(self.changed_cols.len(), std::mem::size_of::<(i32, i32)>());
(sections, other)
}
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.secs.len() self.secs.len()
} }
+24 -6
View File
@@ -172,21 +172,28 @@ impl WaveConfig {
#[cfg(test)] #[cfg(test)]
mod catalog_tests { mod catalog_tests {
use super::*; use super::*;
use crate::sim::catalog::{AIRCRAFT, UNITS}; use crate::sim::catalog::{AIRCRAFT, UNITS, VARIANTS};
fn assets() -> std::path::PathBuf { fn assets() -> std::path::PathBuf {
std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("assets/airdef") std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("assets/airdef")
} }
fn item_exists(item: &str) { fn item_exists(item: &str) {
let name = item.strip_prefix("airdef:").expect("item namespace"); let name = item.strip_prefix("airdef:").expect("item namespace");
for path in [format!("items/{name}.json"), format!("models/item/{name}.json"), format!("textures/item/{name}.png")] { for path in [format!("items/{name}.json"), format!("models/item/{name}.json")] {
assert!(assets().join(&path).is_file(), "{item}: missing {path}"); assert!(assets().join(&path).is_file(), "{item}: missing {path}");
} }
let definition = std::fs::read_to_string(assets().join(format!("items/{name}.json"))).unwrap(); let definition = std::fs::read_to_string(assets().join(format!("items/{name}.json"))).unwrap();
assert!(definition.contains(&format!("airdef:item/{name}")), "{item}: wrong item model"); assert!(definition.contains(&format!("airdef:item/{name}")), "{item}: wrong item model");
let model = std::fs::read_to_string(assets().join(format!("models/item/{name}.json"))).unwrap(); let model = std::fs::read_to_string(assets().join(format!("models/item/{name}.json"))).unwrap();
assert!(model.contains(&format!("airdef:item/{name}")), "{item}: wrong icon reference"); // The icon reference may be an alias of an existing texture (the optical post uses the
let png = std::fs::read(assets().join(format!("textures/item/{name}.png"))).unwrap(); // radar icon until its own asset lands, #136); what matters is that the PNG it names exists.
let layer = model
.split("\"layer0\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or_else(|| panic!("{item}: no icon reference"));
let texture = layer.strip_prefix("airdef:item/").unwrap_or_else(|| panic!("{item}: bad icon reference {layer}"));
let png = std::fs::read(assets().join(format!("textures/item/{texture}.png"))).unwrap();
assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"), "{item}: invalid PNG signature"); assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"), "{item}: invalid PNG signature");
} }
fn model_exists(model: &str) { fn model_exists(model: &str) {
@@ -208,15 +215,26 @@ mod catalog_tests {
for model in [p.launcher, p.pack, p.dish.map(|v| v.0), p.spinner.map(|v| v.0)].into_iter().flatten() { model_exists(model); } for model in [p.launcher, p.pack, p.dish.map(|v| v.0), p.spinner.map(|v| v.0)].into_iter().flatten() { model_exists(model); }
for (model, _, _) in p.fixed { model_exists(model); } for (model, _, _) in p.fixed { model_exists(model); }
} }
for variant in VARIANTS {
item_exists(variant.deploy_item);
}
} }
#[test] #[test]
fn inventory_entries_match_catalog_and_scenario_order_round_trips() { fn inventory_entries_match_catalog_and_scenario_order_round_trips() {
for item in AIRCRAFT.iter().filter_map(|a| a.launch_item).chain(UNITS.iter().map(|u| u.deploy_item)) { let catalogued = |item: &str| {
AIRCRAFT.iter().any(|a| a.launch_item == Some(item))
|| UNITS.iter().any(|u| u.deploy_item == item)
|| VARIANTS.iter().any(|v| v.deploy_item == item)
};
for item in AIRCRAFT.iter().filter_map(|a| a.launch_item)
.chain(UNITS.iter().map(|u| u.deploy_item))
.chain(VARIANTS.iter().map(|v| v.deploy_item))
{
assert_eq!(crate::ITEMS.iter().filter(|i| **i == item).count(), 1, "{item}"); assert_eq!(crate::ITEMS.iter().filter(|i| **i == item).count(), 1, "{item}");
} }
for item in crate::ITEMS.iter().filter(|i| i.starts_with("airdef:launch_") || i.starts_with("airdef:deploy_")) { for item in crate::ITEMS.iter().filter(|i| i.starts_with("airdef:launch_") || i.starts_with("airdef:deploy_")) {
assert!(AIRCRAFT.iter().any(|a| a.launch_item == Some(*item)) || UNITS.iter().any(|u| u.deploy_item == *item), "uncatalogued item {item}"); assert!(catalogued(item), "uncatalogued item {item}");
} }
let mut wave = WaveConfig::default(); let mut wave = WaveConfig::default();
for (i, count) in wave.counts.iter_mut().enumerate() { *count = i as u32; } for (i, count) in wave.counts.iter_mut().enumerate() { *count = i as u32; }
+147 -6
View File
@@ -1,13 +1,106 @@
//! Text for diagnostics produced by the simulation. //! Text for diagnostics produced by the simulation.
use crate::sim::why::{CheckReason, PartEffect}; use crate::sim::why::{BattleBlock, BattleKind, BattleMark, BattleReason, CheckReason, PartEffect};
use crate::sim::{Comps, Part, SamKind};
fn part_value(part: Part, value: f64) -> String {
if value <= 0.0 { format!("{} отказ", part.short()) }
else { format!("{} {:.0}%", part.short(), value * 100.0) }
}
fn part_value_on(part: Part, value: f64, kind: SamKind) -> String {
if value <= 0.0 { format!("{} отказ", part.short_on(kind)) }
else { format!("{} {:.0}%", part.short_on(kind), value * 100.0) }
}
/// Every worn or failed part of a system, as the monitor and the status line read it.
pub fn parts(comps: &Comps, kind: SamKind) -> String {
Part::ALL.iter().filter(|p| p.on(kind) && comps.get(**p) < 1.0)
.map(|p| part_value_on(*p, comps.get(*p), kind)).collect::<Vec<_>>().join(", ")
}
/// The weakest worn or failed part alone, for a one-line status.
pub fn worst(comps: &Comps, kind: SamKind) -> String {
Part::ALL.iter().filter(|p| p.on(kind) && comps.get(**p) < 1.0)
.min_by(|a, b| comps.get(**a).total_cmp(&comps.get(**b)))
.map(|p| part_value_on(*p, comps.get(*p), kind)).unwrap_or_default()
}
/// The mark's age and where it came from, in the battery's own picture: a relayed plot names
/// its station, never the target's true place or kind.
fn mark_text(mark: &BattleMark) -> String {
let age = if mark.age == 0 { "сейчас".to_string() } else { format!("{:.1} с назад", mark.age as f64 / 20.0) };
let source = if mark.own {
"своя РЛС".to_string()
} else {
mark.source.map_or_else(|| "сеть".to_string(), |i| format!("сеть, РЛС №{}", i + 1))
};
let mut own = String::new();
if let Some(product) = mark.own_product {
if !mark.own {
own = format!(", своё измерение: {}", product.name());
}
}
let forecast = if mark.forecast { ", прогноз" } else { "" };
format!(
"отметка {age}, источник {source}, {} кач.{} {}{}{forecast}",
mark.product.name(),
mark.quality,
mark.class.name(),
own
)
}
fn with_mark(text: String, mark: Option<BattleMark>) -> String {
match mark {
Some(mark) => format!("{text}: {}", mark_text(&mark)),
None => text,
}
}
/// The one headline reason a battery fires or not, as the player reads it.
pub fn battle_text(reason: &BattleReason) -> String {
match reason.kind {
BattleKind::Ready => with_mark("готов к пуску".into(), reason.mark),
BattleKind::ObserveOnly => with_mark("есть только обзор, пуск не разрешён — нужно своё подтверждённое измерение".into(), reason.mark),
BattleKind::AwaitingTrack => with_mark("ждёт сопровождения — своё измерение ещё не разрешает пуск".into(), reason.mark),
BattleKind::ChannelsBusy => {
let channels = reason.channels.map_or_else(|| "каналы заняты".to_string(), |(used, total)| format!("каналы заняты: {used}/{total}"));
with_mark(channels, reason.mark)
}
BattleKind::NoAmmo => {
let mut text = format!("нет боезапаса: ракет {}, очередей {}", reason.rounds, reason.bursts);
if reason.reloading > 0 {
text += &format!(", перезарядка ещё {:.1} с", reason.reloading as f64 / 20.0);
}
with_mark(text, reason.mark)
}
BattleKind::Blocked => {
let text = match reason.block {
Some(BattleBlock::Destroyed) => "уничтожен".to_string(),
Some(BattleBlock::Moving) => "на марше, не стреляет".to_string(),
Some(BattleBlock::Hold) => "огонь запрещён или роли не заданы".to_string(),
Some(BattleBlock::NoWeapon) => "нет оружия (РЛС, склад, РЭБ, прожектор)".to_string(),
Some(BattleBlock::NoTarget) => "нет целей в небе".to_string(),
Some(BattleBlock::NoTrack) => "цель не обнаружена своей РЛС или сетью".to_string(),
Some(BattleBlock::OutOfRoles) => "цель вне ролей комплекса".to_string(),
Some(BattleBlock::OutOfReach) => "цель вне дальности".to_string(),
Some(BattleBlock::Claimed) => "цель уже занята перехватчиками".to_string(),
Some(BattleBlock::Doctrine) => "запрещено доктриной (сектор, охрана или резерв)".to_string(),
Some(BattleBlock::Aiming) => "ещё доворачивается на цель".to_string(),
Some(BattleBlock::Preparing) => "открывает ТПК".to_string(),
Some(BattleBlock::LauncherDown) => "пусковая отказала".to_string(),
Some(BattleBlock::Other) | None => "стрелять сейчас не может".to_string(),
};
with_mark(text, reason.mark)
}
}
}
pub fn reason(reason: &CheckReason) -> String { pub fn reason(reason: &CheckReason) -> String {
match reason { match reason {
CheckReason::Text(text) => text.clone(), CheckReason::Text(text) => text.clone(),
CheckReason::Parts(parts) => format!("узлы: {}", parts.iter().map(|(part, value)| { CheckReason::Battle(battle) => battle_text(battle),
if *value <= 0.0 { format!("{} отказ", part.short()) } CheckReason::Parts(parts) => format!("узлы: {}", parts.iter().map(|(part, value)| part_value(*part, *value)).collect::<Vec<_>>().join(", ")),
else { format!("{} {:.0}%", part.short(), value * 100.0) }
}).collect::<Vec<_>>().join(", ")),
CheckReason::PartEffect(effect) => match effect { CheckReason::PartEffect(effect) => match effect {
PartEffect::SensorFailed => "РЛС отказала: своих измерений нет, стволы не стреляют, ракеты — по данным сети".into(), PartEffect::SensorFailed => "РЛС отказала: своих измерений нет, стволы не стреляют, ракеты — по данным сети".into(),
PartEffect::SensorDamaged { fit } => format!("РЛС повреждена: дальность {:.0}%, обзор вдвое реже при худшем", fit * 100.0), PartEffect::SensorDamaged { fit } => format!("РЛС повреждена: дальность {:.0}%, обзор вдвое реже при худшем", fit * 100.0),
@@ -28,7 +121,21 @@ pub fn reason(reason: &CheckReason) -> String {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::sim::Part; use crate::sim::{Comps, Part, SamKind};
#[test]
fn renders_worn_parts_without_the_reason_prefix() {
let mut comps = Comps([1.0; 6]);
comps.0[Part::Sensor as usize] = 0.4;
comps.0[Part::Tracks as usize] = 0.0;
assert_eq!(parts(&comps, SamKind::Pantsir), "РЛС 40%, Ход отказ");
assert_eq!(worst(&comps, SamKind::Pantsir), "Ход отказ");
// A passive post's sensor is optics; only its sensor is fitted.
let mut optics = Comps([1.0; 6]);
optics.0[Part::Sensor as usize] = 0.4;
assert_eq!(parts(&optics, SamKind::Optical), "Опт 40%");
}
#[test] #[test]
fn damaged_simulation_produces_player_diagnostics_in_order() { fn damaged_simulation_produces_player_diagnostics_in_order() {
use crate::sim::{Sam, SamKind, Sim}; use crate::sim::{Sam, SamKind, Sim};
@@ -44,6 +151,40 @@ mod tests {
assert!(summary < sensor && sensor < tracks, "{lines:?}"); assert!(summary < sensor && sensor < tracks, "{lines:?}");
} }
#[test]
fn the_headline_reason_shows_the_marks_age_and_source_without_the_true_kind() {
use crate::sim::battery::Measure;
use crate::sim::ClassEst;
let mark = BattleMark {
age: 46,
own_age: None,
source: Some(2),
own: false,
product: Measure::Search,
quality: 40,
own_product: None,
forecast: false,
class: ClassEst::Unknown,
};
let reason = BattleReason {
kind: BattleKind::ObserveOnly,
block: None,
sam: 0,
target: Some(7),
mark: Some(mark),
rounds: 4,
bursts: 0,
reloading: 0,
channels: None,
};
let text = battle_text(&reason);
assert!(text.starts_with("есть только обзор"), "{text}");
assert!(text.contains("2.3 с назад"), "{text}");
assert!(text.contains("источник сеть, РЛС №3"), "{text}");
assert!(text.contains("тип не определён"), "{text}");
assert!(!text.contains("Шахед"), "the true kind leaked into the HUD: {text}");
}
#[test] #[test]
fn renders_damage_diagnostics() { fn renders_damage_diagnostics() {
assert_eq!(reason(&CheckReason::Parts(vec![(Part::Sensor, 0.4), (Part::Tracks, 0.0)])), "узлы: РЛС 40%, Ход отказ"); assert_eq!(reason(&CheckReason::Parts(vec![(Part::Sensor, 0.4), (Part::Tracks, 0.0)])), "узлы: РЛС 40%, Ход отказ");
+17 -3
View File
@@ -1016,7 +1016,11 @@ frames = 10
[[step]] [[step]]
command = "airdef stats" command = "airdef stats"
expect.feedback = "В воздухе: 184, ракет: 10, ПВО: 64, сбито: 777, поражений: 1499, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавлено 0, промахов 0, сбито ПВО 0; мир: 5353 секций (250 КБ), запросов 14405, неизвестно 0, лучей 327428 (ударов 6746, неизв. 213), клеток 2282312; взрывы в блоках: 1586 (подтверждено 0, без перемен 175, нет чанка 1330), чужих ответов 0" # Baseline re-measured after the #145 fix (engine 2bcce64): the embedded-cue flood of #134 is
# removed, restoring the intercepts. The pre-#133 522 used the target's true velocity, which the
# measurement-only contract (#133) forbids; ~325 is the restored range. See
# docs/measurements/issue-145-intercept-regression.json for the A/B decomposition.
expect.feedback = "В воздухе: 184, ракет: 4, ПВО: 64, сбито: 325, поражений: 2011, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавлено 0, промахов 0, сбито ПВО 0; мир: 4672 секций (219 КБ), запросов 13570, неизвестно 0, лучей 335118 (ударов 8088, неизв. 158), клеток 2162018; взрывы в блоках: 2041 (подтверждено 0, без перемен 148, нет чанка 1754), чужих ответов 0"
# The Windows #122 path: a Smart order through the UI launch function (`airdef raid` # The Windows #122 path: a Smart order through the UI launch function (`airdef raid`
# is the wave screen's ПУСК button handler) with a fat intel log and EW up — twice. # is the wave screen's ПУСК button handler) with a fat intel log and EW up — twice.
@@ -1041,7 +1045,9 @@ expect.feedback = "Готовый: Массированный удар"
[[step]] [[step]]
command = "airdef raid" command = "airdef raid"
expect.chat = [] # A Smart order sends a recon flight ahead of the strike (#135): the wave screen's ПУСК handler
# reports it. The empty-chat expectation predates #135 and stopped the scenario here (#145).
expect.chat = ["Разведка противника: впереди налёта высланы разведчики"]
[[step]] [[step]]
ticks = 400 ticks = 400
@@ -1061,4 +1067,12 @@ frames = 100
[[step]] [[step]]
command = "airdef stats" command = "airdef stats"
expect.feedback = "В воздухе: 11, ракет: 3, ПВО: 68, сбито: 936, поражений: 1853, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавлено 0, промахов 0, сбито ПВО 0; мир: 6643 секций (311 КБ), запросов 17355, неизвестно 0, лучей 393828 (ударов 9283, неизв. 978), клеток 2953257; взрывы в блоках: 1961 (подтверждено 0, без перемен 234, нет чанка 1727), чужих ответов 0" # Re-measured on the shipped engine 8e711f969 with #146 (one knowledge snapshot per Smart order)
# integrated: the two late Smart raids plan over the versioned picture, so their outcome and world
# queries differ from the #145 agent's pre-#146 measurement (385/2472 on engine 2bcce64). The
# tick-2102 checkpoint above is unaffected by #146 and matches on both engines.
# Re-measured again on engine acfb379aa (the DLSS temporal-stability pin): the late Smart raids'
# outcome shifted with the engine's host answers (417/2463, 7 in the air); the tick-2102 checkpoint
# is unchanged. The ground-oom memory bounds (agent/ground-oom) produce this exact same string —
# they do not move this fight.
expect.feedback = "В воздухе: 7, ракет: 0, ПВО: 68, сбито: 417, поражений: 2463, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавлено 0, промахов 0, сбито ПВО 0; мир: 8527 секций (399 КБ), запросов 19444, неизвестно 0, лучей 413900 (ударов 11127, неизв. 1084), клеток 3197805; взрывы в блоках: 2501 (подтверждено 0, без перемен 194, нет чанка 2305), чужих ответов 0"
+241
View File
@@ -0,0 +1,241 @@
//! The fullscreen-map OOM replica (the `Ground::answer` rehash crash): a large raid watched
//! from all sides through a long session, with the wide ground-query pattern the command map
//! adds on top of the simulation's own. 64 integrated complexes stand where `/airdef deploy`
//! puts them; `airdef wave oreshnik 12 2600` orders come from all sides every 1500 ticks (six
//! raids, so recordings close and the kept replays pile up), and a smart raid maps its whole
//! grid. The render answers are produced exactly as the WASM test host produces them
//! (`horizon_mods::world_query::trace`, flat land at y=64). While the fight runs, a map pass
//! every other tick (the map's redraw pace) sweeps ground queries over a wide view — the
//! fullscreen map asks for the land under its whole grid, not just the flights' columns.
//!
//! The test measures what each consumer holds (`Sim::memory`) through the session, asserts the
//! peak fits the 64 MiB WASM linear memory with headroom for a hashbrown rehash transient, and
//! that the fight still resolves: intercepts happen, the sky clears, and the same seed replays
//! the same ordered combat trace.
//!
//! Run: `cargo test --test ground_oom -- --nocapture`.
use airdef::sim::world::{Fill, RayReply, SectionAnswer};
use airdef::sim::{Aim, Approach, DroneKind, Ground, MemoryReport, Out, RaidOrder, Sam, SamKind, Sim};
use glam::DVec3;
use horizon_mods::world_query::{self, BlockProbe, Cell, Trace};
/// The seed the mod derives on the first tick of a fresh world (`open_world`, game_time 1).
const SEED: u64 = 1u64.wrapping_mul(2654435761) ^ 0x9e37;
const PLAYER: DVec3 = DVec3::new(0.5, 64.0, 0.5);
const DEPLOY_AT: DVec3 = DVec3::new(0.5, 64.0, 8.5);
const GROUND_Y: i32 = 64;
const KINDS: [SamKind; 7] = [SamKind::S400, SamKind::Patriot, SamKind::Pantsir, SamKind::Gepard, SamKind::Nasams, SamKind::IrisT, SamKind::Tor];
/// The engine's cap on a mod's linear memory (`horizon-mods` runtime `MEMORY`).
const WASM_MEMORY: usize = 512 << 20;
/// The peak the mod's own bounds keep it under (well inside the cap): headroom for the allocator,
/// the transient query/answer vectors and save serialization on top of the measured steady state.
const PEAK_BUDGET: usize = 48 << 20;
/// Six raids fought out, recordings closed and replays kept; long enough for the caches to fill.
const TICKS: u64 = 10_000;
struct Flat;
impl BlockProbe for Flat {
fn cell(&mut self, _x: i32, y: i32, _z: i32) -> Cell<'_> {
if y < GROUND_Y { Cell::Solid(None) } else { Cell::Empty }
}
}
fn section_fill(sec: (i32, i32, i32)) -> SectionAnswer {
let base = i64::from(sec.1) * 16;
let solid = (i64::from(GROUND_Y) - base).clamp(0, 16) as usize;
let fill = match solid {
0 => Fill::Empty,
16 => Fill::Full,
_ => {
let mut bits = [0u8; 512];
bits[..solid * 32].fill(255);
Fill::Mixed(Box::new(bits))
}
};
SectionAnswer { sec, fill }
}
fn ray_reply(id: u32, a: DVec3, b: DVec3) -> RayReply {
match world_query::trace(&mut Flat, [a.x, a.y, a.z], [b.x, b.y, b.z]) {
Trace::Clear => RayReply { id, clear: true, hit: false, fraction: 1.0, normal: [0; 3], block: [0; 3] },
Trace::Hit { fraction, normal, block } => RayReply { id, clear: false, hit: true, fraction, normal, block },
Trace::Unknown { .. } => RayReply { id, clear: false, hit: false, fraction: 0.0, normal: [0; 3], block: [0; 3] },
}
}
fn wave(sim: &mut Sim, out: &mut Out, count: u32, aim: Aim) -> u32 {
let o = RaidOrder { kinds: vec![(DroneKind::Oreshnik, count)], approach: Approach::AllSides, dist: 2600.0, aim };
sim.order_raid(&o, &[PLAYER], out)
}
fn deploy(sim: &mut Sim) {
for _ in 0..9 {
for kind in KINDS {
let id = sim.id();
sim.sams.push(Sam::new(id, kind, DEPLOY_AT, std::f64::consts::PI));
sim.settle(id);
}
}
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::S400, DEPLOY_AT, std::f64::consts::PI));
sim.settle(id);
assert_eq!(sim.sams.len(), 64);
}
/// One run of the heavy session: the combat trace (ordered, for the determinism check), the
/// peak memory report and the counters at the end.
struct Run {
trace: Vec<(u64, u32, u32, usize)>,
peak: MemoryReport,
peak_total: usize,
peak_known: usize,
peak_airborne: usize,
sim: Sim,
}
fn run() -> Run {
// Six raids 1500 ticks apart: the sky clears between them, so recordings close and the
// kept replays pile up (the journal's and the poses' budgets are per recording).
run_with(&[(3, 12, Aim::Objects), (1503, 12, Aim::Objects), (3003, 12, Aim::Objects), (4503, 12, Aim::Objects), (6003, 12, Aim::Objects), (7503, 12, Aim::Objects), (1203, 10, Aim::Smart)], TICKS)
}
/// The extreme continuous load: waves overlap, the sky never clears, one recording runs long
/// and the flight tracks reach their points budget (the thinning), with over a thousand objects
/// airborne at once — well past the crash's >200.
fn run_extreme() -> Run {
run_with(&[(3, 40, Aim::Objects), (103, 40, Aim::Objects), (203, 40, Aim::Objects), (1003, 40, Aim::Objects), (2003, 40, Aim::Objects), (3003, 40, Aim::Objects), (4003, 40, Aim::Objects), (5003, 40, Aim::Objects)], 8000)
}
fn run_with(waves: &[(u64, u32, Aim)], ticks: u64) -> Run {
let mut sim = Sim::new(SEED);
let mut ground = Ground::default();
let mut out = Out::default();
let mut columns: Vec<(i32, i32, i32)> = Vec::new();
let mut sections: Vec<SectionAnswer> = Vec::new();
let mut rays: Vec<RayReply> = Vec::new();
let mut changes_epoch = 0u32;
let mut run = Run { trace: Vec::new(), peak: MemoryReport::default(), peak_total: 0, peak_known: 0, peak_airborne: 0, sim: Sim::new(SEED) };
for now in 1..=ticks {
if now == 3 {
deploy(&mut sim);
}
for &(at, count, aim) in waves {
if now == at {
assert!(wave(&mut sim, &mut out, count, aim) > 0, "wave at tick {now} was refused");
}
}
if now == 1103 {
sim.shader = true;
}
let now0 = sim.tick;
ground.world.changed_rev(changes_epoch, 0, false, &[]);
ground.answer(std::mem::take(&mut columns), now0);
ground.world.answer(std::mem::take(&mut sections), now0);
ground.world.answer_rays(&std::mem::take(&mut rays));
sim.day_time = Some(now);
sim.night = (13000..23000).contains(&(now % 24000));
out = Out::default();
sim.step(&mut ground, Some(PLAYER), &mut out);
// The fullscreen map redraws every other tick and asks for the land under its grid:
// a wide walk over the view (32 fresh columns a redraw), as panning and placing do.
if now % 2 == 0 {
let t = now as f64;
let x0 = (t * 13.37).rem_euclid(8000.0) - 4000.0;
let z0 = (t * 7.91).rem_euclid(8000.0) - 4000.0;
for k in 0..32 {
let _ = ground.at(DVec3::new(x0 + k as f64 * 8.0, 0.0, z0 + k as f64 * 3.0), sim.tick);
}
}
columns = ground.take_wanted().into_iter().map(|(x, z)| (x, z, GROUND_Y)).collect();
let _chunks = ground.take_chunks();
let rq = ground.world.take_rays(now);
let sq = ground.world.take_wanted(now);
if !rq.is_empty() || !sq.is_empty() {
changes_epoch = 1;
}
rays = rq.into_iter().map(|(id, a, b)| ray_reply(id, a, b)).collect();
sections = sq.into_iter().map(section_fill).collect();
let airborne = sim.drones.iter().filter(|d| d.alive()).count();
run.peak_airborne = run.peak_airborne.max(airborne);
run.peak_known = run.peak_known.max(ground.known_len());
if now % 100 == 0 {
let m = sim.memory(&ground);
let total = m.total();
if total > run.peak_total {
run.peak_total = total;
run.peak = m;
}
run.trace.push((now, sim.kills, sim.hits, airborne));
}
}
run.sim = sim;
run
}
#[test]
fn the_heavy_map_session_fits_the_memory_budget_and_the_fight_resolves() {
let run = run();
let m = run.peak;
eprintln!("peak airborne {}, peak known columns {}", run.peak_airborne, run.peak_known);
eprintln!("peak memory at the worst sample:\n{}", m.text());
if let Some(rec) = run.sim.recording() {
let (tracks, journal, poses, misc) = rec.memory_parts();
eprintln!("live recording: tracks {:.2} MiB, journal {:.2} MiB, poses {:.2} MiB, misc {:.2} MiB", tracks as f64 / (1024.0 * 1024.0), journal as f64 / (1024.0 * 1024.0), poses as f64 / (1024.0 * 1024.0), misc as f64 / (1024.0 * 1024.0));
}
for (i, rec) in run.sim.replays.iter().enumerate() {
let (tracks, journal, poses, misc) = rec.memory_parts();
eprintln!("replay {}: len {} ticks, tracks {:.2} MiB, journal {:.2} MiB, poses {:.2} MiB, misc {:.2} MiB", i + 1, rec.len, tracks as f64 / (1024.0 * 1024.0), journal as f64 / (1024.0 * 1024.0), poses as f64 / (1024.0 * 1024.0), misc as f64 / (1024.0 * 1024.0));
}
eprintln!(
"end: tick {}, kills {}, hits {}, crashes {}, airborne {}, replays {}",
run.sim.tick,
run.sim.kills,
run.sim.hits,
run.sim.crashes,
run.sim.drones.iter().filter(|d| d.alive()).count(),
run.sim.replays.len()
);
// The load is the crash's load: a large raid, more than 200 objects in the sky at once.
assert!(run.peak_airborne > 200, "the replica never reached the crash's load: {}", run.peak_airborne);
// The fight resolves: intercepts happen and the sky clears by the end of the session.
assert!(run.sim.kills > 100, "the defence stopped intercepting: {}", run.sim.kills);
assert_eq!(run.sim.drones.iter().filter(|d| d.alive()).count(), 0, "the raid never fought out");
// The memory budget: the steady peak plus the worst rehash transient (the old and the new
// table of the biggest map held at once) stays under the headroom target, far under the cap.
let peak = run.peak_total + m.rehash_headroom();
assert!(peak < PEAK_BUDGET, "peak {} MiB (steady {} + rehash {}) over the {} MiB budget:\n{}", peak >> 20, run.peak_total >> 20, m.rehash_headroom() >> 20, PEAK_BUDGET >> 20, m.text());
assert!(peak < WASM_MEMORY, "peak {} MiB over the engine's {} MiB cap", peak >> 20, WASM_MEMORY >> 20);
}
#[test]
fn the_same_seed_replays_the_same_ordered_combat_trace() {
let a = run();
let b = run();
assert_eq!(a.trace, b.trace, "the combat trace diverged between identical runs");
assert_eq!(a.sim.kills, b.sim.kills);
assert_eq!(a.sim.hits, b.sim.hits);
assert_eq!(a.sim.tally.text(), b.sim.tally.text());
assert_eq!(a.peak_known, b.peak_known);
}
#[test]
fn the_continuous_extreme_load_stays_bounded_and_thins_its_tracks() {
let run = run_extreme();
let m = run.peak;
eprintln!("extreme: peak airborne {}, peak known columns {}", run.peak_airborne, run.peak_known);
eprintln!("extreme peak memory:\n{}", m.text());
eprintln!("extreme end: kills {}, hits {}, airborne {}", run.sim.kills, run.sim.hits, run.sim.drones.iter().filter(|d| d.alive()).count());
// Well past the crash's load: the radar picture itself scales with the sky, and the
// recording's tracks must thin under their points budget rather than grow without bound.
assert!(run.peak_airborne > 1000, "the extreme load never materialised: {}", run.peak_airborne);
assert!(run.sim.kills > 100, "the defence stopped intercepting: {}", run.sim.kills);
let rec = run.sim.recording().or_else(|| run.sim.replays.last()).expect("the raid was recorded");
let (tracks, journal, poses, misc) = rec.memory_parts();
let points: usize = rec.tracks.iter().map(|t| t.points_len()).sum();
let max_step = rec.tracks.iter().map(|t| t.step()).max().unwrap_or(0);
eprintln!("extreme recording: len {} ticks, tracks {:.2} MiB ({points} points, max step {max_step}), journal {:.2} MiB, poses {:.2} MiB, misc {:.2} MiB", rec.len, tracks as f64 / (1024.0 * 1024.0), journal as f64 / (1024.0 * 1024.0), poses as f64 / (1024.0 * 1024.0), misc as f64 / (1024.0 * 1024.0));
assert!(max_step > airdef::sim::record::STEP, "the points budget never thinned the tracks");
let peak = run.peak_total + m.rehash_headroom();
assert!(peak < PEAK_BUDGET, "extreme peak {} MiB over the {} MiB budget:\n{}", peak >> 20, PEAK_BUDGET >> 20, m.text());
}
+170
View File
@@ -0,0 +1,170 @@
//! The saturation regression (#145): a deterministic native replica of the WASM budget
//! scenario's checkpoint (`tests/budgets/wasm_flat_budget.toml`, tick 2102). 64 integrated
//! complexes stand where `/airdef deploy` puts them (8 blocks south of the player at the world
//! origin), two `airdef wave oreshnik 40 2600` orders 100 ticks apart, flat land at y=64, the
//! engine's own seed for the first morning. The render answers are produced exactly as the WASM
//! test host produces them (`horizon_mods::world_query::trace`, the same section fill), so the
//! replica replays the same fight the heavy run measures. It exists to explain and guard the
//! intercept count under saturation: the counters and `Sim::launch_audit` say why the systems
//! hold their fire, which the fuel-bound WASM run cannot afford to diagnose per tick.
//!
//! Run: `cargo test --test saturation -- --nocapture`.
use airdef::sim::world::{Fill, RayReply, SectionAnswer};
use airdef::sim::{Aim, Approach, DroneKind, Ground, Out, RaidOrder, Sam, SamKind, Sim};
use glam::DVec3;
use horizon_mods::world_query::{self, BlockProbe, Cell, Trace};
/// The seed the mod derives on the first tick of a fresh world (`open_world`, game_time 1).
const SEED: u64 = 1u64.wrapping_mul(2654435761) ^ 0x9e37;
/// Where the test player stands, and where every deploy lands (`deploy_configured`: 8 blocks ahead).
const PLAYER: DVec3 = DVec3::new(0.5, 64.0, 0.5);
const DEPLOY_AT: DVec3 = DVec3::new(0.5, 64.0, 8.5);
const GROUND_Y: i32 = 64;
/// The fixture's deploy order: nine rounds of seven kinds, then one more S-400 (64 complexes).
const KINDS: [SamKind; 7] = [SamKind::S400, SamKind::Patriot, SamKind::Pantsir, SamKind::Gepard, SamKind::Nasams, SamKind::IrisT, SamKind::Tor];
/// The checkpoint the WASM fixture asserts at step 271.
const CHECKPOINT: u64 = 2102;
/// The flat world the test host answers from: solid below `GROUND_Y`, air above.
struct Flat;
impl BlockProbe for Flat {
fn cell(&mut self, _x: i32, y: i32, _z: i32) -> Cell<'_> {
if y < GROUND_Y { Cell::Solid(None) } else { Cell::Empty }
}
}
/// A section's fill, exactly as `answer_flat_world` computes it.
fn section_fill(sec: (i32, i32, i32)) -> SectionAnswer {
let base = i64::from(sec.1) * 16;
let solid = (i64::from(GROUND_Y) - base).clamp(0, 16) as usize;
let fill = match solid {
0 => Fill::Empty,
16 => Fill::Full,
_ => {
let mut bits = [0u8; 512];
bits[..solid * 32].fill(255);
Fill::Mixed(Box::new(bits))
}
};
SectionAnswer { sec, fill }
}
/// A ray's reply, exactly as `answer_flat_world` traces it.
fn ray_reply(id: u32, a: DVec3, b: DVec3) -> RayReply {
match world_query::trace(&mut Flat, [a.x, a.y, a.z], [b.x, b.y, b.z]) {
Trace::Clear => RayReply { id, clear: true, hit: false, fraction: 1.0, normal: [0; 3], block: [0; 3] },
Trace::Hit { fraction, normal, block } => RayReply { id, clear: false, hit: true, fraction, normal, block },
Trace::Unknown { .. } => RayReply { id, clear: false, hit: false, fraction: 0.0, normal: [0; 3], block: [0; 3] },
}
}
fn order(sim: &mut Sim, out: &mut Out) -> u32 {
let o = RaidOrder { kinds: vec![(DroneKind::Oreshnik, 40)], approach: Approach::Sector, dist: 2600.0, aim: Aim::Objects };
sim.order_raid(&o, &[PLAYER], out)
}
fn deploy(sim: &mut Sim) {
for _ in 0..9 {
for kind in KINDS {
let id = sim.id();
sim.sams.push(Sam::new(id, kind, DEPLOY_AT, std::f64::consts::PI));
sim.settle(id);
}
}
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::S400, DEPLOY_AT, std::f64::consts::PI));
sim.settle(id);
assert_eq!(sim.sams.len(), 64);
}
/// Steps the replica to `ticks`, ordering the two waves and the HD effects where the fixture does,
/// and answering render queries one tick later exactly as the WASM host does.
fn run_to(ticks: u64) -> Sim {
let mut sim = Sim::new(SEED);
let mut ground = Ground::default();
let mut out = Out::default();
let mut columns: Vec<(i32, i32, i32)> = Vec::new();
let mut sections: Vec<SectionAnswer> = Vec::new();
let mut rays: Vec<RayReply> = Vec::new();
let mut changes_epoch = 0u32;
for now in 1..=ticks {
// Commands run between ticks: deploys and the first wave after tick 2, the second after
// tick 102, `airdef shader hd` after tick 1102 (effects only, but kept exact).
if now == 3 {
deploy(&mut sim);
assert!(order(&mut sim, &mut out) > 0, "the first wave was refused");
}
if now == 103 {
assert!(order(&mut sim, &mut out) > 0, "the second wave was refused (the first still planning)");
}
if now == 1103 {
sim.shader = true;
}
// The mod's tick reads the previous tick's answers at the clock it had then (sim.tick).
let now0 = sim.tick;
ground.world.changed_rev(changes_epoch, 0, false, &[]);
ground.answer(std::mem::take(&mut columns), now0);
ground.world.answer(std::mem::take(&mut sections), now0);
ground.world.answer_rays(&std::mem::take(&mut rays));
sim.day_time = Some(now);
sim.night = (13000..23000).contains(&(now % 24000));
out = Out::default();
sim.step(&mut ground, Some(PLAYER), &mut out);
// The queries this tick asks; the host answers them before the next tick.
columns = ground.take_wanted().into_iter().map(|(x, z)| (x, z, GROUND_Y)).collect();
let _chunks = ground.take_chunks();
let rq = ground.world.take_rays(now);
let sq = ground.world.take_wanted(now);
if !rq.is_empty() || !sq.is_empty() {
changes_epoch = 1;
}
rays = rq.into_iter().map(|(id, a, b)| ray_reply(id, a, b)).collect();
sections = sq.into_iter().map(section_fill).collect();
}
sim
}
/// The restored checkpoint, measured on this native replica with the #145 fix in place. The WASM
/// budget fixture measures 325 intercepts / 2011 hits at the same tick on the same fix; the replica
/// replays the same fight but answers render rays with the host tracer one tick later, and the
/// combat is chaotic, so its counters sit a few apart (314 / 2022). Both are deterministic; the
/// WASM run is the authoritative fuel/perf measurement, this one the fast fight-and-audit guard.
const REPLICA_KILLS: u32 = 314;
const REPLICA_HITS: u32 = 2022;
const REPLICA_AIRBORNE: usize = 184;
#[test]
fn checkpoint_replica_holds_the_restored_intercept_count() {
let sim = run_to(CHECKPOINT);
let airborne = sim.drones.iter().filter(|d| d.alive()).count();
eprintln!(
"checkpoint tick {}: airborne {airborne}, missiles {}, kills {}, hits {}, fired {}",
sim.tick,
sim.missiles.len(),
sim.kills,
sim.hits,
sim.sams.iter().map(|s| s.fired).sum::<u32>()
);
eprintln!("tally: {}", sim.tally.text());
eprintln!("audit: {}", sim.launch_audit().text());
assert_eq!(airborne, REPLICA_AIRBORNE, "the sky at the checkpoint");
assert_eq!(sim.kills, REPLICA_KILLS, "intercepts at the checkpoint (deterministic replica baseline)");
assert_eq!(sim.hits, REPLICA_HITS, "hits at the checkpoint");
// The regression guard: the #134 embedded-cue flood dropped this replica to 247 intercepts
// (the WASM run to 243). Restored, it must stay well above that broken count.
assert!(sim.kills >= 300, "the intercept count fell back toward the #145 regression: {}", sim.kills);
}
#[test]
fn the_saturation_loadout_has_no_separate_radar_channels_to_hold() {
// #140 (stale own fire channels held by network relays) is a separate-radar bug: it binds only
// where a profile has channels. This loadout deploys integrated complexes alone — every radar
// is the weapon's embedded one, whose profile has no channel limit — so #140 cannot affect it.
// Fact, not assumption: the A/B that relaxed the channel limit changed nothing (243 -> 243).
let sim = run_to(CHECKPOINT);
assert_eq!(sim.sams.len(), 64);
for s in &sim.sams {
assert_ne!(s.kind, SamKind::Radar, "the fixture deploys no separate radar");
assert_eq!(s.radar_profile().channels, 0, "an embedded radar has no channel limit");
}
}
+4 -2
View File
@@ -50,13 +50,15 @@ expect.feedback = "№2 С-400: режим launcher"
[[step]] [[step]]
command = "airdef deploy radar_track" command = "airdef deploy radar_track"
# The profile is chosen at deployment (#134): the old role switch is refused,
# and says where the profile comes from instead of retuning the station.
[[step]] [[step]]
command = "airdef radar 4 search" command = "airdef radar 4 search"
expect.feedback = "№4 РЛС: роль search" expect.error = "Профиль РЛС задаётся при размещении (deploy radar_search|radar_track|radar_height); переключение в search не меняет оборудование. Доступно on/off."
[[step]] [[step]]
command = "airdef radar 4 engagement" command = "airdef radar 4 engagement"
expect.feedback = "№4 РЛС: роль engagement" expect.error = "Профиль РЛС задаётся при размещении (deploy radar_search|radar_track|radar_height); переключение в engagement не меняет оборудование. Доступно on/off."
[[step]] [[step]]
command = "airdef radar 4 off" command = "airdef radar 4 off"
+100
View File
@@ -126,6 +126,52 @@
{ {
"kind": "Light", "kind": "Light",
"item": "deploy_light" "item": "deploy_light"
},
{
"kind": "Optical",
"item": "deploy_optical"
}
],
"variants": [
{
"id": "s400_launcher",
"kind": "S400",
"mode": "launcher",
"role": "multi",
"label": "С-400 — отдельная пусковая",
"description": "Пусковая С-400 без своей РЛС: работает по данным сети."
},
{
"id": "s500_launcher",
"kind": "S500",
"mode": "launcher",
"role": "multi",
"label": "С-500 — отдельная пусковая",
"description": "Пусковая С-500 без своей РЛС: работает по данным сети."
},
{
"id": "radar_search",
"kind": "Radar",
"mode": "integrated",
"role": "search",
"label": "РЛС обзора",
"description": "Дальний обзор: редкие грубые отметки и область поиска; права на пуск не даёт."
},
{
"id": "radar_track",
"kind": "Radar",
"mode": "integrated",
"role": "engagement",
"label": "РЛС сопровождения",
"description": "Сопровождение: локальный поиск, два канала точных треков; собственное измерение даёт право на пуск."
},
{
"id": "radar_height",
"kind": "Radar",
"mode": "integrated",
"role": "height",
"label": "Мачтовая РЛС",
"description": "Мачтовая: поднятая антенна уточняет низкие контакты над рельефом; права на пуск не даёт."
} }
], ],
"items": [ "items": [
@@ -363,6 +409,60 @@
52 52
] ]
}, },
{
"id": "deploy_optical",
"title": "Развернуть оптический пост",
"color": [
70,
110,
90
]
},
{
"id": "deploy_s400_launcher",
"title": "Развернуть С-400 (пусковая)",
"color": [
60,
80,
50
]
},
{
"id": "deploy_s500_launcher",
"title": "Развернуть С-500 (пусковая)",
"color": [
108,
110,
80
]
},
{
"id": "deploy_radar_search",
"title": "Развернуть РЛС обзора",
"color": [
108,
110,
80
]
},
{
"id": "deploy_radar_track",
"title": "Развернуть РЛС сопровождения",
"color": [
108,
110,
80
]
},
{
"id": "deploy_radar_height",
"title": "Развернуть мачтовую РЛС",
"color": [
108,
110,
80
]
},
{ {
"id": "mover", "id": "mover",
"title": "Пульт перемещения", "title": "Пульт перемещения",
+25
View File
@@ -668,6 +668,31 @@
"muzzle": {"type": "none"}, "muzzle": {"type": "none"},
"sensor": 0.0, "sensor": 0.0,
"mast": 1.5 "mast": 1.5
},
{
"kind": "Optical",
"key": "optical",
"name": "Оптический пост",
"missile": null,
"gun": null,
"reload": 0,
"scale": 1.0,
"rest_pitch": 0.0,
"roles": 0,
"family": "static",
"parts": {
"body": "airdef:radar_truck",
"launcher": null,
"pack": null,
"dish": null,
"fixed": [],
"spinner": ["airdef:radar_panel", 1.2, 0.0, 0.6, -0.2]
},
"mount": [0.0, 0.0],
"pivot": [0.0, 0.0, 0.0],
"muzzle": {"type": "none"},
"sensor": 0.0,
"mast": 2.5
} }
], ],
"missiles": [ "missiles": [
+11
View File
@@ -0,0 +1,11 @@
@echo off
rem Run AirDef with DLSS SR and GPU pass timing. Same game home and mod as play.bat.
chcp 65001 >nul
setlocal
set "HORIZON_DLSS=1"
rem Explicit 2/3 render resolution (DLSS Quality upscaling). The Resolution Scale slider's
rem 100% is DLAA (1:1); this env override pins the upscaling ratio for the A/B test.
set "HORIZON_HD_SCALE=0.67"
set "HORIZON_HD_DEBUG_MOTION="
set "HORIZON_SHADER_PACK_TIMING=1"
call "%~dp0play.bat" %*
+9
View File
@@ -0,0 +1,9 @@
@echo off
rem Run the same scene with native TAAU at the same 2/3 render scale and timing.
chcp 65001 >nul
setlocal
set "HORIZON_DLSS=0"
set "HORIZON_HD_SCALE=0.67"
set "HORIZON_HD_DEBUG_MOTION="
set "HORIZON_SHADER_PACK_TIMING=1"
call "%~dp0play.bat" %*
+27 -13
View File
@@ -30,7 +30,7 @@
## Как собрать ## Как собрать
Через N → «Разместить элементы батареи…» можно расставить элементы в разных местах. Элементы расставляются отдельными пультами: `/airdef give` выдаёт пульты всех вариантов (`deploy_radar_search`, `deploy_radar_track`, `deploy_radar_height`, `deploy_s400_launcher`, `deploy_s500_launcher`), которые ставятся на блок как обычные пульты.
Командные эквиваленты: Командные эквиваленты:
```text ```text
@@ -42,24 +42,38 @@
/airdef battery /airdef battery
``` ```
Нумерацию существующей техники показывает `/airdef battery`. Чтобы переоборудовать её: Нумерацию существующей техники показывает `/airdef battery`:
```text ```text
/airdef battery <номер С-400 или С-500> launcher /airdef battery <номер С-400 или С-500> launcher
/airdef radar <номер РЛС> search /airdef battery <номер С-400 или С-500> integrated
/airdef radar <номер другой РЛС> engagement /airdef radar <номер РЛС> on|off
``` ```
Можно оставить одну многофункциональную РЛС (`multi`) и несколько пусковых. Профиль РЛС задаётся при размещении (`radar_search`, `radar_track`, `radar_height`) и не
Поисковая/мачтовая РЛС даёт подсказку, но не разрешает огонь сама. РЛС сопровождения принимает переключается на ходу: `radar <номер> search|engagement|height` больше не меняет оборудование.
подсказку и должна **сама измерить** цель в своей игровой досягаемости и с учётом рельефа. Можно оставить одну многофункциональную РЛС (`multi`, старые сохранения) и несколько пусковых.
Чужой трек не превращается в собственное измерение. После этого связанные пусковые используют
общую картину и существующее распределение целей. Если РЛС сопровождения уничтожена, свёрнута, - **Обзорная** (`radar_search`): широкая дальность и ранние грубые отметки, медленный оборот,
без каналов уточнения. Права на пуск не даёт.
- **Мачтовая** (`radar_height`): поднятая антенна и лучшее вертикальное измерение уточняют низкие
контакты в локальной зоне; рельеф по-прежнему скрывает цель. Права на пуск не даёт.
- **Сопровождения** (`radar_track`): локальный поиск, электронный оборот, два канала точных
треков. Сеть может подсказать, но станция должна **сама измерить** цель; только собственное
подтверждённое измерение разрешает пуск.
- **Многофункциональная** (`multi`): совместимый универсальный вариант, но не лучший во всём.
Сеть передаёт трек вместе с измерившей станцией, возрастом и качеством. Повторная пересылка не
освежает измерение и не создаёт права на пуск. Уточнение применяется только к сопоставленному
контакту, а число каналов ограничено на каждом тике. Канал удерживает только собственное измерение
станции: когда оно устаревает (станция больше не измеряет контакт), канал освобождается для новой
цели, а сетевой обзорный трек остаётся на месте. Если РЛС сопровождения уничтожена, свёрнута,
потеряла связь или её измерение устарело, новые пуски прекращаются. Уже вылетевшие ракеты потеряла связь или её измерение устарело, новые пуски прекращаются. Уже вылетевшие ракеты
продолжают штатную игровую логику связи/памяти/самонаведения. продолжают штатную игровую логику связи/памяти/самонаведения.
Старые миры и обычные `/airdef deploy s400` / `s500` сохраняют сборную конфигурацию `integrated`. Старые миры и обычные `/airdef deploy s400` / `s500` сохраняют сборную конфигурацию `integrated`.
Режимы, роли, боезапас и использованные контейнеры сохраняются с миром и сценариями. Режимы, роли, боезапас и использованные контейнеры сохраняются с миром и сценариями; новые
сохранения пишут устойчивый ID профиля, старые строки только с ролью читаются как те же профили.
У прежнего игрового С-500 был магазин на четыре ракеты при двух нарисованных ТПК; У прежнего игрового С-500 был магазин на четыре ракеты при двух нарисованных ТПК;
теперь он согласован с двумя физическими ячейками. При загрузке старой расстановки теперь он согласован с двумя физическими ячейками. При загрузке старой расстановки
его загруженный остаток ограничивается новой вместимостью, как при обычном восстановлении боезапаса. его загруженный остаток ограничивается новой вместимостью, как при обычном восстановлении боезапаса.
@@ -96,9 +110,9 @@
## Ограничения ## Ограничения
Роли РЛС и мачта пока используют общую модель машины, с разным поведением/отображением антенны. Все три профиля пока используют общий силуэт машины и антенны (отдельная художественная зона
Отдельные точные модели 91Н6/92Н6/96Л6, машина КП, ручная принадлежность к батарее, отдельные владельца): различаются поведение, цикл, точность, каналы и подпись. Точные модели 91Н6/92Н6/96Л6,
каналы сопровождения и кабельное снабжение пока не добавлены. Подробные режимы и параметры реальных машина КП, ручная принадлежность к батарее и кабельное снабжение не добавлены. Подробные режимы и параметры реальных
комплексов не моделируются. В следующей серии добавлены конечная работа двигателя/coast (#120), комплексов не моделируются. В следующей серии добавлены конечная работа двигателя/coast (#120),
доставка RM48U через ТЗМ (#118), переключение излучения (#121) и укрытия от непрямого blast (#119). доставка RM48U через ТЗМ (#118), переключение излучения (#121) и укрытия от непрямого blast (#119).
Текущий объём и ограничения описаны в [техническом журнале](CODEX-HANDOFF.md). Текущий объём и ограничения описаны в [техническом журнале](CODEX-HANDOFF.md).
+60
View File
@@ -4,6 +4,27 @@
Рабочая ветка `kimi-work`; issues не закрывать, публиковать комментарии с коммитом и проверками. Рабочая ветка `kimi-work`; issues не закрывать, публиковать комментарии с коммитом и проверками.
Движок — отдельный `chexit/horizon-airdef`, ветка `airdef`, подключён точным gitlink `horizon/`. Движок — отдельный `chexit/horizon-airdef`, ветка `airdef`, подключён точным gitlink `horizon/`.
## #91: типизированные варианты комплексов — первый slice (20 ноября 2026)
Ветка `agent/91-variants` (worktree `/tmp/airdef-issue91`), база `60f1bf0fd`
(рабочая ветка `kimi-work`), движок `ed751714e` не менялся. Минимальный вариант,
который требует текущий код: развёртывание «элементов батареи» (`s400_launcher`,
`s500_launcher`, `radar_search/track/height`) описывалось тремя разрозненными
ручными списками — таблица меню `BATTERY_DEPLOY` и `match` конфигурации в `lib.rs`
и цепочка ids в `commands.rs`. Они сведены в каталог: `catalog/content.json → variants`
(ключи `mode`/`role` переиспользуют существовавшие ключи сохранений `SamMode`/`RadarRole`),
`gen_catalog.py` генерирует `unit_variants_generated.rs` → `catalog::UnitVariant`
(`id/kind/mode/role/label`), Python-валидация отвергает дубли, чужие kinds/modes,
совпадение с ключами/предметами. Меню батареи, клик по строке и Tab-дополнение
`deploy` читают таблицу; генерация порядка строк прежняя, тексты прежние. **Профили
боезапаса по вариантам не заводились**: для «разных ракет/профилей по батареям» требуется
согласованный профиль и явно подписанная игровая абстракция (замечание ревью по
PAC-3 в комментарии #91) — следующий slice, не этот. Save/replay/тексты не менялись:
вариант — только ключ развёртывания поверх тех же полей `sam`, сейв-формат, порядок
и `durable mark` без изменений. То же видно и в `airdef-core` (общая симуляция).
Остаток #91: профили боезапаса по вариантам, объединение Python-генераторов и других списков,
игровая приёмка.
## Текущее состояние: 4 ноября 2026 ## Текущее состояние: 4 ноября 2026
Последнее продолжение пяти задач: [CONTINUATION-2026-11-04.md](CONTINUATION-2026-11-04.md). Последнее продолжение пяти задач: [CONTINUATION-2026-11-04.md](CONTINUATION-2026-11-04.md).
@@ -621,6 +642,45 @@ kills 59→58, 59→58, 56→63; hits 7→7, 7→9, 8→3; потери ЗРК 3
появляется). Adapter: `the_air_section_of_a_save_is_written_and_read_by_the_adapter` (запись/чтение появляется). Adapter: `the_air_section_of_a_save_is_written_and_read_by_the_adapter` (запись/чтение
секции, замена не слияние, старый save без секции, сценарий без воздуха). секции, замена не слияние, старый save без секции, сценарий без воздуха).
### #149: Smart v2 поверх #146 — единая разведкартина, цены отметок, ограниченный refresh, окно bearing
Продолжение #127/#135 **поверх уже интегрированного #146** (`KnowledgeSnapshot { tick, contacts, marks }`,
`knowledge_now()`, `Plan.knowledge`, `RouteJob.known`, версионные `price_grid_known`/restore). Инфраструктура
#146 не дублируется и не меняется: один снимок на приказ, цены по `known.tick`, версионный restore — как есть.
Новое наслоение:
- **Один публичный тип наблюдения** `sim::observe::Observation` (область/радиус, канал `recon::Source`,
возраст, уверенность, категория/роль/тип, качество, флаг `matched`). `observe::merge` сводит `Contact` и
`Mark` в один список **только по публичным признакам** (перекрытие области + точное совпадение категории);
coarse `Unknown` и противоречащая категория остаются отдельными подсказками, контакт не переписывает
тип/место, отметка добавляет лишь свежесть и refined-роль; `recon.truth` и реальные id не участвуют.
`KnowledgeSnapshot::observations()` (аддитивно) отдаёт этот список; одна шкала `Observation::rank`
заменила две разные в `radar_strikes`, `choose_target` и адаптивном выборе (сигнатуры kimi-work сохранены).
- **Цены отметок** в существующем `price_grid_known`: свежая (Probable/Confirmed) отметка launcher/gun/jammer
ценит клетки по published-огибающей категории (`observe::category_envelope`), взвешенной уверенностью
(Confirmed ×1, Probable ×0.5); radar-отметка кормит сетевую веру ПУ рядом (`observe::radar_envelope`);
совпавшая с контактом ценится один раз через контакт; doubtful не ценится.
- **Ограниченный refresh не выпущенной части**: пока разведчики в воздухе, при завершении плана взводится
`ew::Refresh { deadline, reports }` с абсолютным дедлайном `REFRESH_WINDOW=600`. `step_refresh` один раз,
при приходе донесения, перенацеливает queued-дроны с intent Plan/Sead на свежий снимок (typed
`Intent::Refresh`, приоритет SEAD) в пределах `SWITCH_CAP` и бюджетов. Нет донесения — пуски не задерживаются.
- **Окно bearing**: `Intel.outcomes` — bounded `VecDeque<Learned>` (48 записей, окно 12000 тиков);
`best_bearing` кандидата скорит окно и адаптирует долю исследования по typed `BearingReason`
(few/stale/conditions-changed/exploiting); «условия» — fingerprint публичной картины, не скрытое состояние.
Legacy сохраняет пожизненные kills/hits и фиксированные 0.3 (`FixedShare`). Диагностика —
`Sim::bearing_report()`, поля `bearing/refresh_waiting/refresh_applied/observations` в `EnemyPictureReport`.
- **Сравнительный runner** `cargo run --release --example smart_bench`: simple / current (legacy) / candidate
на seed 1/7/42, сценарии open/hills/config-change/recon-lost; JSON и строки (полезные решения, разнообразие,
jitter ≥2 переключений, reasons/intents, bearing reason, refresh, CPU p95/max, worst jobs).
`Sim::smart_legacy` воспроизводит текущий Smart kimi-work (включая #146) для честного сравнения;
`harness::run_with_hook` меняет оборону между волнами и сбивает разведчика до донесения. Лёгкий режим и
bounded jobs не тронуты; policy не читает здоровье/заряды/скрытые переключатели/позиции мира.
- **Тесты** `sim::smart_tests` + `sim::observe::tests`: метаморфный hidden-layout до/после наблюдения, дедуп
по публичным признакам, отметки в ценах, одна версия на приказ (обе моды чтят #146), bounded refresh
(срабатывает один раз / не паузит), окно bearing и причины, durable окна (`airlearn`) и `Intent::Refresh`.
Регрессия relief-версий сохранена; стена в её фикстуре расширена по z, чтобы пересекать любой восток-запад
маршрут после смены порядка назначений кандидатом.
## Что следующему агенту проверить в первую очередь ## Что следующему агенту проверить в первую очередь
1. На Windows: обновление сабмодуля через `all`, сохранение/перезаход, рабочий цикл игры. 1. На Windows: обновление сабмодуля через `all`, сохранение/перезаход, рабочий цикл игры.
+179
View File
@@ -0,0 +1,179 @@
# Проверка DLSS SR на Windows / RTX
Это тестовая, а не релизная сборка #124. Она включает native DLSS Super Resolution через Vulkan и сохраняет обычный TAAU как fallback. Frame generation здесь нет; RTX 3060 его и не поддерживает.
## Temporal stability: дрожь с DLSS и мерцание native TAAU (ветка agent/dlss-temporal-stability)
### Что исправлено
**DLSS (сильная дрожь всего изображения).** Буфер motion в G-buffer — это current→previous в *джиттеренных* пикселях рендера (оба кадра со своим джиттером). Флаги создания DLSS-контекста не включали `MVJittered`, поэтому NGX использовал векторы как есть **и** применял переданный `jitter_offset` — джиттер камеры учитывался дважды, отсюда «дрожит адски». Исправление: флаг `DlssFeatureFlags::JitteredMotionVectors` (`horizon/crates/horizon-client/src/gfx/hd/dlss.rs`, коммит f536fa958). С ним NGX сам вычитает разницу джиттеров из векторов по per-frame `jitter_offset`.
Контракт сверен по первоисточникам (не по догадкам):
- **NVIDIA DLSS Programming Guide** (редакция 31 марта 2026, SDK 310.x — тот же, что оборачивает `dlss_wgpu` 6.0.0), `doc/DLSS_Programming_Guide_Release.pdf` из [NVIDIA/DLSS](https://github.com/NVIDIA/DLSS):
- §3.6/3.6.1: векторы — current→previous, **в пикселях render-разрешения**, начало координат сверху слева, y вниз; формат RG16F/RG32F. Наш буфер (`Rg16Float`, `terrain.wgsl`/`entity.wgsl` `motion_pixels`) ровно такой.
- §3.6.2: `MVJittered=1` — «DLSS then internally subtracts jitter from the motion vectors using the jitter offset values provided during the Evaluate call»; `MVLowRes=1` — векторы в render-разрешении (NGX сам их dilate'ит). Оба флага теперь стоят.
- §3.6.3: `InMVScaleX/Y = 1.0`, если масштабирование не нужно. Пиксельные векторы не масштабируются — `motion_vector_scale: [1,1]` оставлен. **Важно:** совет `{1/renderWidth, 1/renderHeight}` из гайда Streamline относится к константе `sl::Constants::mvecScale` самого Streamline: его плагин (`source/plugins/sl.dlss/dlssEntry.cpp`) умножает её обратно на renderWidth и передаёт в NGX `MV.Scale = 1.0` для pixel-space (`mvecPixelSpace ? 1.0f : mvecScale.x * renderWidth`). `dlss_wgpu` зовёт NGX напрямую, без Streamline, поэтому у нас 1.0.
- §3.7.3: `jitter_offset` — джиттер текущего кадра **в пикселях render-таргета**, в той же системе координат, что векторы (y вниз), в пределах ±0.5. `scene.jitter_px` именно такой.
- §3.8.1: `DepthInverted=1` для reversed-Z — уже стоял.
- Заголовок NGX `include/nvsdk_ngx_defs.h` (NVIDIA/DLSS): флаг `NVSDK_NGX_DLSS_Feature_Flags_MVJittered = 1 << 2`.
- Исходник Streamline `dlssEntry.cpp`: `motionVectorsJittered == eTrue → MVJittered`, jitter передаётся как есть.
**Native TAAU (слабое мерцание, особенно на воде).** Две причины найдены и исправлены (коммиты 26ee82398, acfb379aa):
1. **Вода анимируется без геометрического движения**: волны наклоняют нормали, преломление/SSR-отражение/блики меняются каждый кадр, а motion-буфер на пикселях воды несёт движение только дна. История TAA конфликтовала с кадром — мерцание. Теперь TAA-проход читает собственную глубину воды (binding 7) и снижает вес истории там, где вода анимируется быстрее всего — вблизи камеры (до 0.8 для `fs_taa`, до 0.7 для `fs_taau`, спад до 96 блоков; дальняя вода с медленными волнами сохраняет полный вес). Это reactive mask; качество не снижается, TAA не выключается.
2. **Листва и растения качаются на ветру**, но motion-буфер знал только камеру (`prev_clip` строился из текущей wind-позиции). Теперь предыдущая позиция вершины вычисляется с ветром *прошлого* кадра (`Globals.hd_motion.zw` = прошлые секунды/сила ветра, `terrain.wgsl` `wind_offset_at`) — листва несёт собственное движение, мерцание кроны и дальней лесополосы уходит.
Тени: каскады уже привязаны к текселям в мировых координатах (`hd::cascades`, f64 snap) — crawl отсутствует; дальняя каскада перерисовывается через кадр (`HORIZON_HD_SHADOW_FAST`), её матрица между перерисовками сдвигается за камерой — это корректно. Точность motion на дальних дистанциях достаточная: f16 хранит субпиксельные значения точно, f32-разница clip-координат на 500 блоках даёт ошибку ~1e-4 px.
### Что проверить на RTX (порядок)
1. Собрать с DLSS: `py tools\airdef.py all` (ветка `agent/dlss-temporal-stability`), запустить `test-dlss.bat --world "Имя мира"`. В `%APPDATA%\horizon\logs\latest.log` должна быть строка `DLSS Super Resolution: [1706, 960] -> [2560, 1440]` (для 1440p при масштабе 2/3) и не должно быть `using native TAAU` / `DLSS evaluation failed`.
2. **Статичная сцена — главный тест.** Встать неподвижно, смотреть на дальние статичные объекты (горы, строения) 10–15 секунд. Изображение не должно дрожать/вибрировать. Затем медленно повернуть камеру — не должно быть smear/ghosting на статичном мире. Для увеличения используй встроенный Windows Screen Magnifier (Win+«+», отключить «Smooth edges of images and text») — гайд §8.4.1.
3. **Движение**: `/airdef move 2` или `/airdef wave shahed 8 300` — движущиеся модели не должны двоиться/размазываться; дым и вспышки смотреть отдельно.
4. **Вода и листва, DLSS off** (`dlss off` через меню мода или контрольный сокет, без перезапуска): постоять у воды с ветром — мерцание/«вибрация» воды и кроны должны заметно уменьшиться против старой сборки. Блики на воде остаются живыми (это анимация, не артефакт).
5. **Motion-визуализация** (отдельный прогон, не для замера качества): `HORIZON_HD_DEBUG_MOTION=1` — на статичной сцене векторы должны быть почти нулевыми (субпиксельная разница джиттеров), без крупных пятен. Это проверяет буфер, который видит NGX.
6. Скриншоты одного ракурса: DLSS on / DLSS off, статика и движение; лог обоих прогонов.
Опционально (для глубокой отладки джиттера): dev-версия `nvngx_dlss.dll` (фича `debug_overlay` у `dlss_wgpu` + `DLSS_SDK` с dev-профилем) даёт оверлей §8.2 и jitter-отладку §8.4: offsets всегда внутри ±0.5, хоткеи CTRL+ALT+F9/F10 меняют знак/оси джиттера на лету.
### Если дрожь осталась: варианты по порядку (быстрая итерация)
Все правки — в `horizon/crates/horizon-client/src/gfx/hd/dlss.rs` (движок, ветка `agent/dlss-temporal-stability`), пересборка только игры.
- **Вариант A (проверка знака/осей джиттера).** В `render()` передавать `jitter_offset: [jitter[0], -jitter[1]]` (или `[-jitter[0], jitter[1]]`, или поменять оси местами). По документации наша система координат совпадает с NGX, так что это маловероятно, но гайд §8.4.1 советует именно это при остаточной дрожи. Признак: дрожь уменьшается при одном из знаков/осей.
- **Вариант B (нормализация Streamline).** `motion_vector_scale: Some([1.0 / self.world[0] as f32, 1.0 / self.world[1] as f32])`. Противоречит §3.6.3 для сырого NGX (и исходнику Streamline), но дёшево проверяется. Признак: если дрожь была от масштаба, картинка сразу стабилизируется; если станет хуже/размазаннее — вернуть `[1,1]`.
- **Вариант C (неджиттеренный буфер вместо флага).** Убрать `JitteredMotionVectors` из `FEATURE_FLAGS` и добавить конверсионный проход перед NGX: новый `Rg16Float`-таргет world-размера, fullscreen-шейдер пишет `motion.xy + frame.taa_params.zw - frame.prev_jitter.xy` (в точности коррекция `fs_taau`, taa.wgsl:234), в `DlssSuperResolutionRenderParameters.motion_vectors` подать его. Это зеркальный путь: NGX получает векторы без джиттера и использует их напрямую (§3.6.2, флаг=0). Признак: если флаг MVJittered в драйверной версии NGX работает иначе, чем описано, этот путь стабилизирует картинку.
Если дрожь ушла, но **только вода/анимированные материалы** двоится под DLSS — это отдельная задача: у NGX есть входы transparency/responsivity mask, `dlss_wgpu` передаёт их пустыми; native-путь теперь имеет reactive mask для воды.
### Что проверено на Mac, а что ждёт RTX
Проверено (macOS, Metal, без DLSS-устройства): вся сюита `cargo test -p horizon-client --lib` — 1242 passed / 0 failed; GPU A/B smoke `taau_gpu_smoke_still_surface_ab` (Apple M5): исправленный decode даёт ошибку 0.0048 на уровне собственного пространственного фильтра (0.00478) и разброс по фазам 0.0029 против 0.0156 у старого decode; shader-валидация naga + трансляция HLSL для всех HD-шейдеров и terrain/entity; раскладка `HdFrame`/`Globals`; детерминизм джиттера и репроекции (численные тесты на всех фазах Halton); сборка бинарника без фичи `dlss`. Сам `dlss.rs` на Mac не компилируется (cfg windows/linux + feature) — флаг и тест `the_feature_flags_match_the_motion_contract` проверятся на Windows-сборке.
Ждёт RTX: собственно NGX-оценка (стабильность статики, движение, вода), тест флага в `cargo test -p horizon-client --features dlss --lib gfx::hd::dlss`, визуальное сравнение воды/листвы с reactive mask и wind-motion.
## Переключатель DLSS
В сборках с фичей `dlss` DLSS теперь включён по умолчанию, а не только через `HORIZON_DLSS=1`:
- Меню мода: **N → Огонь, ремонт, эффекты… → DLSS (NVIDIA)**. Строка показывает состояние; на устройстве без DLSS переключение — мягкий no-op («недоступен»), запрос сохраняется и применяется при следующем запуске, если устройство его поддерживает.
- Команда контрольного сокета: `dlss on|off|status` (`available` — открыт ли DLSS-девайс, `dlss` — запрос игрока).
- Настройка `dlss:true|false` в `horizon-graphics.txt`; `HORIZON_DLSS=1|0` по-прежнему переопределяет её при старте.
Выключение переходит на native TAAU со следующего кадра: разделённые истории #137 делают переход чистым в обе стороны (NGX сбрасывается при возобновлении, первый native кадр не читает устаревшую историю). Включение после старта с выключенным DLSS применяется при следующем запуске — девайс открывается под DLSS только при старте. Разрешение рендера — выбор игрока в настройках Horizon (слайдер Resolution Scale, см. ниже).
Для A/B ниже `test-dlss.bat`/`test-native.bat` работают как раньше; если старт был с DLSS, оба режима можно снять и одним прогоном через `dlss off`/`dlss on` без перезапуска.
## Масштаб разрешения (Resolution Scale) и DLSS
**Баг (исправлен, ветка `agent/resolution-scale`).** Слайдер Resolution Scale (50–200%, `horizon-graphics.txt` `resolutionScale`) писал `world_post.scale`, но при включённом HD решение о масштабе мира принимал `hd::scale_override()`: с DLSS (включён + девайс открыт) он **всегда** возвращал `Some(2/3)`, и `world_post.prepare()` брал `hd_scale.unwrap_or(scale)` — слайдер не читался вовсе. Картинка и FPS не менялись от 50/80/100/200%. Без DLSS и без `HORIZON_HD_SCALE` слайдер работал (native TAAU), поэтому баг был виден только на RTX.
**Семантика после исправления** (`hd::scale_override(slider)`, чистое решение `scale_for`, юнит-тест `the_resolution_slider_drives_hd_scale`). Приоритет, первое совпадение выигрывает:
1. **Film quality** (`render.set-film-quality`, захват) — мир в полный размер окна.
2. **`HORIZON_HD_SCALE`** (0.25–1, читается один раз при старте) — явное dev-переопределение, сильнее слайдера.
3. **DLSS оценивает кадр** (запрос включён + SDK открыт): слайдер — это render-размер, ограниченный размером выхода (апскейлер не рендерит больше выхода), **монотонно**: **100% = render 1:1 (DLAA**, neural AA без апскейла), **ниже 100%** — DLSS апскейл (50% → половина, 80% → 0.8, 67% ≈ Quality); **выше 100%** мир рендерится в размер выхода (суперсэмплинг >1 — только native TAAU с выключенным DLSS).
4. **Иначе (native TAAU)** — слайдер как есть, 0.5–2.0, включая суперсэмплинг; при 1.0 без HD/FXAA мир рисуется прямо в экран (как раньше, бит-в-бит).
**Живое обновление.** `set_world_post` (слайдер) пишет `world_post.scale`; `hd_scale` пересчитывается каждый кадр до джиттера, поэтому джиттер и motion-буфер (`Globals.hd_motion.xy`) соответствуют размеру мира этого же кадра. `world_post.prepare()` пересоздаёт таргет при смене размера, `Hd::resize` → `Taa::resize` сбрасывает истории и зовёт `Dlss::resize(world, out)`. Контекст NGX создаётся под размер выхода; render-размер передаётся в каждой evaluate через `partial_texture_size`, поэтому при смене слайдера контекст **сохраняется**, пока новый render-размер вписывается в `render_resolution_range()` контекста (динамическое разрешение NGX); вне диапазона или при смене размера окна — пересоздание. Пересоздание ждёт idle девайса (`DlssSuperResolution::drop`), поэтому reuse важен для живого слайдера. Первая evaluate после смены масштаба идёт с `InReset` (истории сброшены в `Taa::resize`) — ghosting между масштабами исключён. Контракт motion/jitter #143 не тронут: `MVJittered`, `MVLowRes`, `jitter_offset` в render-пикселях, `motion_vector_scale [1,1]`.
**Что проверено на Mac (M5/Metal, без DLSS-устройства):** юнит-тест приоритета (все ветки, включая DLSS-арифметику — она платформенно-независима); GPU-тест `gfx::world_post::tests::the_world_target_follows_the_resolution_slider` — таргет мира следует за слайдером 50/100/200% (960×540 / 1920×1080 / 3840×2160), live-ресайз без пересоздания `Post`, `hd_scale` заменяет слайдер (0.67, 0.5, 1.0); `taau_gpu_smoke_still_surface_ab` проходит; вся сюита `cargo test -p horizon-client --lib`; сборка без фичи `dlss`.
**Что ждёт RTX (обязательно проверить):**
1. Слайдер 50 / 80 / 100 / 200% при включённом DLSS: в `latest.log` строка `DLSS Super Resolution: [w, h] -> [W, H]` меняет render-размер (для 1440p: 50% → [1280, 720], 80% → [2048, 1152], 100% → [2560, 1440] (DLAA, 1:1), 200% → [2560, 1440]); картинка и FPS меняются от 50/80/100 (100% = DLAA, тяжелее апскейла); 200% при DLSS даёт render в размер выхода (не суперсэмплинг).
2. Статичная сцена после каждого переключения слайдера 10–15 с: нет дрожи/вибрации (регрессия #143), нет ghosting после смены масштаба (первый кадр с `InReset`).
3. Движение (`/airdef move 2`, налёт): модели не двоятся; дым/вспышки как раньше.
4. Живой прогон слайдера туда-сюда: без перезапуска, без микрофризов от пересоздания контекста на каждом шаге (в логе — строки размера, но не шторм пересозданий; reuse в диапазоне NGX). Если NGX Auto не принимает render-размер вне своего диапазона — в логе будет `DLSS context creation failed` / `DLSS evaluation failed` и fallback на native TAAU; прислать лог.
5. DLSS off → слайдер 200%: суперсэмплинг native TAAU (мир 2× окна, FPS ниже, картинка чище); DLSS on → возврат к capped-масштабу.
6. `HORIZON_HD_SCALE=0.67` по-прежнему переопределяет слайдер; film quality — полный размер.
## Быстрый старт
1. Один раз запусти обычный Horizon Launcher, чтобы он подготовил ресурсы Minecraft 26.3.
2. Распакуй `airdef-dlss-windows-x86_64.zip`. Не удаляй `nvngx_dlss.dll`: он должен остаться рядом с `horizon-client.exe`. Если Windows сообщает об отсутствии `MSVCP140.dll` или `VCRUNTIME140.dll`, поставь Microsoft Visual C++ Redistributable 2015–2022 x64.
3. Запусти **`test-dlss.bat --world "Имя мира"**. Скрипт сам включит мод, `HORIZON_DLSS=1` и GPU pass timing.
4. В игре выполни одну и ту же последовательность:
```text
/airdef shader hd
/airdef deploy radar_track
/airdef deploy s400
/airdef damage off
/airdef wave shahed 8 300
```
Подожди около 20 секунд, пока начнётся налёт. Для движущихся моделей подойдёт и `/airdef move 2`.
5. Посмотри на ракеты/технику, сделай скриншот и запиши FPS/кадр. Не включай `HORIZON_HD_DEBUG_MOTION` при измерении качества или FPS.
6. Выйди и запусти **`test-native.bat --world "Имя мира"`**. Он использует TAAU с тем же масштабом 2/3 и тем же GPU timing. Повтори ту же сцену, ракурс и скриншоты.
Для честного A/B используй один мир и одну позицию камеры. Если налёт уже закончился, запусти следующий `/airdef wave shahed 8 300`. Не меняй разрешение окна или HD-настройки между прогонами.
## Что подтверждает, что DLSS действительно включён
В `%APPDATA%\horizon\logs\latest.log` должна быть строка вроде:
```text
DLSS Super Resolution: [1280, 720] -> [1920, 1080]
```
Не должно быть `using native TAAU`, `FeatureNotSupported`, `no DLSS context` или `DLSS evaluation failed`. Само наличие повышенного FPS не считается подтверждением backend.
Скрипты включают `HORIZON_SHADER_PACK_TIMING=1`, поэтому в лог попадают GPU pass timings. Сравнивай не только средний FPS, но и микрофризы, дым, вспышки и движущиеся ракеты.
## Что прислать
- `%APPDATA%\horizon\logs\latest.log` после DLSS-прогона.
- Скриншоты одного ракурса с DLSS и native TAAU, желательно с движущейся техникой/ракетой и отдельно с дымом.
- Скриншот FPS/debug overlay обоих режимов или текстовые значения FPS.
- Если есть артефакты: кратко, что именно не так и меняется ли оно при движении камеры.
- Сохранения миров присылать не нужно.
## Если игра не запускается
- Сначала проверь, что `nvngx_dlss.dll` лежит рядом с `horizon-client.exe` и ресурсы подготовлены лаунчером.
- При ошибке про Vulkan/NGX пришли `latest.log`: там должна быть конкретная причина. Не подменяй её догадкой про драйвер.
- При `FeatureNotSupported` или другом сбое игра должна продолжить работу через native TAAU; это будет видно в логе. Такой запуск не является успешным тестом DLSS.
- `test-native.bat` нужен только для сравнения; он не включает DLSS.
## Сборка самостоятельно вместо готового архива
Нужны только Rust (с `x86_64-pc-windows-msvc` и `wasm32-unknown-unknown`) и Visual Studio Build Tools с C++. Ветка — `kimi-work`.
NVIDIA DLSS SDK, Vulkan SDK и LLVM ставить вручную больше не нужно: на Windows с NVIDIA RTX `airdef.py` сам скачивает всё, что читает `dlss_wgpu` при сборке (включая `libclang.dll` для bindgen), и кладёт `nvngx_dlss.dll` рядом с `horizon-client.exe`.
```powershell
git clone --branch kimi-work https://gitea.maoniao.team/chexit/airdef.git
cd airdef
rustup target add x86_64-pc-windows-msvc wasm32-unknown-unknown
py tools\airdef.py all
```
`all` делает `fork`, `game`, `mod`, `install`. На Windows + RTX шаг `game`:
1. Определяет новейший стабильный тег `v310.9.x` в [NVIDIA/DLSS](https://github.com/NVIDIA/DLSS) через GitHub API; при недоступности API берёт закреплённый `v310.9.1`.
2. Скачивает выборочно (не весь репозиторий): `include/*.h`, `lib/Windows_x86_64/x64/nvsdk_ngx_d.lib` и `nvsdk_ngx_s.lib`, `lib/Windows_x86_64/rel/nvngx_dlss.dll` (~59 МБ). Итог — около 67 МБ один раз.
3. Скачивает только заголовки [KhronosGroup/Vulkan-Headers](https://github.com/KhronosGroup/Vulkan-Headers) в `Include/`: полный LunarG SDK не нужен, `build.rs` линкует Vulkan сам.
4. Ищет уже установленный `libclang.dll` (`LIBCLANG_PATH`, `PATH`, `C:\Program Files\LLVM\bin`, LLVM из Visual Studio). Если его нет — скачивает NuGet-пакет [`libclang.runtime.win-x64`](https://www.nuget.org/packages/libclang.runtime.win-x64) (~34 МБ) и распаковывает из него только `runtimes/win-x64/native/libclang.dll`.
5. Собирает с `--features mods,dlss`, передавая `DLSS_SDK`, `VULKAN_SDK` и `LIBCLANG_PATH` в окружение cargo, затем копирует свежий `nvngx_dlss.dll` рядом с собранным `horizon-client.exe`.
Кэш и повторные сборки:
```text
.horizon-cache/dlss-sdk/<tag>/ include/ + lib/Windows_x86_64/{x64,rel} + airdef-install.json
.horizon-cache/vulkan-headers/<tag>/ Include/vulkan/ + Include/vk_video/ + airdef-install.json
.horizon-cache/libclang/<version>/ libclang.dll + airdef-install.json
```
Повторный запуск видит маркер и полный набор файлов и ничего не скачивает. Удалить кэш можно целиком — при следующей сборке он появится снова.
Ручное переопределение по-прежнему работает и имеет приоритет: если задать `DLSS_SDK` (корень с `include/nvsdk_ngx*.h` и `lib/Windows_x86_64/x64/`), `VULKAN_SDK` (с `Include/vulkan/vulkan.h`) и/или `LIBCLANG_PATH` (каталог с `libclang.dll`), автоскачивание для этого компонента не выполняется. Если явный путь неполный, `airdef.py` предупреждает и собирает `mods`; чтобы вернуть автоскачивание, убери переменную.
Ручная альтернатива для libclang: `winget install LLVM.LLVM`, затем задать `LIBCLANG_PATH` на каталог `bin` установленного LLVM (там лежит `libclang.dll`).
При любой сетевой ошибке, недоступном GitHub/nuget.org, неполном скачивании или если libclang так и не нашёлся, сборка не падает: печатается предупреждение, ставится `--features mods`, и игра остаётся на native TAAU. На macOS и Linux, а также на Windows без RTX, автоскачивания нет — сразу `mods`.
Если bindgen всё же пишет `Unable to find libclang`, проверь `LIBCLANG_PATH`: он должен указывать на каталог, в котором лежит `libclang.dll` (не на сам файл). Удобно один раз выполнить `winget install LLVM.LLVM` и указать `C:\Program Files\LLVM\bin`.
Если `nvngx_dlss.dll` нужен отдельно (например, для ручной раскладки), он лежит в кэше: `.horizon-cache/dlss-sdk/<tag>/lib/Windows_x86_64/rel/nvngx_dlss.dll`. Его версия совпадает с самым новым тегом, который нашёл `airdef.py`.
+6 -2
View File
@@ -63,8 +63,12 @@ runtime закреплённого движка. Используется вре
## Акустика и владение захватом (API 27) ## Акустика и владение захватом (API 27)
Текущий pin: `278f356aa604fa21c2d15d0081823bbe0f891df2` (API 30; поверх API29 — нормали моделей Текущий pin: `3428a571bda382c9c5b388710efd1baf92ed8d9c` (API 31; GPU-instancing одной
и очистка неудачного захвата). Акустические массовой группы моделей мода с fallback до паритета и диагностическим toggle
`model-instancing`, #147; ниже — decode motion buffer по history grid в TAA/TAAU #143,
порядок DLSS-кадра #137, `render.project` — проекция мировых точек через камеру
последнего отрисованного кадра, #132; ниже — staging, cascades,
previous-frame motion и feature-gated DLSS SR backend #124, API 30). Акустические
`render.acoustics-status` и `render.capture-owner-status` возвращают поколение, `render.acoustics-status` и `render.capture-owner-status` возвращают поколение,
`available`, `enabled`, `request-accepted`, `prepared` и причину. В игре всё это показывает `available`, `enabled`, `request-accepted`, `prepared` и причину. В игре всё это показывает
`/airdef capabilities`. Отсутствие запроса, выключение, ожидание backend и ошибка различаются. `/airdef capabilities`. Отсутствие запроса, выключение, ожидание backend и ошибка различаются.
+57 -9
View File
@@ -47,7 +47,7 @@ cd .. && rm -f horizon-patches/*.patch && git -C horizon format-patch -q $(cat H
## Конвейер кадра (HD включён) ## Конвейер кадра (HD включён)
Цели мира (G-буфер, AO, освещение, пост-проход мода) — в «масштабированном» разрешении мира (`world_post`; при `HORIZON_HD_SCALE` < 1 оно меньше окна), цели после TAA (история, bloom, tonemap) — в разрешении окна. HDR — `Rgba16Float`. Глубина камеры — reversed-Z Цели мира (G-буфер, AO, освещение, пост-проход мода) — в «масштабированном» разрешении мира (`world_post`; масштаб — слайдер Resolution Scale настроек Horizon, `HORIZON_HD_SCALE` переопределяет его, при DLSS 100% = 1:1 (DLAA), < 100% — апскейл; при масштабе < 1 оно меньше окна), цели после TAA (история, bloom, tonemap) — в разрешении окна (или мира, если он суперсэмплирован больше окна). HDR — `Rgba16Float`. Глубина камеры — reversed-Z
(`Depth32Float`, 1 = близко, 0 = далеко). Позиции везде относительно камеры (camera-relative), мир — в `f64` (`Depth32Float`, 1 = близко, 0 = далеко). Позиции везде относительно камеры (camera-relative), мир — в `f64`
на CPU. на CPU.
@@ -58,8 +58,12 @@ cd .. && rm -f horizon-patches/*.patch && git -C horizon format-patch -q $(cat H
возвращается. Рисуются секции террейна в коробке дальнего каскада (`hd_shadow_visible`) и сущности-тенеотбрасыватели возвращается. Рисуются секции террейна в коробке дальнего каскада (`hd_shadow_visible`) и сущности-тенеотбрасыватели
(`shadow_casters`: без оверлеев 4/9/10/40 — 40 это светящиеся модели мода). (`shadow_casters`: без оверлеев 4/9/10/40 — 40 это светящиеся модели мода).
2. **G-буфер** (свой depth): albedo `Rgba8Unorm` (a = эмиссия), нормаль `Rgba16Float` (мировая, из `dpdx/dpdy`), 2. **G-буфер** (свой depth): albedo `Rgba8Unorm` (a = эмиссия), нормаль `Rgba16Float` (мировая, из `dpdx/dpdy`),
уровни света `Rgba8Unorm` (x = небо, y = блоки — сырые координаты лайтмапа /240). Террейн + дальние LOD-тайлы + уровни света `Rgba8Unorm` (x = небо, y = блоки — сырые координаты лайтмапа /240), motion `Rg16Float`
сущности. Полупрозрачное в G-буфер **не** попадает (идёт ванильным путём); вода — отдельный путь, см. п. 3 и «Вода». (current→previous в render-пикселях, обе проекции с jitter). Террейн + дальние LOD-тайлы + сущности.
Terrain/ванильные сущности пишут camera/static motion; `motion_models_pass` перезаписывает mod-модели
previous-frame transforms с read-only depth и тем же alpha cutout (`7a73e8d26`). Ветер остаётся camera-only.
`HORIZON_HD_DEBUG_MOTION=1` показывает R/G displacement и validity вместо обычного TAA-кадра.
Полупрозрачное в G-буфер **не** попадает (идёт ванильным путём); вода — отдельный путь, см. п. 3 и «Вода».
3. **Вода** (`water_pass`, только если на экране есть полупрозрачные секции, нет `frame.underwater` и не `HORIZON_HD_WATER=0`): 3. **Вода** (`water_pass`, только если на экране есть полупрозрачные секции, нет `frame.underwater` и не `HORIZON_HD_WATER=0`):
те же секции ещё раз с `fs_water` (terrain.wgsl), который отбрасывает всё, кроме слоёв спрайтов `water_still`/`water_flow` те же секции ещё раз с `fs_water` (terrain.wgsl), который отбрасывает всё, кроме слоёв спрайтов `water_still`/`water_flow`
(номера слоёв передаются в `Renderer::new` из `sprite_layers` и ставятся override-константами `WATER_STILL/WATER_FLOW`; стекло, (номера слоёв передаются в `Renderer::new` из `sprite_layers` и ставятся override-константами `WATER_STILL/WATER_FLOW`; стекло,
@@ -86,9 +90,11 @@ cd .. && rm -f horizon-patches/*.patch && git -C horizon format-patch -q $(cat H
5. **Пост-проход мода** `lit` → `fx` (`effects.wgsl`: взрывы, дым, вспышки, свечение; при HD его собственная 5. **Пост-проход мода** `lit` → `fx` (`effects.wgsl`: взрывы, дым, вспышки, свечение; при HD его собственная
«подсветка огнём» выключена — свет даёт HD). «подсветка огнём» выключена — свет даёт HD).
6. **TAA** — после пост-прохода мода (`fx`, либо `lit` без него), до bloom: история пинг-понгом, в альфе истории — 6. **TAA** — после пост-прохода мода (`fx`, либо `lit` без него), до bloom: история пинг-понгом, в альфе истории —
дистанция для отбраковки дизокклюзии; телепорт > 64 блоков сбрасывает историю. Джиттер добавляется к дистанция для отбраковки дизокклюзии; телепорт > 64 блоков сбрасывает историю. Если world/G-buffer depth
совпадают, history UV = current UV + motion/render_size; вода, прозрачность и небо используют прежний
depth/camera fallback. Джиттер добавляется к
`view_projection` только при HD (публичная матрица без джиттера); рука и HUD рисуются после tonemap и не дрожат. `view_projection` только при HD (публичная матрица без джиттера); рука и HUD рисуются после tonemap и не дрожат.
**TAAU**: если мир меньше окна (`HORIZON_HD_SCALE=0.67`), тот же проход (`fs_taau`, в таймингах `hd taau`) восстанавливает **TAAU**: если мир меньше окна (слайдер Resolution Scale < 100%, DLSS апскейл при < 100% или `HORIZON_HD_SCALE=0.67`), тот же проход (`fs_taau`, в таймингах `hd taau`) восстанавливает
полное разрешение. История, bloom и tonemap — в разрешении окна. Для каждого пикселя выхода берётся 3×3 выборки мира полное разрешение. История, bloom и tonemap — в разрешении окна. Для каждого пикселя выхода берётся 3×3 выборки мира
вокруг (с учётом джиттера в `taa_params.zw`), веса — полином, аппроксимирующий Lanczos-2, по расстоянию от центра вокруг (с учётом джиттера в `taa_params.zw`), веса — полином, аппроксимирующий Lanczos-2, по расстоянию от центра
пикселя выхода до выборки; variance clip в YCoCg по тем же 3×3; глубина — ближайшая из 2×2; история (Catmull-Rom, пикселя выхода до выборки; variance clip в YCoCg по тем же 3×3; глубина — ближайшая из 2×2; история (Catmull-Rom,
@@ -225,6 +231,7 @@ HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off` — A/B; `--baseline run-home
| #36: ванильная вода не рисует цвет в HD (`fs_translucent` при `Globals.hd_flags.x`, глубину оставляет); прозрачное перед водой (`d` ближе `wd`) не отключает HD-воду: вода считается на освещённом дне и добавляется к сцене с весом 0.7; преломление не берёт тексели с таким прозрачным (`textureGather` по альфе) | готово (проверены стекло; частицы и scale 0.67 не проверялись) | в рабочем дереве форка | | #36: ванильная вода не рисует цвет в HD (`fs_translucent` при `Globals.hd_flags.x`, глубину оставляет); прозрачное перед водой (`d` ближе `wd`) не отключает HD-воду: вода считается на освещённом дне и добавляется к сцене с весом 0.7; преломление не берёт тексели с таким прозрачным (`textureGather` по альфе) | готово (проверены стекло; частицы и scale 0.67 не проверялись) | в рабочем дереве форка |
| #45: `gfx/hd.rs` разделён на модуль `gfx/hd/` (по файлу на проход: `shadows`, `gbuffer`, `ao`, `sky`, `volumes`, `lighting`+`tiles`, `water`, `taa`, `bloom`, `tonemap`, `frame`), WGSL вынесен в `.wgsl` (`include_str!`, общая прелюдия), у каждого прохода своя структура ресурсов/пайплайнов; контракты цвета, глубины, альф и времени записаны в `hd/mod.rs` и в начале файлов проходов; тесты привязок и размера `HdFrame`. Вид не менялся (сверка `tools/hd_bench.py`) | готово | в рабочем дереве форка | | #45: `gfx/hd.rs` разделён на модуль `gfx/hd/` (по файлу на проход: `shadows`, `gbuffer`, `ao`, `sky`, `volumes`, `lighting`+`tiles`, `water`, `taa`, `bloom`, `tonemap`, `frame`), WGSL вынесен в `.wgsl` (`include_str!`, общая прелюдия), у каждого прохода своя структура ресурсов/пайплайнов; контракты цвета, глубины, альф и времени записаны в `hd/mod.rs` и в начале файлов проходов; тесты привязок и размера `HdFrame`. Вид не менялся (сверка `tools/hd_bench.py`) | готово | в рабочем дереве форка |
| #39: веер восхода `vanilla_sunrise_weight` отсекается до цикла по 16 треугольникам выше горизонта (знак x стороны солнца и наклон ≤ α/3; проверено перебором 200 тыс. лучей без пропусков); `hd lighting` на рассвете 5.3 → 3.3 мс (M-серия, 2560×1440) | готово | в рабочем дереве форка | | #39: веер восхода `vanilla_sunrise_weight` отсекается до цикла по 16 треугольникам выше горизонта (знак x стороны солнца и наклон ≤ α/3; проверено перебором 200 тыс. лучей без пропусков); `hd lighting` на рассвете 5.3 → 3.3 мс (M-серия, 2560×1440) | готово | в рабочем дереве форка |
| #126 (этап 1): retained-геометрия моделей мода — грани резолвятся против атласа раз в generation пака, кадр только трансформирует и освещает; motion #124 из тех же граней без второго bake; счётчики `mod_models` в `stats`; вершины бит-в-бит прежние (тест). `entity_geometry` CPU 5.71 → 1.57 мс avg, p95 8.7 → 2.2 (M5, raid-сцена Polygon) | готово; GPU-instancing — следующий этап | форк `a861c1ed2` (`kimi-work-124`), замеры `docs/measurements/issue-126-first-stage/` |
| Облака в воде, перистые, туман по рельефу, лучи, тень облаков при низком солнце, дальний дым (768 блоков) | готово, в рабочем дереве форка; тайминги не сняты чисто | не закоммичено | | Облака в воде, перистые, туман по рельефу, лучи, тень облаков при низком солнце, дальний дым (768 блоков) | готово, в рабочем дереве форка; тайминги не сняты чисто | не закоммичено |
| Материалы и блики (план 5): G-буфер `levels.zw` = шероховатость, металличность; GGX-блик солнца с Френелем и отражение неба (`sky_along`/`atmosphere_sky`) в `shade_surface`; мокрые поверхности и лужи в дождь (`HdFrame.surface`); `HORIZON_HD_SPECULAR=0` — выкл. | готово | в рабочем дереве форка | | Материалы и блики (план 5): G-буфер `levels.zw` = шероховатость, металличность; GGX-блик солнца с Френелем и отражение неба (`sky_along`/`atmosphere_sky`) в `shade_surface`; мокрые поверхности и лужи в дождь (`HdFrame.surface`); `HORIZON_HD_SPECULAR=0` — выкл. | готово | в рабочем дереве форка |
@@ -241,12 +248,23 @@ HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off` — A/B; `--baseline run-home
Каждый пункт — самостоятельная задача. Перед началом прочитай `gfx/hd/mod.rs` (контракты) и файл нужного прохода. Каждый пункт — самостоятельная задача. Перед началом прочитай `gfx/hd/mod.rs` (контракты) и файл нужного прохода.
1. **TAAU — временной апскейлер** (поверх TAA) — СДЕЛАНО (патч 18, см. статус; масштаб — `HORIZON_HD_SCALE`, переопределяет «масштаб разрешения» настроек Horizon только для HD; поля в `HdSettings` нет). Осталось: LOD-bias текстур террейна, MetalFX. Исходное ТЗ: Мир и G-буфер рендерятся в `render_scale` (например 0.67), 1. **TAAU — временной апскейлер** (поверх TAA) — СДЕЛАНО (патч 18, см. статус; масштаб — слайдер Resolution Scale настроек Horizon, живой, без перезапуска; `HORIZON_HD_SCALE` — явное dev-переопределение поверх слайдера, film quality — полный размер; поля в `HdSettings` нет). Приоритет и DLSS-взаимодействие — `hd::scale_override(slider)` / `scale_for` и тест `the_resolution_slider_drives_hd_scale`; с DLSS слайдер capped на 1 (апскейлер), монотонно: 100% = 1:1 (DLAA), < 100% — апскейл, >100% — render в размер выхода; суперсэмплинг >1 — native TAAU без DLSS. Исправлен баг: раньше DLSS всегда пинил мир на 2/3 и слайдер игнорировался (ветка `agent/resolution-scale`, см. `docs/DLSS-TESTING.md`). Осталось: LOD-bias текстур террейна, MetalFX. Исходное ТЗ: Мир и G-буфер рендерятся в `render_scale` (например 0.67),
TAA-проход восстанавливает полное разрешение: история в полном разрешении, текущий кадр семплируется с учётом TAA-проход восстанавливает полное разрешение: история в полном разрешении, текущий кадр семплируется с учётом
джиттера (Catmull-Rom/Lanczos-веса по субпиксельной позиции), клиппинг окрестности как в TAA. Настройка джиттера (Catmull-Rom/Lanczos-веса по субпиксельной позиции), клиппинг окрестности как в TAA. Настройка
масштаба (`HORIZON_HD_SCALE` или поле в `HdSettings`). Цель: при 0.67 картинка близка к нативной, FPS заметно масштаба (`HORIZON_HD_SCALE` или поле в `HdSettings`). Цель: при 0.67 картинка близка к нативной, FPS заметно
выше. Альтернатива на Mac — MetalFX через wgpu-hal (нативный код, только Metal) — отдельной опцией потом. DLSS выше. #124 развивает этот путь в общий temporal backend: `ed751714e` добавляет optional `dlss` feature
нереален для нашей цели (только NVIDIA через Streamline, нет в wgpu). и `HORIZON_DLSS=1`, previous-frame motion, NGX+HDR bootstrap и display↔linear conversion. Submit:
world+linearize → NGX → delinearize; native TAAU остаётся fallback. #137 довёл порядок до контракта:
film/tonemap/UI/capture/present записываются в encoder после delinearize и отправляются одним submit
без CPU sync (раньше они читали `taa.target` до записи NGX), а готовность нативной истории отделена от
истории NGX — первый fallback-кадр после DLSS не читает пустую/устаревшую native history. Render-размер DLSS — слайдер Resolution Scale
(capped на размер выхода; 100% = 1:1 DLAA, < 100% — апскейл), `HORIZON_HD_SCALE` переопределяет это; контекст NGX живёт под размер выхода,
render-размер едет в каждой evaluate (`partial_texture_size`) и меняется вживую без пересоздания, пока вписывается в диапазон NGX.
Сборка требует `DLSS_SDK` (v310.9.1), `VULKAN_SDK`, clang и
`--features dlss`; runtime DLL/SO и NVIDIA notices нужны рядом с приложением, не в Git. Полный `cargo xwin build`
на MSVC и prerelease `v0.4.0-dlss-rc1` опубликованы; реальный RTX/Vulkan runtime ещё не проверен.
A/B инструкция — `docs/DLSS-TESTING.md`.
Ванильные сущности/ветер остаются camera-only. MetalFX — отдельный Metal backend, FG отдельно.
2. **Вода** — СДЕЛАНО (патч 19, см. «Вода» ниже). Исходное ТЗ: отдельный G-буфер-путь для воды (маска + нормаль с анимированными волнами), SSR (трассировка по 2. **Вода** — СДЕЛАНО (патч 19, см. «Вода» ниже). Исходное ТЗ: отдельный G-буфер-путь для воды (маска + нормаль с анимированными волнами), SSR (трассировка по
глубине, откат на небо/туман), преломление (смещение по нормали), затухание по глубине воды (цвет биома), глубине, откат на небо/туман), преломление (смещение по нормали), затухание по глубине воды (цвет биома),
блики солнца (GGX-подобный), френель. Подводный вид не ломать (`frame.underwater`). блики солнца (GGX-подобный), френель. Подводный вид не ломать (`frame.underwater`).
@@ -351,6 +369,36 @@ HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off` — A/B; `--baseline run-home
- Мод в повторе берёт взрывы из записи (`record::replay_blasts`, чистая функция времени), время идёт по часам повтора (`params[255].x` — доля частичного тика, которую эффекты не используют при паузе/замедлении). - Мод в повторе берёт взрывы из записи (`record::replay_blasts`, чистая функция времени), время идёт по часам повтора (`params[255].x` — доля частичного тика, которую эффекты не используют при паузе/замедлении).
- #51: на перехвате слои звука (`cinema.rs`), свет-«удар» (белая вспышка в HD-освещении, радиус до 256), пик экспозиции/bloom (`set-lighting`), в `effects.wgsl` широкое гало, подсветка неба/облаков и яркое кольцо ударной волны на экране. - #51: на перехвате слои звука (`cinema.rs`), свет-«удар» (белая вспышка в HD-освещении, радиус до 256), пик экспозиции/bloom (`set-lighting`), в `effects.wgsl` широкое гало, подсветка неба/облаков и яркое кольцо ударной волны на экране.
## Retained-геометрия моделей мода (#126, этап 1)
- **Что изменилось.** `game/mod_models.rs`: грани модели резолвятся против атласа один раз на
generation пака (`MeshCache` по `BlockStateId`; generation — `Arc<RenderAssets>` текущего пака,
сравнение `ptr_eq`, клон удерживает адрес от переиспользования): прямоугольник спрайта,
model-space квад и нормаль (`block_model_normal`), emission и special-материал квада (40/41/42)
по центру UV. Кадр только применяет трансформ инстанса: позиции — `m.transform_point3`,
нормаль — один inverse-transpose на инстанс (не на грань), свет — мировой свет позиции + emission.
Таблица special-материалов строится раз в generation, а не каждый кадр обходом всего атласа;
линейный поиск материала по квадам убран из кадра. HD motion-проход (#124) берёт previous-позиции
из тех же retained-граней с матрицей прошлого кадра — второй bake модели больше нет. Вершины
бит-в-бит совпадают с прежним покадровым bake (тест `retained_emit_matches_the_per_frame_bake`,
матрица трансформов × glow × свет × emission, включая motion).
- **Инвалидация.** Resource reload (`apply_staged_pack`) и выход из мира (`clear_entities`,
`leave_server`) сбрасывают кэш; generation-guard дополнительно ловит любую смену пака. Размер
кэша ограничен числом состояний моделей в паке, не числом инстансов и не временем.
- **Счётчики и span.** `stats`/`bench` control-сокета возвращают `mod_models`: frames, models,
quads, motion_quads, vertex_bytes, motion_bytes, mesh_builds, atlas_scans с момента сброса
(bench сбрасывает). Span `mod_models` внутри `entity_geometry` виден при `HORIZON_SPIKES`.
- **Замеры.** M5, Metal, 2560×1440 offscreen, HD, in-frame, Polygon: 14 батарей + 3 волны
(`shahed 40 900`, `kh101 16 1400`, `mix 24 700`), ~135 моделей/кадр, ~17.8 тыс. квадов/кадр.
`entity_geometry` CPU 5.71 → 1.57 мс avg (p95 8.7 → 2.2, p99 10.6 → 2.7), фаза prepare
23.5 → 7.05 мс; span `mod_models` 1.32 мс avg — чистые трансформы. Static-сцена (4 батареи,
TAA/wind/clouds/volfog выключены, время заморожено): пиксели identical (0 px > 20/255 при
сошедшемся LOD). Байты upload не менялись (~3.1 МБ/кадр вершин + ~4 МБ motion): этап убирает
CPU-bake, не объём upload. Полная таблица и методика — `docs/measurements/issue-126-first-stage/`.
- **Чем это не является.** Не GPU-instancing: вершины по-прежнему трансформируются на CPU и
загружаются каждый кадр. Per-instance буферы, GPU-интерполяция и indirect draws — следующий
этап направления A #126. Боевые правила, 20 Гц, API мода, DLSS/RT не тронуты; мод (WASM) тот же.
## Прожекторы: направленный свет и объёмный луч (#60) ## Прожекторы: направленный свет и объёмный луч (#60)
- **API 16** `render.set-spot-lights(list<spot-light>) -> bool`: апекс, направление, цвет, интенсивность, `range` (до 1024), внутренний/внешний полуугол (рад), `beam` (видимость луча 0..1). До 32 от мода, рисуются ближайшие 16 (`MAX_SPOTS`). Возвращает, рисует ли HD (`HORIZON_HD_SPOTS=0` выключает), иначе мод держит свой запасной луч. Игра интерполирует по id между двумя вызовами (`mod_models.rs: mod_spots`) и переводит в `HdSpot` (`gfx/hd/frame.rs`): координаты камеры, косинусы углов. - **API 16** `render.set-spot-lights(list<spot-light>) -> bool`: апекс, направление, цвет, интенсивность, `range` (до 1024), внутренний/внешний полуугол (рад), `beam` (видимость луча 0..1). До 32 от мода, рисуются ближайшие 16 (`MAX_SPOTS`). Возвращает, рисует ли HD (`HORIZON_HD_SPOTS=0` выключает), иначе мод держит свой запасной луч. Игра интерполирует по id между двумя вызовами (`mod_models.rs: mod_spots`) и переводит в `HdSpot` (`gfx/hd/frame.rs`): координаты камеры, косинусы углов.
@@ -404,7 +452,7 @@ ffmpeg 9.0.1. `/airdef replay export` с записанного налёта (4
## Цветные тени, рябь, кино-пост: что знать преемнику ## Цветные тени, рябь, кино-пост: что знать преемнику
- **Цветные тени.** Ближний каскад (c = 0) рисуется `fs_shadow_near` (листва `MAT_LEAVES` отброшена), потом проход `hd shadow colour` (`Hd::shadow_tint_pass`, цель `Shadows::tint`, очистка в белое) рисует листву (`shadow_tint_leaves`, твёрдые квады, `SHADOW_SOLID`) и полупрозрачные квады секций (`shadow_tint_glass`, по отсортированным индексам; вода не рисуется) тем же `fs_shadow_tint`: rgb умножаются (blend `Dst*src`), альфа = `(расстояние от света − 320)/160` с blend Min — ближайший такой квад. Приёмник в `shadow_tint` (`light.wgsl`, привязка 22) окрашивается, если квад ближе к свету, чем он; 8 точек Vogel радиусом 0.4 блока размывают листву в «пятна». Дальний каскад по-прежнему рисует листву полностью (на границе 36 блоков шов: ближе листва светлее). Цвет не доходит до лучей тумана, воды и дальнего каскада. Цена: `hd shadow colour` 0.25–0.35 мс (Mac, малая сцена). - **Цветные тени.** Ближний каскад (c = 0) рисуется `fs_shadow_near` (листва `MAT_LEAVES` отброшена), потом проход `hd shadow colour` (`Hd::shadow_tint_pass`, цель `Shadows::tint`, очистка в белое) рисует листву (`shadow_tint_leaves`, твёрдые квады, `SHADOW_SOLID`) и полупрозрачные квады секций (`shadow_tint_glass`, по отсортированным индексам; вода не рисуется) тем же `fs_shadow_tint`: rgb умножаются (blend `Dst*src`), альфа = `(расстояние от света − 320)/160` с blend Min — ближайший такой квад. Приёмник в `shadow_tint` (`light.wgsl`, привязка 22) окрашивается, если квад ближе к свету, чем он; 8 точек Vogel радиусом 0.4 блока размывают листву в «пятна». Дальний каскад по-прежнему рисует листву полностью; с `17382445a` near/far depth filters смешиваются на последних 6 блоках перед границей 36,8, а tint затухает по той же smoothstep — круглого шва нет. Цвет не доходит до лучей тумана, воды и дальнего каскада. Цена: `hd shadow colour` 0.25–0.35 мс (Mac, малая сцена).
- **Рябь.** `ripple_gradient` берёт часы воды (`water.y`, часы фильма): частоты — целые циклы на 600 с, сетка 160 клеток на 256 блоков, поэтому рисунок не прыгает на обороте. Гаснет по размеру пикселя, только под открытым небом (`nt.a`). Амплитуда 0.012 не подбиралась. - **Рябь.** `ripple_gradient` берёт часы воды (`water.y`, часы фильма): частоты — целые циклы на 600 с, сетка 160 клеток на 256 блоков, поэтому рисунок не прыгает на обороте. Гаснет по размеру пикселя, только под открытым небом (`nt.a`). Амплитуда 0.012 не подбиралась.
- **Кино-пост.** `Hd::film` между `taa` и `finish` (`HdSource::Film`), только при `film_quality()`; цели создаются при первом фильме. Motion blur — только от движения камеры (глубина + `prev_view_proj`, затвор 180°, мёртвая зона 1–2.5 px из-за джиттера; движущиеся объекты не размываются; нет после склейки/телепорта: `taa.w`). DoF — диск 24 отсчёта, фокус авто (гармоническое среднее 9 глубин у центра) или `HORIZON_HD_DOF_FOCUS`. Детерминизм: единственное время в шейдере — `water.y` (часы фильма) для шума. Проверять на реальном фильме `/airdef replay film`; `HORIZON_HD_FILM_QUALITY=1` принудительно включает качество фильма для проб. DoF в игре был слишком сильным и дорогим; параметры уменьшены без повторного снимка. Motion blur на снимке (поворот 40° за 1.5 с) не разобран. - **Кино-пост.** `Hd::film` между `taa` и `finish` (`HdSource::Film`), только при `film_quality()`; цели создаются при первом фильме. Motion blur — только от движения камеры (глубина + `prev_view_proj`, затвор 180°, мёртвая зона 1–2.5 px из-за джиттера; движущиеся объекты не размываются; нет после склейки/телепорта: `taa.w`). DoF — диск 24 отсчёта, фокус авто (гармоническое среднее 9 глубин у центра) или `HORIZON_HD_DOF_FOCUS`. Детерминизм: единственное время в шейдере — `water.y` (часы фильма) для шума. Проверять на реальном фильме `/airdef replay film`; `HORIZON_HD_FILM_QUALITY=1` принудительно включает качество фильма для проб. DoF в игре был слишком сильным и дорогим; параметры уменьшены без повторного снимка. Motion blur на снимке (поворот 40° за 1.5 с) не разобран.
- Из Photon (MIT) ничего нового не переносилось: THIRD_PARTY_PHOTON.md не менялся. - Из Photon (MIT) ничего нового не переносилось: THIRD_PARTY_PHOTON.md не менялся.
+7 -3
View File
@@ -8,7 +8,7 @@
для Rust и Python; #102: измеренный fuel, API29 light/source milestones, API30 camera-status для Rust и Python; #102: измеренный fuel, API29 light/source milestones, API30 camera-status
и изоляция камер; #96: массовый deterministic offline capture; #115: authored Lancet/Х-101 и изоляция камер; #96: массовый deterministic offline capture; #115: authored Lancet/Х-101
и кадры инстансов. и кадры инстансов.
Текущий engine pin — API30; старые номера/числа ниже описывают предыдущие этапы. Текущий engine pin — API31 (`render.project`, #132); старые номера/числа ниже описывают предыдущие этапы.
Проблема нормалей модели #123 исправлена в engine `45b43f00d`; парные HD-кадры и ночная проверка Lancet записаны в галерее. Проблема нормалей модели #123 исправлена в engine `45b43f00d`; парные HD-кадры и ночная проверка Lancet записаны в галерее.
| Issue | Реализовано | Что остаётся для полной приёмки | | Issue | Реализовано | Что остаётся для полной приёмки |
@@ -17,7 +17,7 @@
| #87 | Каноническое SDK-free ядро `airdef-core`, используется модом и сценариями | Дальнейшее отделение текстового/визуального вывода домена от адаптера | | #87 | Каноническое SDK-free ядро `airdef-core`, используется модом и сценариями | Дальнейшее отделение текстового/визуального вывода домена от адаптера |
| #88 | Типизированный журнал измеренных переходов; read-only Snapshot для Smoke/Shown; записанные пожары, позы, пуски и зажигание | Перевести оставшиеся model/audio adapters и режиссёра на общий снимок; замер полной 10-минутной записи | | #88 | Типизированный журнал измеренных переходов; read-only Snapshot для Smoke/Shown; записанные пожары, позы, пуски и зажигание | Перевести оставшиеся model/audio adapters и режиссёра на общий снимок; замер полной 10-минутной записи |
| #89 | Session владеет Live/Replay/Export; явные часы/поколения; единый cleanup; задержанный звук следует часам показа; выход в заголовок завершает показ одним cleanup (хук `frame`, `Session::world_left`); движок освобождает temp/лог ошибки энкодера и не трогает готовый MP4 | Реальный короткий MP4 проверен 4 ноября (звук/видео, отмена, ошибка SDK и энкодера, повторный запуск, совпадение кадров и хвоста очереди, сохранность прежнего MP4). Остаётся: 10-минутный экспорт; приёмка Windows/Linux | | #89 | Session владеет Live/Replay/Export; явные часы/поколения; единый cleanup; задержанный звук следует часам показа; выход в заголовок завершает показ одним cleanup (хук `frame`, `Session::world_left`); движок освобождает temp/лог ошибки энкодера и не трогает готовый MP4 | Реальный короткий MP4 проверен 4 ноября (звук/видео, отмена, ошибка SDK и энкодера, повторный запуск, совпадение кадров и хвоста очереди, сохранность прежнего MP4). Остаётся: 10-минутный экспорт; приёмка Windows/Linux |
| #91 | Общий каталог доступности и потребители меню/инвентаря; явный RM48U-профиль; корректные подписи очередей; `catalog/specs.json` — единственный источник числовых строк, из него генерируются Rust-таблицы для мода и `airdef-core`, CI проверяет свежесть | Варианты комплексов (разные ракеты/профили по батареям) и игровая приёмка; каталог остаётся статичными данными, не динамическим ECS | | #91 | Общий каталог доступности и потребители меню/инвентаря; явный RM48U-профиль; корректные подписи очередей; `catalog/specs.json` — единственный источник числовых строк, из него генерируются Rust-таблицы для мода и `airdef-core`, CI проверяет свежесть; первый типизированный slice вариантов комплексов: `catalog/content.json → variants` описывает существующие ключи развёртывания элементов батареи (`s400_launcher`…), вариант = `id/kind/mode/role/label` без нового баланса, таблица `catalog::VARIANTS` генерируется и потребляется меню/командами, ручные параллельные списки в `lib.rs`/`commands.rs` удалены | Профили боезапаса по вариантам (разные ракеты/боекомплекты по батареям) не заводились: обязательное условие — зафиксированный профиль и явная игровая абстракция (см. поправку ревью о PAC-3 в комментарии #91); далее полная игровая приёмка; каталог остаётся статичными данными, не динамическим ECS |
| #92 | Authored overrides, проверка ссылок/PNG/границ, manifest, безопасная транзакционная генерация; registry/texture/icon modules | Дальнейшее ручное улучшение контента относится к #115 | | #92 | Authored overrides, проверка ссылок/PNG/границ, manifest, безопасная транзакционная генерация; registry/texture/icon modules | Дальнейшее ручное улучшение контента относится к #115 |
| #96 | Акустические пути; измеренные синтетические occlusion/echo/reverb fixtures; лицензии и исходные notices в архивах; настоящий MP4 с акустикой: пары on/off, статусы ready, окклюзия/поглощение и диффузный wet-остаток в замкнутой геометрии | Прослушивание, игровой массовый звук/CPU, чистый хвост/RT60 в MP4; точность RT60 пока по допуску 35%, не 15% | | #96 | Акустические пути; измеренные синтетические occlusion/echo/reverb fixtures; лицензии и исходные notices в архивах; настоящий MP4 с акустикой: пары on/off, статусы ready, окклюзия/поглощение и диффузный wet-остаток в замкнутой геометрии | Прослушивание, игровой массовый звук/CPU, чистый хвост/RT60 в MP4; точность RT60 пока по допуску 35%, не 15% |
| #102 | Pinned engine/API30, packer/build identity; smoke/acoustics/capture-owner/light/source/owner-scoped camera milestones; fallback/владение; WASM27 и flat stress271; измеренный callback fuel; JSON provenance/failure tests; Metal/no-audio smoke; URL/Git-регрессия; camera-ready по закодированному кадру с per-run/per-world сбросом; GPU-приёмка monitor/main-view на Metal/offscreen (Apple M5) | Старое69-шаговое утверждение о перекрытии отозвано; визуальная/Windows-GPU приёмка картинки камер, полные query/voice/peak budgets, GPU/готовый MP4 и Windows-приёмка остаются | | #102 | Pinned engine/API30, packer/build identity; smoke/acoustics/capture-owner/light/source/owner-scoped camera milestones; fallback/владение; WASM27 и flat stress271; измеренный callback fuel; JSON provenance/failure tests; Metal/no-audio smoke; URL/Git-регрессия; camera-ready по закодированному кадру с per-run/per-world сбросом; GPU-приёмка monitor/main-view на Metal/offscreen (Apple M5) | Старое69-шаговое утверждение о перекрытии отозвано; визуальная/Windows-GPU приёмка картинки камер, полные query/voice/peak budgets, GPU/готовый MP4 и Windows-приёмка остаются |
@@ -31,6 +31,7 @@
| #118 | Физический С-400/RM48U, четыре общие ячейки, конечные запасы; доставка и обратный вывоз ТЗМ, резерв/отмена, возврат снятой ПВО; обе фазы вывозного маршрута сохраняются; carrier/крышки/выброс/зажигание/разгон в записи; фантомное ПВО удалено | Визуальная приёмка пуска и маршрутов на сложном рельефе; другие носители не добавлены без подтверждённого профиля | | #118 | Физический С-400/RM48U, четыре общие ячейки, конечные запасы; доставка и обратный вывоз ТЗМ, резерв/отмена, возврат снятой ПВО; обе фазы вывозного маршрута сохраняются; carrier/крышки/выброс/зажигание/разгон в записи; фантомное ПВО удалено | Визуальная приёмка пуска и маршрутов на сложном рельефе; другие носители не добавлены без подтверждённого профиля |
| #128 | Невыполнимый возврат RM48U (ПУ движется/повреждена, маршрут недоступен, заявку уже везёт другая ТЗМ, у склада нет места) больше не блокирует ТЗМ: заявка сохраняется, свободная ТЗМ исполняет независимые заявки на доставку; выполнимый возврат снова в приоритете; консервация боеприпасов и save-restore посреди маршрута покрыты регрессиями | Игровая приёмка маршрутов на сложном рельефе остаётся за #118 | | #128 | Невыполнимый возврат RM48U (ПУ движется/повреждена, маршрут недоступен, заявку уже везёт другая ТЗМ, у склада нет места) больше не блокирует ТЗМ: заявка сохраняется, свободная ТЗМ исполняет независимые заявки на доставку; выполнимый возврат снова в приоритете; консервация боеприпасов и save-restore посреди маршрута покрыты регрессиями | Игровая приёмка маршрутов на сложном рельефе остаётся за #118 |
| #129 | Единые стадии пуска: выброс без мотора (`cold` 20/24 тика у С-400/С-500, 8 у IRIS-T/Тора), зажигание в текущей позиции, departure с плавным ростом тяги/темпа поворота, наведение только после `cold + boost`; рельсовые ракеты получили spool тяги без холодного выброса, P1-SUN — без струи; RM48U согласован на 20 тиков; live/replay/export читают записанное зажигание; `pk`, максимальные скорости и коллизии не менялись | Парные replay-MP4 до/после и кадры сняты на одном мире/seed/сценарии (Metal/offscreen); измеренный сдвиг первой вспышки 0,233 → 0,900 с. Остаётся человеческая визуальная оценка композиции, very-close план выброса; live-видео, Windows/Linux и живое прослушивание не проверялись | | #129 | Единые стадии пуска: выброс без мотора (`cold` 20/24 тика у С-400/С-500, 8 у IRIS-T/Тора), зажигание в текущей позиции, departure с плавным ростом тяги/темпа поворота, наведение только после `cold + boost`; рельсовые ракеты получили spool тяги без холодного выброса, P1-SUN — без струи; RM48U согласован на 20 тиков; live/replay/export читают записанное зажигание; `pk`, максимальные скорости и коллизии не менялись | Парные replay-MP4 до/после и кадры сняты на одном мире/seed/сценарии (Metal/offscreen); измеренный сдвиг первой вспышки 0,233 → 0,900 с. Остаётся человеческая визуальная оценка композиции, very-close план выброса; live-видео, Windows/Linux и живое прослушивание не проверялись |
| #134 | Три самостоятельных игровых профиля отдельных РЛС (`radar_search`, `radar_track`, `radar_height`) с устойчивыми ID, циклом/каналами/локальным поиском и разрешёнными продуктами измерения; `on/off` сохраняется, переключение роли на ходу отклоняется; встроенные РЛС комплексов сохраняют своё право на пуск. Сеть передаёт измерившую станцию, возраст и качество, но повторная пересылка не освежает измерение и не даёт права на пуск. Пуск требует собственного подтверждённого огневого трека (или внешней огневой РЛС для отдельной пусковой и дальнего пуска). Карта/монитор/`why` показывают профиль, источник, продукт, качество, каналы и причину отказа; старые сейвы мигрируют по роли, replay хранит профиль. Тесты: сценарий профилей по отдельности/парами/втроём, дублирование, каналы, off/повреждение/связь, relay, миграция и replay | Общий силуэт машины у трёх профилей (различаются поведение, подписи и статусы); публикация наблюдаемой роли РЛС в картине противника (#127) не расширена; визуальная приёмка на Windows/Linux и живые замеры совокупной картины не проводились |
Для #118 RM48U — явно условный Minecraft-профиль. Существование сочетания опирается на сообщение ведомства, Для #118 RM48U — явно условный Minecraft-профиль. Существование сочетания опирается на сообщение ведомства,
а игровые параметры не выдаются за реальные. `ground-stock` — команда подготовки sandbox-сценария, а игровые параметры не выдаются за реальные. `ground-stock` — команда подготовки sandbox-сценария,
@@ -50,8 +51,11 @@
| #119 | Три read-only луча в известной геометрии ослабляют непрямой blast для корпуса/узлов/объектов; проёмы дают частичное воздействие; прямой контакт сохранён | Unknown/stale: прежний урон без защиты, нулевое ожидание; partial blocks считаются занятыми кубами; GUI-проверка разрушения укрытия ещё нужна | | #119 | Три read-only луча в известной геометрии ослабляют непрямой blast для корпуса/узлов/объектов; проёмы дают частичное воздействие; прямой контакт сохранён | Unknown/stale: прежний урон без защиты, нулевое ожидание; partial blocks считаются занятыми кубами; GUI-проверка разрушения укрытия ещё нужна |
| #120 | Конечное горение, powered/coast, сопротивление и снижение доступного манёвра, один остаточный pk по фактической скорости; swept-встреча; события burnout/energy loss; согласованное прекращение факела/дыма/звука | Игровой профиль, без аэродинамики и реальных параметров; сравнительная выборка 12 рейдов и расширенная сетка 48 рейдов (6 вариантов × 8 seed, батареи/дальности/классы) записаны в measurements; без подтверждённого дефекта параметры не менялись; прослушивание остаётся | | #120 | Конечное горение, powered/coast, сопротивление и снижение доступного манёвра, один остаточный pk по фактической скорости; swept-встреча; события burnout/energy loss; согласованное прекращение факела/дыма/звука | Игровой профиль, без аэродинамики и реальных параметров; сравнительная выборка 12 рейдов и расширенная сетка 48 рейдов (6 вариантов × 8 seed, батареи/дальности/классы) записаны в measurements; без подтверждённого дефекта параметры не менялись; прослушивание остаётся |
| #121 | On/Off в команде и карте, save/replay; Off не создаёт own measurements и сохраняет сетевой приём; раскрытие работающего радара наблюдателем; SEAD использует last-known и возраст | Условный наблюдатель по расстоянию, без радиотехнической модели и ошибки пеленга; выбор на карте ещё не проверен в GUI | | #121 | On/Off в команде и карте, save/replay; Off не создаёт own measurements и сохраняет сетевой приём; раскрытие работающего радара наблюдателем; SEAD использует last-known и возраст | Условный наблюдатель по расстоянию, без радиотехнической модели и ошибки пеленга; выбор на карте ещё не проверен в GUI |
| #122 | Воспроизведены два класса: tick fuel exhaustion на двух максимальных составах, HD (полный обход height-cache на каждом взрыве заменён удалением нужных ключей; max135.3M/300M) и остановка в UI event на втором крупном приказе (переснимок known_units на каждом дроне заменён одним снимком на приказ и O(журнал+группировка); max command 32.9M/1e9, `/stats` до/после совпал); нативные тесты эквивалентности и второго приказа; WASM fixture с 4 принятыми приказами; callback diagnostics/profile | Требуется приёмка на Windows; без подтверждённого build identity нельзя утверждать ту же причину пользовательского сеанса; FPS/GPU не измерялись | | #122 | Воспроизведены три класса: tick fuel exhaustion на двух максимальных составах, HD (полный обход height-cache на каждом взрыве заменён удалением нужных ключей; max135.3M/300M); остановка в UI event на втором крупном приказе (переснимок known_units на каждом дроне заменён одним снимком на приказ и O(журнал+группировка); max command 32.9M/1e9, `/stats` до/после совпал); OOM в `note_sams` (до: 384000 SamKey/27 MiB в одной полной записи 64 РЛС; после: бюджет 32768, адаптивное прореживание без остановки записи; WASM 24002 тика/64 РЛС/60 малых волн прошёл с прежним лимитом 64 MiB); нативные регрессии и callback diagnostics/profile | Требуется приёмка на Windows; без подтверждённого build identity нельзя утверждать ту же причину пользовательского сеанса; FPS/GPU не измерялись |
| #124 | Motion + object transforms + feature-gated DLSS SR: engine `ed751714e`; NGX+HDR bootstrap, долгоживущий SDK/context, display↔linear conversion и ordered submit; native TAAU fallback. Полный `cargo xwin build` на MSVC и `v0.4.0-dlss-rc1` с PE32+, `airdef.hmod`, `nvngx_dlss.dll`, notices и A/B launchers опубликованы; 24 HD + layout, mods/no-mods, обычный Metal кадр проверены | Runtime/качество/FPS на RTX/Vulkan не подтверждены; нужна приёмка по `docs/DLSS-TESTING.md`. Ванильные сущности/ветер camera-only; reactive/transparency, FSR3/MetalFX и FG отдельно |
| #130 | Первый небольшой backport: upstream `f7b77fbc8` перенесён как engine `94b572cd2`; oversized staging allocations округляются до степени двойки и переиспользуются, копируются только фактические байты; 3 upload/GPU readback-теста прошли на Metal | Полная миграция на Nightly не начата; VSync/pacing, дальний рельеф и другие кандидаты остаются; Windows/Vulkan и долгий игровой RSS-профиль не проверялись |
| #127 | Этапы 1–2. **Картина:** журнал раскрытий заменён картой контактов (`Intel.contacts`: последнее «пуск/излучение/глушение», место, время, метка эмиссии, наблюдённая гибель, счётчик увиденных пусков), уверенность — функция возраста (Confirmed/Probable/Doubtful, TTL 6000), угроза и цены читают только published-параметры и факты наблюдений (launcher-only без донора «слеп»), уничтожение учится только из BSA. **Structured intent:** `Intent` (Plan/Sead/React/Replace) и `Aim` (юнит, since, switches, confidence) отделены от random-выбора; throttle `SWITCH_HOLD=160`, `SWITCH_CAP=3`, `ASSIGN_PER_TICK=16`, `ASSIGN_PER_CONTACT=6`, цена смены `SWITCH_GAIN=120`; в полёте цель меняется только когда картинка её убила/забыла. **Durable queue:** автосейв пишет версионированную секцию `air 1` — дроны, очередь запуска, задания (id, дрон, цель, юнит, версия, приоритет, намерение, версия рельефа), контакты, RLE-рельеф; очередь ограничена 256, устаревшие/фантомные/дублирующие задания отменяются при загрузке (`JOB_TTL=1200`), картина задания восстанавливается на свою версию, старые saves читаются (пустое небо), сценарии воздух не несут, Live/Replay не смешиваются. **Неизвестная земля не бесплатна** (`Relief.unknown=6` у повторного плана). **Объяснимость:** `enemy_picture()` дополнен aims/pending reason/aimed_by/pending_jobs без русского текста в core. Метаморфные тесты скрытых изменений (включая нагрев/замок РЭБ), save/restore посреди незавершённой очереди, детерминизм seed, 40+ массовый ретаргет. Замеры: `docs/measurements/issue-127-intent-queue-{baseline,result}.json` | GUI поверх `enemy_picture()`, игровая приёмка сохранения налёта на Windows/Linux, оценка баланса ew-adaptive (kills 59→58/59→58/56→63, потери 3→3/3→4/4→2 — следствие throttle, параметры не менялись) | | #127 | Этапы 1–2. **Картина:** журнал раскрытий заменён картой контактов (`Intel.contacts`: последнее «пуск/излучение/глушение», место, время, метка эмиссии, наблюдённая гибель, счётчик увиденных пусков), уверенность — функция возраста (Confirmed/Probable/Doubtful, TTL 6000), угроза и цены читают только published-параметры и факты наблюдений (launcher-only без донора «слеп»), уничтожение учится только из BSA. **Structured intent:** `Intent` (Plan/Sead/React/Replace) и `Aim` (юнит, since, switches, confidence) отделены от random-выбора; throttle `SWITCH_HOLD=160`, `SWITCH_CAP=3`, `ASSIGN_PER_TICK=16`, `ASSIGN_PER_CONTACT=6`, цена смены `SWITCH_GAIN=120`; в полёте цель меняется только когда картинка её убила/забыла. **Durable queue:** автосейв пишет версионированную секцию `air 1` — дроны, очередь запуска, задания (id, дрон, цель, юнит, версия, приоритет, намерение, версия рельефа), контакты, RLE-рельеф; очередь ограничена 256, устаревшие/фантомные/дублирующие задания отменяются при загрузке (`JOB_TTL=1200`), картина задания восстанавливается на свою версию, старые saves читаются (пустое небо), сценарии воздух не несут, Live/Replay не смешиваются. **Неизвестная земля не бесплатна** (`Relief.unknown=6` у повторного плана). **Объяснимость:** `enemy_picture()` дополнен aims/pending reason/aimed_by/pending_jobs без русского текста в core. Метаморфные тесты скрытых изменений (включая нагрев/замок РЭБ), save/restore посреди незавершённой очереди, детерминизм seed, 40+ массовый ретаргет. Замеры: `docs/measurements/issue-127-intent-queue-{baseline,result}.json` | GUI поверх `enemy_picture()`, игровая приёмка сохранения налёта на Windows/Linux, оценка баланса ew-adaptive (kills 59→58/59→58/56→63, потери 3→3/3→4/4→2 — следствие throttle, параметры не менялись) |
| #135 | **Core (`9d8f3da57`):** умная волна высылает ограниченный бюджет невооружённых разведчиков (Gerbera, собственные id `0x3000_0000`, не тратят combat RNG волны и не входят в её replay); они физически проходят игровые зоны вокруг отмеченных целей и через `REPORT_DELAY` передают только область, публичную категорию, канал (пролёт/излучение/РЭБ/пуск), возраст и качество — без точной точки, `SamKind`, HP, боезапаса, сети и реального id. Сбитый до донесения разведчик ничего не передаёт; уже переданное остаётся и переживает налёты. Планировщик читает отметки наравне с контактами раскрытия и назначает по наблюдаемой роли/свежести/качеству (`Mark::priority`), скрытая станция не становится целью, старая сомнительная отметка уступает свежей скромной; бюджет назначений и исходные цели волны сохранены. Save/load хранит отметки, вылеты, ожидающие донесения и проверенные зоны. **UI/диагностика (этот коммит):** на карте сети разведчик — узнаваемый жёлтый ромб с подписью «разведчик», роль в панели выбора и легенда фильтра; в боевом HUD и на карте — понятная фаза вылета (разведка/донесение/завершение) только пока сеть держит разведчика; в sandbox-режиме `truth` — янтарная метка и счётчик отметок. Причина выбора показана в `/airdef recon` и на странице меню «Разведка противника (разбор)» (из «Повторы…»): отметки best-first с разбором `приоритет = свежесть×4 + качество×3 + роль` (`recon::priority_parts`, сверен тестом с `Mark::priority`) и дроны, нацеленные на отметку. Всеведущая картина противника в обычный HUD не выводится — только явный debug/разбор. Механика, модели и текстуры не менялись. Тесты: `priority_parts`-кросс-чек, `recon_view`, панель, дерево команд | Игровая/визуальная приёмка значка и фазы на Windows/Linux; приёмка разбора в GUI; баланс приоритетов по серии seed остаётся за core-приёмкой |
По #127 реализованы карта контактов, структурированное намерение с throttle и durable-очередь: По #127 реализованы карта контактов, структурированное намерение с throttle и durable-очередь:
autosave хранит дронов, очередь запуска, задания с картиной и рельефом своей версии, поэтому autosave хранит дронов, очередь запуска, задания с картиной и рельефом своей версии, поэтому
+51 -3
View File
@@ -7,10 +7,58 @@
поэтому запись может сохраниться и без ручного копирования. поэтому запись может сохраниться и без ручного копирования.
Задача: [#122](https://gitea.maoniao.team/chexit/airdef/issues/122). Задача: [#122](https://gitea.maoniao.team/chexit/airdef/issues/122).
**Воспроизведены и исправлены две конкретные причины отключения в этом классе нагрузки.** **Воспроизведены и исправлены три конкретные причины отключения в этом классе нагрузки.**
Первая — тик и кэш высот (`1f28f83`, ниже). Вторая — событие UI и второй приказ Первая — тик и кэш высот (`1f28f83`, ниже). Вторая — событие UI и второй приказ
(`order_raid`, см. раздел «Второй налёт из UI: событие, не тик»). Без старого лога не (`order_raid`, см. раздел «Второй налёт из UI: событие, не тик»). Третья — исчерпание
утверждается, что Windows-сеанс имел именно их; GPU/FPS отдельно не измерялись. 64 MiB линейной памяти WASM полными ключами поз техники в реплеях. GPU/FPS отдельно не измерялись.
## OOM при записи поз техники
Точный лог Windows: `rust_oom` ← `RawVec<SamKey>::grow_one` ← `Recording::note_sams` ←
`Sim::step` во время обычного `tick`, с оставшимся fuel. Это не повтор прежнего OutOfFuel.
До исправления нативная регрессия с 64 непрерывно вращающимися РЛС на полной записи 12000 тиков
создавала 384000 `SamKey`: 27 MiB только в этих ключах, без учёта ёмкости `Vec`, траекторий и
событий. Активная запись и три сохранённых реплея могли превысить лимит 64 MiB.
`Recording` теперь имеет общий бюджет 32768 ключей поз. При превышении старые ключи каждой
трассы прореживаются вдвое без потери первой и последней позы, освобождённая ёмкость возвращается,
а интервал следующих samples удваивается. Запись не обрывается: регрессия проверяет бюджет
длины и реально выделенной ёмкости, а также наличие свежей позы в конце окна. Для обычных
коротких записей частота не меняется; при нехватке памяти точность старого движения снижается.
Проверки: core release 233 + 8 сценариев (8 ignored), adapter 68 + 1 boundary + 5 сценариев;
настоящий WASM contract 30 шагов. Дополнительный flat-world WASM-стресс: 64 РЛС, 60 волн по
4 Shahed на 4000 блоках, 24002 тика и два полных окна записи, 185 шагов; max tick fuel
137346889/300M, command 129151/1B, failures=0. Лимит памяти 64 MiB не увеличивался. Это
синтетический host без GPU и не приёмка Windows GUI.
### Прореживание не съедает короткие переходы (#142)
Прореживание #122 не различало непрерывную позу и дискретный факт: при большом числе меняющихся
РЛС оно пропускало целиком открытие крышки ТПК (`launch::OPEN_TICKS = 6` тиков, короче шага
sampling) и могло убрать уже записанный переход — ракета в реплее вылетала с нарисованной
закрытой крышкой, а `spent_cells` менялось только на следующем общем сэмпле.
Теперь `Recording::note_sams` вызывается каждый тик: позы по-прежнему снимаются на адаптивной
сетке `sam_step` из прежнего бюджета 32768, а дискретные переходы (`cap_cell`, `spent_cells`,
`radar_on`, режим и роль) и кадры открытия крышки пишутся на том тике, когда произошли, и
помечаются как события. Начало открытия дотягивается отдельным ключом на тик раньше, поэтому
ramp занимает ровно `OPEN_TICKS`, а не «примерно». Прореживание поз половинит только позы и
сохраняет события, первую и последнюю позу.
У событий свой явный бюджет — 4096 ключей на запись поверх 32768 поз; общий бюджет поз не
поднимался. При переполнении старые события перестают быть критическими (прореживаются как
позы), новейшие сохраняются: под записью с «болтливым» датчиком реплей остаётся ограниченным,
а свежий пуск — точным.
Проверки: `airdef-core` `sim::record::tests::decimation_keeps_a_cold_launch_cover_ejection_and_the_radar_switch`
— 64 вращающихся РЛС + С-400 при `sam_step = 16`, выброс на тике 4103: за тик до выброса
`cap_open = 0.8333333` (как в контрольной записи без давления на бюджет), `spent_cells = 0`
до и `1` на тике выброса, отмена/закрытие и `radar_on` читаются на своих тиках, повторное
прореживание их не убирает;
`critical_transitions_have_their_own_explicit_budget` — 64 РЛС, переключающихся каждый тик,
1500 тиков: событий ровно 4096, позы в своём бюджете, новейшее переключение точное.
## Второй налёт из UI: событие, не тик ## Второй налёт из UI: событие, не тик
+1 -1
View File
@@ -16,7 +16,7 @@
| `horizon/`, `.gitmodules` | Закреплённый сабмодуль отдельного форка Horizon | | `horizon/`, `.gitmodules` | Закреплённый сабмодуль отдельного форка Horizon |
| `tools/airdef.py` | Сборка мода и установка в папку игры | | `tools/airdef.py` | Сборка мода и установка в папку игры |
| `tools/gen_models.py`, `tools/gen_tex.py`, `tools/gen_sounds.py` | Генераторы контента (см. ниже) | | `tools/gen_models.py`, `tools/gen_tex.py`, `tools/gen_sounds.py` | Генераторы контента (см. ниже) |
| `tools/acoustics_check.py`, `tools/hd_bench.py` | Проверочные скрипты | | `tools/acoustics_check.py`, `tools/hd_bench.py`, `tools/raid_bench.py` | Проверочные скрипты (`raid_bench` — воспроизводимый бой+replay замер рендера, #147) |
| `docs/` | Документация (этот файл, `INSTALL.md`, `ACOUSTICS.md`, `HD-RENDERER.md`) | | `docs/` | Документация (этот файл, `INSTALL.md`, `ACOUSTICS.md`, `HD-RENDERER.md`) |
| `install.sh`, `play.sh`, `dist/` | Установка и запуск | | `install.sh`, `play.sh`, `dist/` | Установка и запуск |
| `run-home/`, `run-home-bench/`, `run-home-smoke/` | Тестовые игровые папки, не часть мода | | `run-home/`, `run-home-bench/`, `run-home-smoke/` | Тестовые игровые папки, не часть мода |
@@ -0,0 +1,103 @@
# Issue #126, пункт 4: пропуск рэймарча огненного шара при нулевом fade — проверка
Мёртвая работа в `airdef-mod/shaders/effects.wgsl` (раздел «2. Fireballs and their smoke»). Счёт и
картинка не менялись ни на пиксель; меняется только то, что при `fade == 0` цикл марша больше не
крутится.
## Изменение
```wgsl
// было (для каждого шара): ds, затем сразу цикл
for (var s = 0; s < steps; s++) { ... let n = fbm(...); ... }
// стало
if fade > 0.0 {
for (var s = 0; s < steps; s++) { ... } // тот же цикл, тот же выход по trans < 0.02
}
// свечение огня после марша осталось; оно само под `if heat > 0.0`
```
Почему картинка та же: при `fade == 0` на каждом шаге `density = shape * (1.2 + n*2.0) * fade == 0`,
значит `absorb = 1 - exp(0) == 0`, `lit += trans * absorb * c` ничего не добавляет, а
`trans *= 1 - absorb` не меняет `trans`. HD-ветка гасит `fade` уже к `k = 0.28`
(`1 - smoothstep(0.08, 0.28, k)`), поэтому у позднего шара марш (6–14 вызовов `fbm` на пиксель)
не виден, но выполнялся. Свечение (`heat = 1 - smoothstep(0.05, 0.55, k)`) живёт до `k = 0.55` и
вынесено из нового условия; второй `if heat > 0.0` убирает только заведомо нулевое слагаемое.
Шаги, разрешение, плотность, семплирование, свет и туннели не тронуты.
## Стенд
- Apple M5, Metal, 2560×1440 offscreen; engine pin `3428a571b`, база мода `c08b73729`, правка
`7d77c09f0` (только `effects.wgsl`).
- Мир `Polygon` — копия в `run-home/saves` рабочего дерева (оригинальные сохранения не трогались),
свежий `HORIZON_HOME` в `run-home-bench/home` на прогон.
- Сцена: spectator, `tp @s 40.5 76 40.5 135 <pitch>`, `time set 6000`,
`advance_time/advance_weather false`, `weather clear`, `doMobSpawning false`,
`randomTickSpeed 0`, `kill @e[type=!minecraft:player]`, HUD скрыт; `HORIZON_HD_TAA=0`,
`HORIZON_HD_WIND=0`, `HORIZON_HD_CLOUDS=0`, `HORIZON_HD_VOLFOG=0`, `HORIZON_HD_WATER=0`,
`HORIZON_HD_AO=0`. В кадре только небо и один/32 шара: никакого дрейфа LOD и сущностей.
- Все прогоны игры — под `flock -x /tmp/airdef-bench.lock` (один клиент за раз).
## Пиксельный паритет: A/B на одном замороженном кадре
Кросс-процессные прогоны расходятся (LOD/стриминг, партиклы, интерполяция настроек мода по
частичному тику), поэтому сравнение сделано **в одном процессе**: временная сборка мода (в коммит
не входит, дерево после неё чистое) содержала
- `testblast` — ставит шар(ы) в фиксированной мировой точке с `start 0, life 4000`, так что
состояние зависит только от абсолютного тика;
- выбор шейдера файлом `<HORIZON_HOME>/horizon-mods/.horizon-mod-data/airdef/harness-command`
(`old` — `effects.wgsl` из `7d77c09f0~1`, `new` — из `7d77c09f0`; обе версии вкомпилированы);
- настройки мода (`set-params`, `set-lights`, `set-smoke`) выталкиваются каждый кадр, иначе хост
интерполирует последние два тика по частичному тику и кадр «плывёт» даже на паузе.
Игра ставится на паузу без меню (F3+Esc) в нужном тике, затем на **этом же тике** снимаются кадры
`new → old → new` (переключение шейдера — запись файла). `p[1020] = 1` в харнессе убирает частичный
тик из часов эффектов.
Результаты (2560×1440, кадр целиком; `mean` — средняя разница по каналам из 255, методика
`tools/hd_bench.py`: `compare_runs`, движущиеся пиксели маскируются по размаху между `new` и `new2`):
| сцена | тик | k | путь | old-vs-new mean | >20/255 | шум того же шейдера (new-vs-new2) |
|---|---|---|---|---|---|---|
| 32 шара, небо | 623 | 0.156 | активный марш | 0.0054 | 0 | 0.0030 |
| 32 шара, небо | 1603 | 0.401 | fade = 0, марш пропущен | 0.0075 | 0 | 0.0069 |
| 1 шар 20 блоков, небо | 620 | 0.155 | активный марш | 0.0455 | 0 | 0.0597 |
| 1 шар 20 блоков, небо | 1608 | 0.402 | fade = 0, марш пропущен | 0.0436 | 0 | 0.0770 |
Покадрово: максимум расхождения **1/255** (32 шара) и **2/255** (один шар), пикселей с разницей
> 5/255 — **ноль**; разница old-vs-new не больше, чем у двух кадров одного и того же шейдера.
То есть правка невидима и в активном пути, и в пропущенном.
## Пиксельный паритет в штатной сцене hd_bench
`tools/hd_bench.py --only polygon_noon` (Polygon, полдень, статичное окружение
`HORIZON_HD_WIND/CLOUDS/VOLFOG=0`), старый мод против нового, под локом:
- old: GPU 18.06 мс; new: GPU 21.29 мс (бюджет 18 мс превышен в обоих — это шум/нагрузка стенда:
тот же кадр в этой сессии давал 18–31 мс);
- сравнение кадров new к базе old: средняя разница 0.79/255, пикселей >20/255 — 0.58% (порог 5%),
т.е. в пределах мерцания TAA между прогонами; в этой сцене нет взрывов, ветка правки не
выполняется.
## Время кадра (честно)
Парные `bench` на одном замороженном кадре, шейдеры чередуются каждую секунду (снимает дрейф
частот/тепла), сцена — небо, late-life шары невидимы:
| сцена | тик | new, медиана | old, медиана | old − new |
|---|---|---|---|---|
| 32 шара (каждый ~полэкрана) | 1606 | 79.27 мс | 79.63 мс | +0.37 мс (mean +1.15, σ 3.65, N=10) |
| 1 шар на 20 блоках | 1604 | 15.49 мс | 16.30 мс | +0.82 мс (mean +0.95, σ 3.79, N=16) |
Разброс между парами больше эффекта, знак нестабилен: на M5 выигрыш **ниже шума** измерения кадра.
Это ожидаемо — экономится один 7-шаговый `fbm`-марш по площади шара на пиксель, доли миллисекунды
на типичном кадре; замер требует изоляции прохода мода (в таймингах паков прохода мода нет).
## Что проверено
- `cargo test` в `airdef-mod`: 113 lib + 1 `core_boundary` + 2 `saturation` + 5 `scenarios` = 121,
0 падений.
- `python3 tools/test_hd_bench.py`: 5 тестов OK.
- Шаги/плотность/свет/туннели не менялись: см. diff `7d77c09f0` (только `effects.wgsl`).
@@ -0,0 +1,118 @@
{
"issue": 126,
"point": 4,
"base": "c08b73729",
"engine_pin": "3428a571b",
"change": "7d77c09f0",
"method": "same-process same-frozen-tick A/B (temporary harness build, reverted); pair benches interleaved",
"scene": {
"world": "Polygon (copy)",
"resolution": [
2560,
1440
],
"env": {
"HORIZON_HD_TAA": "0",
"HORIZON_HD_WIND": "0",
"HORIZON_HD_CLOUDS": "0",
"HORIZON_HD_VOLFOG": "0",
"HORIZON_HD_WATER": "0",
"HORIZON_HD_AO": "0"
},
"tick_clock": "p[1020]=1 (no partial tick), blast start 0 life 4000",
"parity_frames": {
"32_blasts": [
"/tmp/st4/new_623.png",
"/tmp/st4/old_623.png",
"/tmp/st4/new2_623.png",
"/tmp/st4/new_1603.png",
"/tmp/st4/old_1603.png",
"/tmp/st4/new2_1603.png"
],
"one_blast": [
"/tmp/st3/new_620.png",
"/tmp/st3/old_620.png",
"/tmp/st3/new2_620.png",
"/tmp/st3/new_1608.png",
"/tmp/st3/old_1608.png",
"/tmp/st3/new2_1608.png"
]
}
},
"pixel_parity": [
{
"scene": "32 blasts, sky",
"tick": 623,
"k": 0.156,
"path": "march runs (fade>0)",
"old_vs_new_mean_255": 0.0054,
"px_over_20": 0,
"same_shader_floor_mean_255": 0.003,
"max": 1
},
{
"scene": "32 blasts, sky",
"tick": 1603,
"k": 0.401,
"path": "march skipped (fade=0)",
"old_vs_new_mean_255": 0.0075,
"px_over_20": 0,
"same_shader_floor_mean_255": 0.0069,
"max": 1
},
{
"scene": "one blast at 20 blocks, sky",
"tick": 620,
"k": 0.155,
"path": "march runs (fade>0)",
"old_vs_new_mean_255": 0.0455,
"px_over_20": 0,
"same_shader_floor_mean_255": 0.0597,
"max": 2
},
{
"scene": "one blast at 20 blocks, sky",
"tick": 1608,
"k": 0.402,
"path": "march skipped (fade=0)",
"old_vs_new_mean_255": 0.0436,
"px_over_20": 0,
"same_shader_floor_mean_255": 0.077,
"max": 2
}
],
"frame_time": [
{
"scene": "32 blasts, late life",
"tick": 1606,
"new_median_ms": 79.274,
"old_median_ms": 79.628,
"old_minus_new_median_ms": 0.37,
"old_minus_new_mean_ms": 1.15,
"stdev_ms": 3.65,
"pairs": 10
},
{
"scene": "one blast at 20 blocks, late life",
"tick": 1604,
"new_median_ms": 15.493,
"old_median_ms": 16.302,
"old_minus_new_median_ms": 0.82,
"old_minus_new_mean_ms": 0.95,
"stdev_ms": 3.79,
"pairs": 16
}
],
"hd_bench_polygon_noon_static": {
"old_gpu_avg_ms": 18.06,
"new_gpu_avg_ms": 21.29,
"budget_ms": 18,
"vs_baseline_mean_255": 0.79,
"vs_baseline_pct_over_20": 0.58,
"note": "no blasts in the scene; the changed branch is not taken; budget exceeded in both runs (this session's same scene ranged 18-31 ms)"
},
"tests": {
"cargo test airdef-mod": "121 passed, 0 failed",
"tools/test_hd_bench.py": "5 passed"
}
}
@@ -0,0 +1,102 @@
# Issue #126, этап 1: retained-геометрия моделей мода — замеры
Первый самостоятельный этап направления A #126: грани моделей мода резолвятся против атласа
один раз на generation пака, кадр только трансформирует и освещает их. Это **не** GPU-instancing:
вершины по-прежнему собираются на CPU и загружаются каждый кадр; объём upload не менялся.
Изменение только в рендере (`game/mod_models.rs` + span/счётчики/инвалидация), боевая симуляция
(WASM-мод) не тронута — тот же `airdef.hmod` в обоих прогонах A/B.
## Стенд
- Apple M5 (10 ядер, 16 ГБ), macOS, Metal. **Ryzen 5600X / RTX 3060 не профилировались** —
приёмка на целевом железе pending (контракт #126).
- Engine pin `ed751714e` (ветка форка `agent/126-engine-first-stage`), AirDef base `60f1bf0fd`.
Baseline-бинарник — тот же pin без правки; after — с правкой. Оба `--profile fast --features mods`.
- 2560×1440 offscreen (окно 1280×720 @2x), пресет HD, `HORIZON_HD_SCALE=1`, in-frame
(`--in-frame`: фидбек мода читается `chat-log`, тик в кадре — одинаково в A/B),
`HORIZON_NO_AUDIO=1`, `HORIZON_SPIKES=0` (span каждого кадра в логе),
`HORIZON_SHADER_PACK_TIMING=1`. Одна игра за раз; чужих игр во время парных прогонов не было.
- Мир `Polygon` (копия `run-home/saves/Polygon`), свежий `HORIZON_HOME` на прогон.
Камера `tp @s 40 76 40 135 25`, `time set 6000`, `advance_time/advance_weather false`,
`weather clear`, creative, HUD скрыт.
## Сцена и драйвер
Драйвер — scratch-скрипт `/tmp/airdef-issue126-run/profile.py` (в коммит не входит; команды и
тайминги зафиксированы здесь и в `report.json`):
1. 14 батарей: `airdef deploy s400/patriot/pantsir/gepard/nasams/irist/tor` ×2.
2. Raid: `airdef wave shahed 40 900`, `airdef wave kh101 16 1400`, `airdef wave mix 24 700`.
Волна принимается не сразу: противник ищет площадки и ждёт terrain (~15–20 с), факт принятия
проверялся по чату («ВОЗДУШНАЯ ТРЕВОГА», «В воздухе: N») и counters `mod_models.models`.
3. `bench N` (сброс frame-stats и counters, ответ — p50/p95/p99/max frame/CPU/GPU + фазы),
`stats` (counters `mod_models`), `sample` процесса на окно bench, скриншот.
Static-сцена: только батареи, `HORIZON_HD_TAA=0 HORIZON_HD_WIND=0 HORIZON_HD_CLOUDS=0
HORIZON_HD_VOLFOG=0`, 3 кадра подряд; движущиеся пиксели (вода) маскируются по размаху >16/255
между кадрами одного прогона (методика `tools/hd_bench.py`), сравнение A/B — по статичным.
## Результаты (парные прогоны, одна сцена)
Raid, develop 30 с + bench 12 с (`before-raid3` / `after-raid`), ~135 моделей/кадр:
| Метрика | before | after |
|---|---|---|
| `entity_geometry` CPU avg / p95 / p99, мс | 5.71 / 8.7 / 10.6 | 1.57 / 2.2 / 2.7 |
| фаза `prepare` avg, мс | 23.49 | 7.05 |
| frame CPU avg / p50 / p95 / p99, мс | 78.8 / 75.5 / 133.0 / 263.4 | 71.8 / 65.3 / 112.7 / 181.0 |
| span `mod_models` CPU avg / p95 / p99, мс | — (внутри `entity_geometry`) | 1.32 / 2.0 / 2.3 |
Combat-плотный raid, develop 45 с + bench 15 с (`before-combat` / `after-combat`); фазы боя
не синхронизированы по тикам (before: 28 в воздухе, 12 сбито; after: 40 в воздухе, 0 сбито):
| Метрика | before | after |
|---|---|---|
| `entity_geometry` CPU avg / p95 / p99, мс | 6.5 / 12.1 / 15.0 | 1.95 / 3.3 / 4.4 |
| фаза `prepare` avg, мс | 20.13 | 7.78 |
| frame CPU avg / p50 / p95 / p99, мс | 85.8 / 84.8 / 127.2 / 167.5 | 49.5 / 48.9 / 71.8 / 77.1 |
Counters `mod_models` (after-raid, окно bench, 155 кадров): models 21001 (~135/кадр),
quads 2 760 334 (~17.8 тыс./кадр), vertex_bytes 485.8 МБ (~3.1 МБ/кадр, 44 Б/вершина),
motion_bytes 618.3 МБ (~4 МБ/кадр, 56 Б/вершина), mesh_builds 0, atlas_scans 0 — в установившемся
кадре bake нет, только трансформы. Байты upload до/после одинаковы (вершины те же).
Static (4 батареи, ~60 моделей/кадр): `prepare` 6.38 → 1.51 мс, frame CPU p50 15.1 → 10.9 мс,
p95 42.7 → 15.5, p99 77.1 → 18.3 (settle 8 с). **Пиксели A/B при settle 25 с (LOD сошёлся):
0 статичных пикселей с разницей >20/255 из 3.44 млн (93.2% кадра статичны), mean abs diff 0.128.**
При settle 8 с разница 3991 px (0.116%) — вся в полосе горизонта y≤385 (дальний LOD не сошёлся,
after-бинарник быстрее → другое состояние LOD к снимку); baseline↔baseline при том же settle — 14 px.
## Reload и world unload (lifecycle-smoke)
`lifecycle.py`: батареи → скриншот → F3+T (reload) → скриншот → Esc → «Save and Quit to Title» →
`open Polygon` → батареи → скриншот. Counters after: atlas_scans 1 → 2 → 3, mesh_builds
17 → 34 → 51 (17 состояний моделей перестроены после reload и после unload), модели рисуются
в каждом этапе. Пиксели pre/post reload при 25 с ожидания: **before 0.3003%, after 0.2982%**
статичных пикселей >20/255 — одинаковая у обоих бинарников остаточная разница самого reload
(атлас/LOD после `clear_lod`), не регрессия правки; при 12 с ожидания разница больше у обоих
(LOD не сошёлся), вся в полосе горизонта, на моделях — ноль.
## Тесты
```sh
cd horizon && cargo test --profile fast -p horizon-client --bin horizon-client --features mods mod_models::tests
```
- `retained_emit_matches_the_per_frame_bake` — вершины retained-пути бит-в-бит равны прежнему
покадровому bake (`block_model_vertices` + material/post-pass) на матрице трансформов
(scale × rotation × translation) × glow × light × emission, включая previous-позиции motion (#124).
- `special_materials_match_names_and_centres` — таблица special-материалов и строгие границы
прямоугольников (центр квада).
## Ограничения и что дальше
- Замеры только на M5/Metal; 5600X/3060 и M5-боевой p99-trace — pending acceptance #126.
- In-frame режим замера (тик в кадре); server-thread путь проверен smoke-прогоном (HD, модели,
reload работают), парные замеры в нём не снимались.
- Фазы боя в A/B не синхронизированы по тикам (wall-clock waits); ordered combat trace harness
не строился — правка только рендерная, sim/RNG не тронуты (diff scope).
- Upload bytes/frame не уменьшены: GPU-instancing (per-instance буферы, GPU-интерполяция,
indirect draws) — следующий этап A. HD smoke (направление B) не тронут.
- Скрипты драйверов — scratch (`/tmp/airdef-issue126-run/`), в репозиторий не входят;
воспроизведение — по командам выше и `report.json`.
@@ -0,0 +1,338 @@
{
"issue": 126,
"stage": "first: retained CPU-resolved model meshes (not GPU instancing)",
"engine_pin": "ed751714e0d24d02062976ee615e994186284170",
"airdef_base": "60f1bf0fd873d89a28b47bc7316b2fc02a79e669",
"machine": "Apple M5, 10 cores, 16 GB, macOS, Metal backend",
"render": "2560x1440 offscreen (window 1280x720 @2x), HD preset, HORIZON_HD_SCALE=1, in-frame mode, HORIZON_NO_AUDIO=1, HORIZON_SPIKES=0, HORIZON_SHADER_PACK_TIMING=1",
"mod": "airdef.hmod built from airdef-mod @ base (unchanged between A/B), packer pinned ed751714",
"scene": {
"world": "Polygon (copy of run-home/saves/Polygon), fresh HORIZON_HOME per run",
"camera": "tp @s 40 76 40 135 25, time set 6000, advance_time/advance_weather false, weather clear, gamemode creative, HUD hidden (f1)",
"batteries": "deploy s400/patriot/pantsir/gepard/nasams/irist/tor twice (14 complexes)",
"raid": "wave shahed 40 900; wave kh101 16 1400; wave mix 24 700",
"static_env": "HORIZON_HD_TAA=0 HORIZON_HD_WIND=0 HORIZON_HD_CLOUDS=0 HORIZON_HD_VOLFOG=0",
"driver": "/tmp/airdef-issue126-run/profile.py (scratch; commands and waits recorded here)"
},
"runs": {
"before-raid3": {
"frames": 130,
"cpu_ms": {
"avg_ms": 78.76,
"max_ms": 321.6,
"p50_ms": 75.53,
"p95_ms": 132.96,
"p99_ms": 263.41
},
"phases_avg_ms": {
"prepare": 23.49,
"render": 25.45,
"tick": 28.1,
"update": 1.73
},
"entity_geometry_cpu_ms": {
"n": 1355,
"avg": 5.71,
"p50": 6.0,
"p95": 8.7,
"p99": 10.6,
"max": 29.1
},
"mod_models_span_cpu_ms": null,
"mod_models_counters": null,
"airborne_at_bench": "В воздухе: 19, ракет: 0, ПВО: 14, сбито: 0, поражений: 0, разбились о препятствия: 4; удары по ПУ: пущено 0, уничтожено 0, подавле"
},
"after-raid": {
"frames": 124,
"cpu_ms": {
"avg_ms": 71.75,
"max_ms": 427.98,
"p50_ms": 65.26,
"p95_ms": 112.68,
"p99_ms": 181.0
},
"phases_avg_ms": {
"prepare": 7.05,
"render": 30.29,
"tick": 30.43,
"update": 3.97
},
"entity_geometry_cpu_ms": {
"n": 1260,
"avg": 1.57,
"p50": 1.6,
"p95": 2.2,
"p99": 2.7,
"max": 33.9
},
"mod_models_span_cpu_ms": {
"n": 1065,
"avg": 1.32,
"p50": 1.3,
"p95": 2.0,
"p99": 2.3,
"max": 2.7
},
"mod_models_counters": {
"atlas_scans": 0,
"frames": 155,
"mesh_builds": 0,
"models": 21001,
"motion_bytes": 618314816,
"motion_quads": 2760334,
"quads": 2760334,
"vertex_bytes": 485818784
},
"airborne_at_bench": "В воздухе: 24, ракет: 0, ПВО: 14, сбито: 0, поражений: 0, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавле"
},
"before-combat": {
"frames": 166,
"cpu_ms": {
"avg_ms": 85.79,
"max_ms": 185.08,
"p50_ms": 84.82,
"p95_ms": 127.19,
"p99_ms": 167.54
},
"phases_avg_ms": {
"prepare": 20.13,
"render": 35.38,
"tick": 29.07,
"update": 1.21
},
"entity_geometry_cpu_ms": {
"n": 1709,
"avg": 6.5,
"p50": 5.8,
"p95": 12.1,
"p99": 15.0,
"max": 18.4
},
"mod_models_span_cpu_ms": null,
"mod_models_counters": null,
"airborne_at_bench": "В воздухе: 28, ракет: 0, ПВО: 14, сбито: 12, поражений: 0, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавл"
},
"after-combat": {
"frames": 275,
"cpu_ms": {
"avg_ms": 49.47,
"max_ms": 88.18,
"p50_ms": 48.89,
"p95_ms": 71.79,
"p99_ms": 77.13
},
"phases_avg_ms": {
"prepare": 7.78,
"render": 24.58,
"tick": 16.23,
"update": 0.88
},
"entity_geometry_cpu_ms": {
"n": 1861,
"avg": 1.95,
"p50": 1.8,
"p95": 3.3,
"p99": 4.4,
"max": 19.5
},
"mod_models_span_cpu_ms": {
"n": 1733,
"avg": 1.63,
"p50": 1.5,
"p95": 2.8,
"p99": 3.9,
"max": 4.4
},
"mod_models_counters": {
"atlas_scans": 0,
"frames": 286,
"mesh_builds": 3,
"models": 44077,
"motion_bytes": 1173606784,
"motion_quads": 5239316,
"quads": 5239316,
"vertex_bytes": 922119616
},
"airborne_at_bench": "В воздухе: 40, ракет: 0, ПВО: 14, сбито: 0, поражений: 0, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавле"
},
"before-static": {
"frames": 174,
"cpu_ms": {
"avg_ms": 17.92,
"max_ms": 88.07,
"p50_ms": 15.12,
"p95_ms": 42.66,
"p99_ms": 77.07
},
"phases_avg_ms": {
"prepare": 6.38,
"render": 7.6,
"tick": 3.9,
"update": 0.04
},
"entity_geometry_cpu_ms": {
"n": 1094,
"avg": 4.21,
"p50": 4.6,
"p95": 6.6,
"p99": 7.1,
"max": 27.1
},
"mod_models_span_cpu_ms": null,
"mod_models_counters": null,
"airborne_at_bench": "В воздухе: 0, ракет: 0, ПВО: 14, сбито: 0, поражений: 0, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавлен"
},
"after-static": {
"frames": 190,
"cpu_ms": {
"avg_ms": 11.1,
"max_ms": 20.46,
"p50_ms": 10.92,
"p95_ms": 15.54,
"p99_ms": 18.3
},
"phases_avg_ms": {
"prepare": 1.51,
"render": 6.47,
"tick": 2.97,
"update": 0.16
},
"entity_geometry_cpu_ms": {
"n": 1163,
"avg": 1.29,
"p50": 1.3,
"p95": 1.9,
"p99": 2.1,
"max": 26.3
},
"mod_models_span_cpu_ms": {
"n": 913,
"avg": 1.04,
"p50": 1.0,
"p95": 1.4,
"p99": 1.5,
"max": 1.6
},
"mod_models_counters": {
"atlas_scans": 0,
"frames": 196,
"mesh_builds": 0,
"models": 11760,
"motion_bytes": 322255360,
"motion_quads": 1438640,
"quads": 1438640,
"vertex_bytes": 253200640
},
"airborne_at_bench": "В воздухе: 0, ракет: 0, ПВО: 14, сбито: 0, поражений: 0, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавлен"
},
"before-static-long": {
"frames": 237,
"cpu_ms": {
"avg_ms": 9.68,
"max_ms": 15.56,
"p50_ms": 9.59,
"p95_ms": 12.85,
"p99_ms": 14.01
},
"phases_avg_ms": {
"prepare": 3.72,
"render": 4.32,
"tick": 1.51,
"update": 0.12
},
"entity_geometry_cpu_ms": {
"n": 1951,
"avg": 3.29,
"p50": 3.5,
"p95": 3.9,
"p99": 4.1,
"max": 13.8
},
"mod_models_span_cpu_ms": null,
"mod_models_counters": null,
"airborne_at_bench": "В воздухе: 0, ракет: 0, ПВО: 14, сбито: 0, поражений: 0, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавлен"
},
"after-static-long": {
"frames": 181,
"cpu_ms": {
"avg_ms": 14.21,
"max_ms": 24.87,
"p50_ms": 14.27,
"p95_ms": 20.55,
"p99_ms": 23.39
},
"phases_avg_ms": {
"prepare": 1.92,
"render": 8.27,
"tick": 3.64,
"update": 0.37
},
"entity_geometry_cpu_ms": {
"n": 1506,
"avg": 1.15,
"p50": 1.0,
"p95": 2.0,
"p99": 2.2,
"max": 14.9
},
"mod_models_span_cpu_ms": {
"n": 1354,
"avg": 0.88,
"p50": 0.8,
"p95": 1.6,
"p99": 1.7,
"max": 1.8
},
"mod_models_counters": {
"atlas_scans": 0,
"frames": 183,
"mesh_builds": 0,
"models": 10980,
"motion_bytes": 300881280,
"motion_quads": 1343220,
"quads": 1343220,
"vertex_bytes": 236406720
},
"airborne_at_bench": "В воздухе: 0, ракет: 0, ПВО: 14, сбито: 0, поражений: 0, разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, подавлен"
}
},
"pixel_ab": {
"static_settle25": {
"static_pixels_pct": 93.2,
"diff_gt20": 0,
"diff_gt60": 0,
"mean_abs_diff": 0.128
},
"static_settle8": {
"static_pixels_pct": 93.1,
"diff_gt20": 3991,
"diff_gt60": 0,
"note": "LOD not converged at 8 s; diffs all in horizon band y<=385, none on models; baseline-vs-baseline at same settle: 14 px"
},
"reload_lifecycle_settle25": {
"before_diff_gt20_pct": 0.3003,
"after_diff_gt20_pct": 0.2982,
"note": "same residual in both binaries (atlas/LOD after clear_lod); at 12 s settle both larger, all in horizon band, zero on models"
}
},
"tests": {
"command": "cargo test --profile fast -p horizon-client --bin horizon-client --features mods mod_models::tests",
"result": "2 passed (retained_emit_matches_the_per_frame_bake, special_materials_match_names_and_centres)"
},
"lifecycle_counters_after": {
"pre_reload": {
"atlas_scans": 1,
"mesh_builds": 17
},
"post_reload": {
"atlas_scans": 2,
"mesh_builds": 34
},
"post_unload_reenter": {
"atlas_scans": 3,
"mesh_builds": 51
}
},
"engine_commit": "a861c1ed2402fb13950a3c3049d16e9971489c24",
"engine_branch": "kimi-work-124"
}
@@ -0,0 +1,58 @@
{
"schema": 1,
"issue": 145,
"title": "Intercept regression under WASM saturation: 522 -> 302 (#133) -> 243 (#134)",
"scenario": "airdef-mod/tests/budgets/wasm_flat_budget.toml",
"checkpoint_tick": 2102,
"engine": "2bcce642362ab5d3f04de193e390d8293cd1bf30",
"fuel_budget_per_tick": 300000000,
"method": "One unchanged fixture, one WASM host (cargo-horizon-mod test --fuel-profile budget), one SDK; each slice built from its own commit against the pinned engine. The checkpoint stats line is read by a deliberate expect.feedback mismatch that prints the real line; fuel counters come from the host. Native replica: airdef-mod/tests/saturation.rs (same sim, host block tracer, deterministic).",
"ab_checkpoint": [
{"slice": "main release v0.4.0-rc1", "commit": "c525feb", "kills": 522, "hits": 1789, "missiles_airborne": 5},
{"slice": "parent of #133", "commit": "95739c95b", "kills": 522, "hits": 1789, "missiles_airborne": 5, "fuel_max_tick": 113866321},
{"slice": "#133 class/speed from measurements", "commit": "ac7521936", "kills": 302, "hits": 2024, "missiles_airborne": 8, "fuel_max_tick": 114068675},
{"slice": "#134 radar profiles", "commit": "858735a4c", "kills": 243, "hits": 2083, "missiles_airborne": 24, "fuel_max_tick": 135803282},
{"slice": "kimi-work HEAD", "commit": "a983177d3", "kills": 243, "hits": 2083, "missiles_airborne": 24, "fuel_max_tick": 136067073}
],
"decomposition_variants_wasm": [
{"variant": "#133 with class estimate forced Unknown", "base": "ac7521936", "kills": 249, "hits": 2092, "note": "confounded: Unknown also disables last-chance and halves the ballistic salvo; class/roles is not the #133 cause (native class-off 296 ~= baseline 294)"},
{"variant": "#134 cue restricted to separate radars (cue-off)", "base": "858735a4c", "kills": 325, "hits": 2011, "fuel_max_tick": 124349576, "note": "recovers the whole #134 drop: the embedded cue flood is the cause"},
{"variant": "#134 own_fire_within relaxed to own_within (no FIRE_QUALITY/product gate)", "base": "858735a4c", "kills": 243, "hits": 2083, "fuel_max_tick": 135800131, "note": "zero effect: embedded radars always produce Fire plots of quality >= 64"},
{"variant": "#134 channel limit never binds", "base": "858735a4c", "kills": 243, "hits": 2083, "fuel_max_tick": 135438135, "note": "zero effect: embedded profiles have channels = 0"},
{"variant": "cue precise + carry network velocity (Fix D)", "base": "a983177d3", "kills": 260, "hits": 2051, "note": "partial: early cue authority fires with a stale carried velocity"},
{"variant": "cue restricted to separate fire-quality radars (Fix F, chosen)", "base": "a983177d3", "kills": 325, "hits": 2011, "fuel_max_tick": 118325396, "note": "the fix; restores embedded acquisition to pre-#134 beam/revisit/lock"}
],
"native_replica_checkpoint": {
"note": "Deterministic native replica (tests/saturation.rs); chaotic combat answers render rays a tick later than the WASM host, so counters sit a few apart from WASM. Same drops, same fix.",
"pre133": {"kills": 605, "hits": 1706},
"s133": {"kills": 294, "hits": 2037},
"s134_head": {"kills": 247, "hits": 2079},
"class_off": {"kills": 296, "hits": 2045},
"cue_off": {"kills": 314, "hits": 2022},
"authority_relaxed": {"kills": 247, "hits": 2079},
"channels_off": {"kills": 247, "hits": 2079},
"fix_f": {"kills": 314, "hits": 2022}
},
"causes": {
"drop_133_522_to_302": "Track.vel became an estimate from noisy measured places (was the target's true velocity); the forecast, the aim lead and the interceptor's launch Fix all read it. Class-off ~= baseline, so class/roles is not the cause. The pre-#133 522 used the target's true velocity, which the #133 contract ('class and speed only from measurements') forbids; this portion is the intentional cost of honest measurement-only tracks.",
"drop_134_302_to_243": "#134 extended the network cue from the separate engagement radar to every fire-quality radar, including each weapon's embedded radar. Cueing every relayed contact each tick flooded the embedded fire control with one-tick plots whose noisy velocity degraded guidance. Restricting the cue back to separate radars recovers the drop (243 -> 325).",
"own_fire_FIRE_QUALITY_channels": "Not causes here: relaxing the own-fire gate or the channel limit each changed nothing (243 -> 243). Embedded radars always measure Fire plots of quality >= 64 and have no channel limit.",
"issue_140": "Does not affect this loadout, by fact: the fixture deploys 64 integrated complexes and no separate radar, so every profile is embedded with channels = 0; the channel-age bug binds only where a profile has channels. The channels-off A/B changed nothing."
},
"fix": {
"file": "airdef-mod/src/sim/sight.rs",
"change": "The network cue looks only through a separate fire-quality radar (sam.kind == SamKind::Radar), never the weapon's embedded radar; the embedded radar keeps its beam/revisit/lock acquisition as before #134.",
"preserved": "All radar profiles, channel limits, own-fire authority (own_fire_within / FIRE_QUALITY), and the measurement-only class/speed contract (#133). No target truth is injected.",
"tests": [
"airdef-mod/tests/saturation.rs (deterministic checkpoint replica + audit + #140 loadout fact)",
"airdef-mod/src/sim/sensor_tests.rs::a_network_plot_cues_a_separate_fire_radar_but_not_the_embedded_one",
"airdef-mod/src/sim/why.rs::Sim::launch_audit (on-demand tolerance diagnostic)"
]
},
"after_fix_wasm": {
"checkpoint_tick_2102": {"kills": 325, "hits": 2011, "airborne": 184, "missiles_airborne": 4, "fuel_max_tick": 118325396, "fuel_failures": 0},
"final_tick_3302": {"kills": 385, "hits": 2472, "airborne": 9, "missiles_airborne": 2, "fuel_max_tick": 176588234, "fuel_failures": 0},
"late_raid_chat": ["Разведка противника: впереди налёта высланы разведчики"]
},
"target_range": "Post-fix checkpoint ~325 intercepts (WASM) / 314 (native replica) at tick 2102, fuel max ~118M/300M. The residual gap to the pre-#133 522 is the measurement-only velocity contract cost (#133), kept deliberately: class and speed come from measurements, never the target's own figures."
}
@@ -0,0 +1,258 @@
# Issue #147, шаг 3.1: CPU-профиль боевого кадра — кто виноват (#126 D/E)
> Основа: engine `3428a571b` + instrumentation-коммит `d073783f5` (ветка
> `agent/126-cpu-profile`), AirDef `c08b73729` + `92c058f60`. Замер — только
> инструментация: правила симуляции, частоты, лимиты и точность не менялись.
> Worker НЕ реализован (это шаг 3.2, вне scope): задача — измерить и назвать
> виновника по данным, затем рекомендовать первого worker'а.
## Что инструментировано
### Хост: спаны `tick_mods` (engine, `HORIZON_MOD_CPU_PROFILE=1`)
`crates/horizon-client/src/game/mods.rs`: один record на игровой тик, в порядке
исполнения на потоке кадра:
| span | что меряется |
|---|---|
| `ground` | ответы `mod_ground(x,z)` → `answer_ground` (цикл ground-запросов) |
| `world` | `answer_mod_world()` — rays/sections + упаковка (`mod_world.rs`) |
| `snapshot` | `mod_snapshot()` + `set_snapshot` + resolver/acoustics setup |
| `wasm` | `mods.tick(self.ticks)` — wall-time всего WASM-тика (включая `Sim::step`) |
| `models` | `refresh_mod_trees` + `update_mod_models` (подготовка моделей) |
| `output` | `show_mod_output` |
| `total` | весь `tick_mods` (включая `sync_mod_sources`) |
Каждый record несёт `tick` (номер игрового тика) и `frame` — индекс кадра в
сырых массивах `FrameStats` (`frame_ms`/`cpu_ms`/`gpu_ms`), чтобы спаны
соединялись с trace кадров. Гейтинг как у fuel-профиля (выключено по умолчанию,
`OnceLock` по env); запись ограничена `1<<16` тиков (~54 мин). `stats` отдаёт
`mod_cpu` (перцентили по span'ам), `stats raw` — `mod_cpu_ticks` (сырые records);
`stats reset`/`bench` очищают. Overhead выключенного профиля — несколько чтений
часов на тик (как у существующего frame-timing).
### Гость: фазы `Sim::step` (мод, `sim::profile`)
`airdef-mod/src/sim/profile.rs` + `Sim::step`: named-фазы `plan` (plan_step/A*),
`adapt`, `drones` (step_drones), `moves` (step_moves), `sight` (update_sight/радар),
`sams` (step_sams/пуск), `record`, плюс весь `step` и `other` (step минус named).
Счётчики фиксированного размера, per-thread, не читают randomness и не меняют
решений → упорядоченный combat trace идентичен.
Симуляция остаётся SDK-независимой (она же собирается как `airdef-core`):
адаптер ставит хостовые часы `game.monotonic-nanos` (новый WIT-import, API level
32) в `init`; нативные тесты используют `std::time::Instant`. `/airdef stats`
выводит фазы как `PROFILE key=value` chat-строки (мс, totals и per-step maxima),
сброс при открытии нового мира.
### Harness-фиксы control-сокета (не симуляция)
Чтобы замерять бой на пути по умолчанию (server-thread), control-сокет должен
вести себя как чат-бокс игрока. Два минимальных фикса `game/control.rs` (правила
сима, частоты, лимиты и combat-решения не тронуты; in-frame путь не изменился):
- `chat`: в remote-режиме шёл напрямую `send_chat` на сервер, минуя перехват
клиент-мод-команд (`handle_chat_input` → `mod_command`). Теперь как в чат-боксе:
клиент-мод-команда перехватывается первой, иначе строка уходит на сервер.
Без этого `/airdef deploy|wave|stats` не доходили до клиентского мода в
server-thread (первый прогон: отпечатки null, fuel тика 395K против 12.7M
in-frame — бой не состоялся).
- `chat-log`: в remote-режиме читал сырой буфер соединения `remote_chat`, где нет
строк клиентского мода (они идут в `ui.chat` через `add_mod_chat_line`; серверные
строки зеркалируются в `ui.chat` через `chat_line`). Теперь читает `ui.chat` —
чат, который видит игрок, включая feedback мода. `status.chat` (`remote_chat`)
не тронут.
### Драйвер: `tools/raid_bench.py`
- `--scheduler in-frame|server-thread` — два пути single-player, замеряются
РАЗДЕЛЬНО (требование issue). `in-frame`: окно само тикает мир;
`server-thread` (путь по умолчанию): интегрированный сервер на своём потоке,
окно — клиент (`tick_remote` → `tick_mods` синхронно перед prep кадра).
- `HORIZON_MOD_CPU_PROFILE=1` в env прогона.
- `mod_cpu_ticks` соединяются с trace кадров (`mod_cpu_frames`): per-frame total
мод-пути, его p50/p95/p99/max, счётчики кадров >25/33 мс, и что несут худшие 1%
CPU-кадров (avg mod total/wasm/world/models, сколько из них с мод-тиком) —
совпадают ли пики мод-пути с пиками кадров.
- Мод-фазы читаются на idle_warm и после боя; `mod_phases_battle_delta` =
cumulative-после-боя минус cumulative-idle (изолирует бой).
## Стенд и методика
- Apple M5 (10 ядер), macOS, Metal 4. 5600X/RTX 3060 — pending (как #126/#147).
- 2560×1440 offscreen (окно 1280×720 @2x), HD (`/airdef shader hd`),
`HORIZON_HD_SCALE=1`, `HORIZON_NO_AUDIO=1`, `HORIZON_SPIKES=0`,
`HORIZON_MOD_FUEL_PROFILE=1`, `HORIZON_MOD_CPU_PROFILE=1`.
- Мир `Polygon` (копия `run-home/saves/Polygon`), свежий `HORIZON_HOME` на прогон.
Камера `tp @s 40 76 40 135 25`, `time set 6000`, время/погода заморожены,
`weather clear`, creative, HUD скрыт — сцена #126/#147.
- Бой по фиксированным тикам (`BATTLE_SCHEDULE`: 14 батарей, волны shahed 40/160,
kh101 16/180, mix 24/140 — перекрывающиеся налёты + взрывы + плотный дым),
окно замера battle 10 с в середине боя (в потоке). Отпечаток — `airdef stats`
на тиках 400/800/1200/1400.
- Fuel — отдельный сигнал (не включает хост/GPU работу): `mod_fuel` по callback.
- **Сериализация замера**: каждый запуск клиента обёрнут в эксклюзивный
`flock -x` на общем `/tmp/airdef-bench.lock` (другой агент использует тот же
lock): `( flock -x 200; python3 tools/raid_bench.py … ) 200>/tmp/airdef-bench.lock`.
Только один клиент в системе за раз; перед стартом внутри lock ожидается
очистка `pgrep 'horizon-client --world'`. Ранние прогоны, шедшие конкурентно с
клиентом другого агента, признаны невалидными и отброшены; ниже — чистые
замеры под lock. `flock` доставлен через `brew install flock` (0.4.0).
```sh
python3 tools/raid_bench.py --scheduler server-thread --label m5-server --out run-home-bench/out/147-cpu-server
python3 tools/raid_bench.py --scheduler in-frame --label m5-inframe --out run-home-bench/out/147-cpu-inframe
```
## Результаты (M5/Metal, 2560×1440 HD, чистые замеры под flock)
Два раздельных прогона, каждый под эксклюзивным lock: `report-server.json`
(server-thread, путь по умолчанию) и `report-inframe.json` (`--in-frame`,
контроль). Бои реальные: server fp400 — 14 ПВО, 40 сбитых; in-frame fp400 —
14 ПВО, 37 дронов в воздухе, 20 сбитых. **Бои двух планировщиков расходятся по
таймингу событий** (стриминг/акустика; методика #147) — отпечатки разные,
поэтому totals фаз между ними не сравнимы как «один бой»; сравним вклад
мод-пути в пики кадров каждого планировщика.
### Боевой кадр: frame / CPU / GPU (окно battle 10 с)
| метрика, мс | server-thread | in-frame |
|---|---|---|
| кадров в окне | 128 | 103 |
| frame avg / p50 | 78.9 / 73.3 | 97.7 / 70.5 |
| frame p95 / p99 / max | 88.4 / 94.9 / 880.4 | 171.9 / 182.6 / 742.8 |
| **CPU** avg / p50 | 36.4 / 29.5 | 94.3 / 71.4 |
| **CPU p95 / p99** / max | **38.8 / 46.7** / 872.3 | **167.9 / 175.4** / 734.9 |
| **GPU** avg / p95 / p99 | 73.7 / 89.1 / 92.5 | 53.2 / 69.5 / 78.6 |
| кадров >25 мс | 128/128 | 103/103 |
| кадров >33 мс | 127/128 | 103/103 |
| фазы avg: render / tick / update / prepare | 27.0 / 5.95 / 0.3 / 3.1 | 38.2 / 37.4 / 11.6 / 7.1 |
| худший 1% CPU-кадр: render / tick | 449 / 6.8 | 351 / 79.6 |
- **server-thread: кадр GPU-bound.** GPU avg 73.7 мс ≈ frame p95 88 мс; CPU p99
всего 46.7 мс. Почти все кадры >33 мс из-за HD освещения/дыма на 1440p (~74–90 мс
GPU), не из-за CPU мода.
- **in-frame: кадр CPU-bound.** CPU avg 94.3 ≈ frame avg 97.7; GPU avg 53.2 меньше.
Tick-фаза 37.4 мс avg — это Minecraft-сим (мобы/блоки) на потоке кадра + мод;
render-encode 38.2 мс, update 11.6 мс.
- Одиночный catch-up спайк в обоих (server 872 / in-frame 735 мс) —
**render-доминированный** (render-фаза 449 / 351 мс), не мод.
### Мод-путь: спаны `tick_mods` на тик (окно battle, engine `mod_cpu`)
| span, мс | server avg / p95 / p99 / max | in-frame avg / p95 / p99 / max |
|---|---|---|
| ground (ответы земли) | 0.032 / 0.122 / 0.257 / 0.285 | 0.116 / 0.268 / 2.001 / 3.123 |
| world (rays/sections+упаковка) | 0.028 / 0.087 / 0.127 / 0.134 | 0.929 / 4.036 / 6.302 / 6.714 |
| snapshot | 0.031 / 0.042 / 0.052 / 0.072 | 0.114 / 0.107 / 4.070 / 4.222 |
| **wasm (весь WASM-тик)** | 2.322 / 3.200 / 3.491 / 3.630 | 7.930 / 16.869 / 21.422 / 30.226 |
| models (подготовка моделей) | 0.055 / 0.078 / 0.089 / 0.108 | 0.120 / 0.145 / 1.946 / 3.285 |
| output | 0.050 / 0.105 / 0.140 / 0.145 | 0.118 / 0.165 / 2.820 / 3.200 |
| **total мод-путь** | 2.537 / 3.484 / 3.802 / 4.096 | 9.378 / 19.686 / 25.480 / 34.463 |
| тиков в окне | 194 | 156 |
Host world answers (ground+world) и model prep — **ничтожны** на пути по
умолчанию (<0.1 мс/тик); in-frame world заметнее (avg 0.93, p99 6.3 мс), но всё
равно мал против wasm. Мод-путь почти целиком — wasm (`Sim::step` + презентация).
### Совпадение пиков мод-пути с пиками кадров (`mod_cpu_frames`)
| метрика | server-thread | in-frame |
|---|---|---|
| мод-total на кадр p50 / p95 / p99 / max, мс | 3.29 / 6.40 / 7.68 / 14.9 | 10.0 / 33.96 / 38.56 / 38.6 |
| кадров с мод-путём >25 мс | **0** | **27** |
| кадров с мод-путём >33 мс | **0** | **7** |
| худший CPU-кадр: cpu / мод-total / wasm / world, мс | 872 / 2.15 / 2.0 / 0.003 | 735 / 34.5 / 30.2 / 4.0 |
- **server-thread: мод-путь НИКОГДА не превышает 25 мс на кадр** (p99 7.7 мс).
Пик CPU-кадра (872 мс) несёт лишь 2.15 мс мода — спайк не модовый.
- **in-frame: мод-путь >25 мс в 27 кадрах, >33 мс в 7.** Мод — реальный вклад в
CPU-пики, но пик кадра (735 мс) всё равно render-доминированный (мод 34.5 мс).
- **Пики мод-пути двух планировщиков НЕ совпадают**: на пути по умолчанию мод
не создаёт пиков вовсе; in-frame создаёт (бой плотнее + поток кадра уже загружен
симом, wall-time растягивается). Совпадает только природа одиночного
catch-up спайка (render/GPU hitch) и всеобщность >33 мс кадров (HD на 1440p).
### `Sim::step` изнутри: фазы (мод `PROFILE`, delta за весь бой)
Totals за бой (idle→конец), мс; max — худший тик боя. Бои расходятся, поэтому
доли — характеристика каждого планировщика, не сравнение одного боя.
| фаза | server total / max / доля | in-frame total / max / доля |
|---|---|---|
| **drones (step_drones)** | 308.9 / 1.71 / 30% | **1418.8 / 47.05 / 52%** |
| **plan (plan_step, A*)** | **346.5 / 1.40 / 34%** | 397.7 / 31.83 / 15% |
| sight (update_sight, радар) | 173.3 / 1.00 / 17% | 412.0 / 26.81 / 15% |
| other (нетименованное) | 87.3 / 0.53 / 9% | 196.3 / 4.50 / 7% |
| record | 46.5 / 0.22 / 5% | 156.7 / 10.49 / 6% |
| sams (пуск) | 50.0 / 0.26 / 5% | 120.1 / 5.52 / 4% |
| moves | 3.0 / 0.02 / <1% | 12.1 / 3.67 / <1% |
| adapt | 1.4 / 0.06 / <1% | 2.4 / 0.10 / <1% |
| **step всего** | 1016.8 / 2.52 (1250 тиков) | 2716.1 / 47.18 (2091 тик) |
- **server-thread: A* plan_step — крупнейшая фаза** (34%), но весь `Sim::step`
~0.81 мс/тик (max 2.52) — мод мал.
- **in-frame: step_drones доминирует** (52%, max 47 мс/тик — плотный налёт),
A* лишь третий (15%). Host world answers и model prep не лидируют нигде.
### Fuel (отдельный сигнал, без хост/GPU работы)
`airdef:tick` max_used: server 11.15M, in-frame 20.69M при бюджете 300M,
failures 0. Fuel подтверждает: in-frame бой тяжелее по гостевой работе (больше
дронов/тиков), но это не хостовые world answers и не GPU.
## Виновник и рекомендация первого worker'а (шаг 3.2)
**Виновник пиков боевого кадра на пути по умолчанию (server-thread) — GPU.**
GPU avg 73.7 мс ≈ frame p95 88 мс; 127/128 кадров >33 мс из-за HD
освещения/дыма на 1440p. CPU мода — ~2.5 мс/тик, на кадр p99 7.7 мс, **0 кадров
>25 мс**; host world answers <0.1 мс, model prep ~0.05 мс. Одиночный CPU-спайк
(872 мс) — render/GPU hitch (449 мс render-фаза), мод в нём 2.15 мс.
**Рекомендация по данным (worker НЕ реализован):**
1. **Путь по умолчанию (server-thread): CPU-worker не поможет пикам кадров.**
Мод-путь уже ничтожен и вынесен с симом на серверный поток; пики — GPU.
Применяются **шаги 1–2 таблицы #147 (GPU/геометрия)**: HD дым/освещение,
instancing остальных групп моделей. Route-worker / world-worker здесь не
оправданы данными.
2. **Чистый A* route-worker НЕ оправдан.** A* лидирует лишь в крошечном моде
server-thread (34% от 2.5 мс/тик, на пики кадров не влияет); in-frame A* —
только 15% `Sim::step` (третий после step_drones 52% и sight 15%). Снятие A*
не адресует ни GPU-пики дефолта, ни крупнейшую фазу in-frame.
3. **Batch read-only chunk-snapshot world-worker НЕ оправдан.** Host world
answers не лидируют нигде: <0.1 мс/тик дефолт, avg 0.93 / p99 6.3 мс in-frame
— мало против wasm и GPU.
4. **Если целиться в CPU in-frame-пути — единица offload'а весь `Sim::step`
(Wasmtime на своём потоке), а не A*.** In-frame кадр CPU-bound, мод-путь
>25 мс в 27 кадрах, доминирует step_drones (52%, max 47 мс/тик), тесно
связанный с мутабельным состоянием сима и host world answers — это аргумент
за whole-sim offload (следующий шаг таблицы), **но не за pure route-worker**.
При этом и in-frame пики кадров (p99 175 мс) шире мод-пути (38 мс): Minecraft
сим + render-encode тоже велики, а худший спайк — render. Реалистичное
ожидание от whole-sim worker'а — снятие мод-вклада (~38 мс p99), не устранение
>33 мс кадров (их держит GPU/сим/encode).
**Итог:** данные не поддерживают ни pure A* route-worker, ни world-snapshot
worker как первый шаг. На дефолтном пути виновник — GPU (шаги 1–2); на
in-frame контроле CPU-вклад мода реален, но доминирует step_drones, и
оправданный (если делать) следующий шаг — Wasmtime на отдельном потоке целиком,
не route-worker. Реализация worker'а — вне scope 3.1, не делалась.
## Тесты
- `airdef-core` cargo test: 326 passed, 0 failed (8 ignored); timing-тест
`a_smart_raid_plans_and_flies_in_time` (<200 мс/тик) падает только под
параллельной компиляцией (491 мс тик при загрузке CPU), в изоляции — ok.
- `airdef-mod` cargo test: 113+1+2+5 passed, 0 failed, включая
`same_seed_same_result` и `adapter_reexports_core_and_combat_trace_is_deterministic`.
- `tools/test_raid_bench.py`: 11 passed (7 существующих + 4 новых helper'а).
- `horizon-mods` cargo test: 26 lib + sandbox/api_reference ok (exit 0);
api_reference/api_level: ok; WIT-import аддитивен (старые моды линкуются).
- wasm ABI-тест мода `python3 tools/airdef.py test-wasm`: `wasm_contract.toml`
ok (30 шагов, реальный хост, fuel-лимиты) — `game.monotonic-nanos` работает
end-to-end, failures 0.
- Harness-фикс `chat`/`chat-log` (control.rs) — только control-сокет; sim-тесты
его не касаются (нативные тесты не используют бинарник игры). Determinism
(`same_seed_same_result`, `combat_trace_is_deterministic`) перепроверен после
фикса — ok. Инструментация observation-only: combat trace идентичен.
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,228 @@
# Issue #147, шаг 1: GPU-instancing одной массовой группы моделей мода — замеры
> Основа: engine `3428a571b` (instancing #147 поверх `8e711f969` — decode motion
> buffer по history grid #143 и порядок DLSS-кадра #137), AirDef `32748b116`
> (#145/#149). Замеры ниже сняты на этой основе; контракт motion buffer #143
> (current-to-previous в jittered render pixels) instanced-путь наследует без
> изменений — decode исправлен на стороне TAA/TAAU и применяется к обоим путям.
После retained-геометрии #126 (`a861c1ed2`) кадр всё ещё собирал и загружал вершины
каждой модели каждый кадр (~3,1 МБ vertex + ~4,0 МБ motion на кадр в замере #126).
Этот этап убирает поток повторных вершин для **одной массовой группы** одинаковых
моделей: меш группы резолвится против атласа и загружается на GPU один раз на
generation пака, кадр пишет только instance records (current/previous pose, ID, свет),
и один и тот же instance stream рисует main, motion и тени. Остальные модели и весь
кадр при выключенном instancing идут прежним покадровым путём — fallback до паритета
(вершины бит-в-бит, тест `retained_emit_matches_the_per_frame_bake` #126 не менялся).
## Что изменилось (engine)
- `crates/horizon-client/src/model_instance.rs` — `ModelMeshVertex` (40 Б: model-space
pos/normal, atlas UV, material, emission) и `ModelInstance` (80 Б: current/previous
pose+quat, light, id, flags), минимум группы 8 моделей.
- `entity.wgsl` — `vs_model_instance` / `vs_model_instance_motion`: тот же трансформ
(quat о центре единичного куба), квантование нормалей trunc×127 как CPU `as i8`,
упаковка light/emission/glow как `emit_mod_mesh`; motion через previous pose того же
record. Неподвижная модель несёт идентичные pose → нулевая object velocity (#143).
- `gfx.rs` — retained GPU-меши по состояниям (`upload_model_mesh`/`forget_model_meshes`),
instance buffer, 4 пайплайна (HD gbuffer, HD motion, HD тени, classic/main+mod-камеры)
с общим слотом меша и слотом записей; draws во всех пассах, где рисуется entity stream,
включая камеры мода и каскады теней (модели за main camera рисуются там же).
- `game/mod_models.rs` — выбор группы (больше всего моделей одного state, тай-брейк по
меньшему state id), подготовка pose/light на модель (не на вершину), instance records
для группы, прежний CPU-путь для остальных; счётчики `instanced_models/instanced_quads/
instance_bytes/gpu_mesh_builds`; инвалидация GPU-мешей на reload/unload вместе с #126.
- Fallback: `HORIZON_MODEL_INSTANCING=0` (стартовое значение) или runtime-toggle
`model-instancing off|on` (control-команда, диагностика), группа < 8, shader pack
рисует entities, нет renderer — весь кадр прежним путём. История drawn pose общая
для обоих путей, поэтому переключение не размазывает motion.
- Драйвер-поддержка: `stats raw` (сырые frame/cpu/gpu времена), `HORIZON_MOD_FUEL_PROFILE=1`
→ `stats` отдаёт `mod_fuel` (calls/max_used/budget/failures по callback) и `mod_cost_ms`.
## Стенд
- Apple M5 (10 ядер), macOS, Metal. **Ryzen 5600X / RTX 3060 не профилировались** —
приёмка на целевом железе pending (как в #126).
- 2560×1440 offscreen (окно 1280×720 @2x), HD (`/airdef shader hd`), `HORIZON_HD_SCALE=1`,
in-frame, `HORIZON_NO_AUDIO=1`, `HORIZON_SPIKES=0`, `HORIZON_MOD_FUEL_PROFILE=1`.
- Мир `Polygon` (копия `run-home/saves/Polygon`), свежий `HORIZON_HOME` на прогон.
Камера `tp @s 40 76 40 135 25`, `time set 6000`, `advance_time/advance_weather false`,
`weather clear`, creative, HUD скрыт — сцена замера #126.
- Один и тот же `airdef.hmod` во всех окнах (собран один раз, не пересобирался).
- A/B — один бинарник, один процесс, одна запись боя: `model-instancing off`
(fallback, вершины бит-в-бит равны до-правочному пути) против `on` (instancing),
toggle переключается между окнами без перезапуска.
## Драйвер (шаг 0): `tools/raid_bench.py`
Воспроизводимый драйвер вместо scratch-скрипта #126. Один бой по фиксированным тикам
(расписание в `BATTLE_SCHEDULE`: 14 батарей, волны shahed 40/160, kh101 16/180,
mix 24/140), отпечаток боя — строки `airdef stats` на контрольных тиках; затем прогон
**той же записи** (`airdef replay full`): призраки летят по записанным трекам.
**Оба пути замеряются на одной записи в одном процессе.** Драйвер переключает
`model-instancing off|on` (диагностический toggle движка, #147) и проигрывает запись
заново каждым путём: окна `replay_before`/`replay_after` и вторая пара в обратном
порядке (проверка прогрева/очередей). Межпроцессные бои расходятся по таймингу
событий (стриминг/акустика): первый вариант драйвера (A/B двумя прогонами) дал
16 против 32 сбитых на одном контрольном тике и разные записи — такое сравнение
не изолирует рендер, поэтому оставлен только как кросс-проверка (`--compare` двух
отчётов честно показывает несовпадение отпечатков).
Окна: idle_cold 4 с (сразу после загрузки), idle_warm 6 с (после 500 тиков
сходимости LOD), battle 10 с (середина боя, в потоке, чтобы расписание тиков не
плыло), replay 12 с на путь. Проверки: reload (F3+T), seek (стрелки ±5 с в replay),
камера в сторону от боя (тени/чужая камера), статичные кадры off/on после reload
для пиксельного паритета (`--stills`, методика hd_bench: движущиеся пиксели
маскируются по размаху между кадрами одного пути). Отчёт `report.json`: gitlink'и,
устройство, счётчики `mod_models`, CPU/GPU p50/p95/p99/max, сырые frame time,
кадры >25/33 мс, fuel гостей (`HORIZON_MOD_FUEL_PROFILE=1`), очереди стриминга.
Дальности волн — в пределах резидентного террейна (render distance 12 = 192 блока):
на дальностях #126 (700–1400) дроны ждут ответа земли на краю неизвестных чанков
(`sim/terrain.rs`, #61) и бой не состоится — первый прогон драйвера это показал
(8 дронов висят на краю, 0 пусков, запись без событий). В пределах резидентного
террейна бой идёт по тикам детерминированно.
```sh
python3 tools/raid_bench.py --label m5 --out run-home-bench/out/147-m5
python3 tools/raid_bench.py --compare run-home-bench/out/147-m5/report.json
python3 tools/raid_bench.py --stills run-home-bench/out/147-m5
```
## Результаты (M5/Metal, 2560×1440, один процесс, одна запись; основа #137/#143)
Прогон: `report.json` рядом с этим README (сырые frame time включены; рабочий каталог
прогона — `run-home-bench/out/147-m5`, gitignore). Чистый паритет — `static-parity.json`
(прогон `run-home-bench/out/147-static`). Отчёт снят на дереве `8835e5f04` (engine
`3428a571b`); последующие amend'ы коммита меняли только docs/JSON, код драйвера,
мода и движка идентичны финальному коммиту.
Бой на новой основе (#145/#149): 14 батарей, волны на тиках 60/140/220; отпечаток —
43 сбитых к тику 800, 76 к тику 1200, ракеты в воздухе; конец боя тик 1594. Группа
instancing — самая массовая state летящих моделей (~24 одинаковых дроона/кадр из
~113 моделей записи); крупные модели батарей (штучные) остаются на CPU-пути.
### Replay, одна запись, пары off→on (порядок пар чередуется)
| Метрика | before (off) | after (on) | B/A |
|---|---|---|---|
| моделей/кадр | 112.7 | 113.3 | 1.005 |
| instanced/кадр | 0 | 24.6 | — |
| vertex байт/кадр | 1 919 038 | 1 864 573 | 0.972 |
| motion байт/кадр | 2 442 411 | 2 373 093 | 0.972 |
| instance байт/кадр | 0 | 1 969 | — |
| CPU avg, мс | 27.2 | 26.1 | 0.961 |
| CPU p50 / p95 / p99, мс | 26.7 / 41.6 / 46.9 | 24.6 / 44.7 / 50.3 | 0.92 / 1.07 / 1.07 |
| фаза prepare avg, мс | 1.89 | 1.73 | 0.92 |
| фаза render avg, мс | 15.22 | 14.49 | 0.95 |
| frame p95 / p99, мс | 141.7 / 153.5 | 135.2 / 253.6 | 0.95 / 1.65 |
| GPU p95 / p99, мс | 143.8 / 175.7 | 127.3 / 154.6 | 0.89 / 0.88 |
Вторая пара (on→off→on→off): vertex/motion ×0.967, instance 1 909 Б/кадр,
CPU avg 23.1→24.9 (×1.08), p95 ×1.03, p99 ×1.10; prepare 1.72→1.69, render
14.08→14.05; frame/GPU p95 ×1.13/1.24. Кадров в окнах 122–143, моделей/кадр
112.4–113.7 — одна и та же запись.
**Байты — устойчивый выигрыш**: группа ~24 моделей × ~2.3 КБ vertex + ~2.9 КБ motion
≈ 123 КБ/кадр заменены на ~1.9 КБ записей (~65× для группы); суммарный upload кадра
−2.8…3.3% в обеих парах, потому что группа — мелкие летящие модели (24 из 113),
а крупные батарейные остаются на CPU-пути (следующие этапы #147).
**CPU prepare/render — мал, но в ту же сторону в обеих парах** (prepare −8%/−2%,
render −5%/−0.2%). Перцентили CPU/frame в окнах гуляют ±10% между парами: их
доминируют не-рендерные фазы (tick/update/стриминг) и дрейф сессии (окна идут
подряд, первые несут остаточную нагрузку после боя; в до-ребейзном прогоне первая
пара давала CPU p99 ×0.61, вторая ×0.95 — тот же порядок-эффект). На M5 в этой
сцене кадр GPU-bound (~95 мс HD освещение/дым на 1440p), почти все кадры >33 мс;
хвост frame p99 в первой паре хуже (253 мс — одиночный GPU-спайк), во второй
×1.08. Устойчивого улучшения худших кадров на M5 instancing одной группы не даёт —
критерий #147 по худшим кадрам требует GPU-работы (шаги 2–3) и/или CPU-bound
железа (5600X/3060, pending), где снятие prepare должно быть виднее.
### Бой (live, instancing on) и idle
- battle: 131 модель/кадр, 27.5 instanced, vertex 2.08 МБ/кадр, motion 2.64 МБ/кадр,
instance 2.2 КБ/кадр; CPU p95 118 / p99 130 мс (max 1023 — catch-up спайк),
frame p99 131 мс; фазы: render 32.7, update 22.5, tick 15.6 мс.
- idle_cold: CPU p95 22.2 / p99 41.3 мс; idle_warm: p95 16.2 / p99 16.9 мс (моделей нет).
- reload_warm (после F3+T, instancing on): 48 моделей/кадр, 12 instanced,
CPU p95 20.1 / p99 21.9 мс, frame p99 26.8 мс.
### Проверки
- **Reload (F3+T)**: `atlas_scans` 0→1, `mesh_builds` 0→17, `gpu_mesh_builds` 0→1 —
GPU-меши пересозданы против нового атласа, модели рисуются (74 720 за окно после).
- **Seek (стрелки ±5 с в replay)**: модели рисуются до и после (22 863 → 24 771,
instanced 808 → 1 073); переключение пути не размазывает motion (общая история
drawn pose).
- **Камера в сторону от боя**: 27 085 моделей / 1 516 instanced подготовлены, пока
main camera смотрит в другую сторону — тени и чужая камера их рисуют; сам
`replay full` снимает через камеру мода.
- **Fuel гостей** (`HORIZON_MOD_FUEL_PROFILE=1`): tick max_used 12.73M при бюджете
300M, frame 1 927/10M, command 551 395/1G, failures 0.
- **Стриминг/очереди**: после settle `pending_chunks` 0.
### Пиксельный паритет fallback ↔ instancing
Чистый прогон `--static-parity` (`static-parity.json`, рабочий каталог
`run-home-bench/out/147-static`): батареи, без боя,
`HORIZON_HD_TAA=0 HORIZON_HD_WIND=0 HORIZON_HD_CLOUDS=0 HORIZON_HD_VOLFOG=0`
(методика #126), settle 2×500 тиков, `pauseOnLostFocus:false`, по 3 кадра на путь:
- **off ↔ on: 0.0005% статичных пикселей с разницей >20/255** (проверено 93.5% кадра,
~2 пикселя из 3.4 млн), mean abs diff 0.717; движущиеся пиксели (вода, 6.5%)
маскируются по размаху.
- Шум пола: off↔off 0.000% (mean 0.686), on↔on 0.000% (mean 3.135) — паритет на
уровне пола; fallback бит-в-бит равен до-правочному
(`retained_emit_matches_the_per_frame_bake`, #126, не менялся).
- На до-ребейзном прогоне паритет был 0.103% (TAA-история после переключения пути
не сошлась); с #143 (decode по history grid) и выключенным TAA в чистом прогоне —
0.0005%.
### Методика: почему одна запись в одном процессе
Первый вариант драйвера (A/B двумя прогонами, `HORIZON_MODEL_INSTANCING=0` против
включённого) дал расходящиеся бои: 16 против 32 сбитых на контрольном тике 400 —
тайминг событий зависит от стриминга/акустики, записи разные, сравнение не изолирует
рендер. Также волны на дальностях #126 (700–1400) не состоялись: дроны висят на краю
неизвестных чанков (0 пусков). Итог: волны в резидентном террейне, бой один,
оба пути на его записи через runtime-toggle, пары чередуются. Кросс-прогонные
отчёты первого варианта лежат в `run-home-bench/out/147-before|after` (не коммитятся).
## Тесты
```sh
cd horizon
cargo test -p horizon-client --features mods --lib --bins model_instance # 2: раскладки буферов
cargo test -p horizon-client --features mods --bin horizon-client mod_models::tests # 6
cargo test -p horizon-client --features mods --lib entity_shader_validates # WGSL (naga)
python3 tools/test_raid_bench.py # 7: драйвер
```
- `retained_emit_matches_the_per_frame_bake` (#126, не менялся) — fallback путь бит-в-бит.
- `instance_group_picks_the_most_models_deterministically` — выбор группы и тай-брейк.
- `gpu_mesh_vertices_match_the_retained_faces` — GPU-меш = те же грани/UV/материалы.
- `instanced_shader_math_matches_the_cpu_bake` — трансформ шейдера против CPU-матрицы
(f32-округление, <1e-5 относительной ошибки) и квантование нормалей (≤1 шага i8).
- `static_instance_keeps_zero_object_velocity` — неподвижная модель: identical poses,
нулевая object velocity (#143), moved model несёт последний drawn pose.
- `model_instance_attributes_follow_their_structs`, `records_are_tightly_packed_for_the_vertex_layout`
— раскладки буферов против struct offset'ов.
- `entity_shader_validates_with_its_overlay_constants` — WGSL валиден (naga).
На основе #137/#143 также прогнаны: `dlss_submission_orders_consumers_after_ngx`
(#137) — ok; `airdef-core` cargo test — 326+8 passed, 0 failed (8 ignored);
`airdef-mod` cargo test — 113+1+2+5 passed, 0 failed (включая saturation #145 и
smart #149); смок-запуск ребейзнутого бинарника с toggle off/on — ok.
## Ограничения и что дальше
- Замеры только на M5/Metal; 5600X/3060 — pending acceptance.
- GPU-трансформ отличается от CPU в последних ulp f32 (порядок округления), поэтому
паритет instanced-пути — визуальный (пиксельный A/B), не бит-в-бит; бит-в-бит паритет
гарантирован fallback-пути.
- HD smoke (направление B) и worker rewrite не тронуты (шаги 2–3 #147 отдельно).
- Координатный контракт motion buffer #143 (jitter native TAAU) не менялся: instanced
motion пишет тот же контракт (jittered prev_view_proj + camera_delta), что и CPU-путь;
decode по history grid из #143 применяется к обоим путям одинаково.
File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More