gitignore the smoke agent's test home

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.gitignore

@@ -6,3 +6,4 @@ __pycache__/
 /out/
 .DS_Store
 run-home-bench/
+run-home-smoke/

airdef-mod/NOTES-terrain-guidance.md

@@ -0,0 +1,5 @@
+Status of terrain-aware flight (not committed):
+- Done: sim/terrain.rs (look-ahead terrain following, dive only down a clear line, interceptor steer/loft/self-destruct, launch predicate), planner relief pricing + spawn above land (raid.rs), SAM launch check + why line (mod.rs, why.rs), Tally.scrubbed, world.probe, harness terrain fixes, 6 new tests in regress.rs. Build has no warnings; cargo test passes (43 + 4).
+- Numbers (6 seeds, sim_run big-smart): hills:70:100:140 crashes 13 -> 3, hills:70:150:120 29 -> 2, default hills 2 -> 2 (all terminal-dive near-target by Kh101/Kalibr).
+- Half-done / known: terminal dive of slow-turning cruise missiles still sometimes hits ground 7-20 blocks short of target; hills:70:150:120 tick max 38 ms / p95 2 ms (planner terrain phase + ground queries) not profiled; not tested in game.
+- Next: tune dive geometry for Kh101/Kalibr, profile the planner's 1024-columns-per-tick height requests, optional in-game check.

airdef-mod/examples/sim_run/harness.rs

@@ -108,6 +108,8 @@ pub struct Report {
     /// The block cache's counters (issue #43) and the drones that struck the land (issue #42).
     pub world: String,
     pub crashes: u32,
+    /// What went wrong for the air defence, as the raid report words it.
+    pub failures: String,
     pub ground_batches: u64,
     pub tick_p50: Duration,
     pub tick_p95: Duration,
@@ -135,14 +137,16 @@ pub fn run(sc: &Scenario) -> Report {
     sim.damage = false; // explosions would change the land the height function describes
     for u in &sc.units {
         let id = sim.id();
-        let mut s = Sam::new(id, u.kind, u.pos, u.heading);
+        // Systems stand on the land, whatever the layout says.
+        let pos = DVec3::new(u.pos.x, f64::from(sc.terrain.height(u.pos.x.floor() as i32, u.pos.z.floor() as i32)), u.pos.z);
+        let mut s = Sam::new(id, u.kind, pos, u.heading);
         if u.empty {
             s.empty = true;
             s.missiles = 0;
         }
         sim.sams.push(s);
     }
-    sim.targets = sc.objects.clone();
+    sim.targets = sc.objects.iter().map(|o| DVec3::new(o.x, f64::from(sc.terrain.height(o.x.floor() as i32, o.z.floor() as i32)), o.z)).collect();
     sim.target_health = vec![100.0; sc.objects.len()];
     if sc.ew {
         sim.set_ew(true);
@@ -163,7 +167,8 @@ pub fn run(sc: &Scenario) -> Report {
             if !ordered[i] && now >= spec.at && !sim.planning() && (i == 0 || ended[i - 1]) {
                 let order = RaidOrder { kinds: spec.kinds.clone(), approach: spec.approach, dist: spec.dist, aim: spec.aim };
                 launched_before[i] = sim.launched;
-                sim.order_raid(&order, &sc.objects, &mut out);
+                let objects = sim.targets.clone();
+                sim.order_raid(&order, &objects, &mut out);
                 ordered[i] = true;
             }
         }
@@ -226,6 +231,7 @@ pub fn run(sc: &Scenario) -> Report {
     r.raids_ordered = ordered.iter().filter(|o| **o).count();
     r.world = ground.world.text();
     r.crashes = sim.crashes;
+    r.failures = sim.tally.text();
     r.raids_ended = ended.iter().filter(|o| **o).count();
     r.all_ended = r.raids_ended == sc.raids.len();
     r.tick_total = times.iter().sum();
@@ -268,7 +274,8 @@ impl Report {
              ground queries: {gq} in {gb} batches\n\
              non-finite positions: {nan}\n\
              stuck trucks: {stuck:?} (busy truck-ticks {busy})\n\
-             crashes into the land: {crashes}; {world}\n",
+             crashes into the land: {crashes}; {world}\n\
+             air-defence failures: {failures}\n",
             name = self.name,
             seed = self.seed,
             units = self.units,
@@ -293,6 +300,7 @@ impl Report {
             busy = self.truck_busy_ticks,
             crashes = self.crashes,
             world = self.world,
+            failures = if self.failures.is_empty() { "none" } else { &self.failures },
         )
     }
     pub fn json(&self) -> String {

airdef-mod/shaders/effects.wgsl

@@ -201,7 +201,9 @@ fn post(uv: vec2<f32>, pixel: vec2<f32>) -> vec4<f32> {
         let t1 = min(span.y, wall);
         if t1 <= t0 { continue; }
         let heat = 1.0 - smoothstep(0.05, 0.55, k);
-        let fade = 1.0 - smoothstep(0.65, 1.0, k);
+        // With the HD renderer's volumetric smoke (params[0].w = 2) only the fireball is drawn here.
+        var fade = 1.0 - smoothstep(0.65, 1.0, k);
+        if frame.params[0].w > 1.5 { fade = 1.0 - smoothstep(0.08, 0.28, k); }
         // Fewer steps for a fireball that is small on screen.
         let on_screen = radius / max(length(centre), 1.0);
         let steps = i32(clamp(on_screen * 40.0, 6.0, 14.0));

airdef-mod/src/lib.rs

@@ -16,6 +16,7 @@ mod monitor;
 mod panel;
 mod radar;
 mod replay;
+mod smoke;
 pub mod sim;
 mod scenario;
 mod wave;
@@ -54,6 +55,7 @@ const ITEMS: [&str; 29] = [
 ];
 
 struct AirDef {
+    smoke: smoke::Smoke,
     sim: Sim,
     ground: Ground,
     dirty: bool,
@@ -331,7 +333,7 @@ impl AirDef {
             add(id, b.at + DVec3::Y * size as f64 * 0.5, (1.0, 0.58, 0.25), size * size * 18.0 * (glow + flash), size * 14.0);
         }
         // Fires burn on for minutes: a flickering, wide glow that dies down with the flames.
-        for f in &self.sim.fires.list {
+        for f in self.sim.fires.list.iter().filter(|f| f.shown) {
             let (fl, sm) = f.level(tick);
             if f.quiet {
                 continue;
@@ -381,7 +383,7 @@ impl AirDef {
     fn shader_params(&self, out: &Out) -> Vec<f32> {
         let mut p = vec![0.0f32; 4];
         p[0] = self.sim.tick as f32;
-        p[3] = if self.hd { 1.0 } else { 0.0 };
+        p[3] = if self.smoke.hd { 2.0 } else if self.hd { 1.0 } else { 0.0 };
         let mut blasts: Vec<&sim::Blast> = self.sim.blasts.iter().rev().take(48).collect();
         // The shader composites the volumes front to back with one shared transmittance, so
         // the nearest to the player goes first. This is exact for volumes that do not
@@ -459,14 +461,20 @@ impl AirDef {
         }
         if self.hd {
             render::set_lights(&self.lights(&out));
+            self.smoke.hd = render::set_smoke(self.sim.tick as f64, &self.smoke.segments(&self.sim));
+        } else {
+            self.smoke.hd = false;
         }
         if !out.models.is_empty() || self.sim.tick % 20 == 0 {
             self.send_models(&out.models);
         }
         if !out.particles.is_empty() {
+            let hd_smoke = self.smoke.hd;
             let spawns: Vec<ParticleSpawn> = out
                 .particles
                 .into_iter()
+                // The long smoke is the renderer's volume then.
+                .filter(|p| !(hd_smoke && matches!(p.kind, "minecraft:campfire_cosy_smoke" | "minecraft:campfire_signal_smoke" | "minecraft:large_smoke")))
                 .take(512)
                 .map(|p| ParticleSpawn {
                     particle: p.kind.to_string(),
@@ -997,6 +1005,7 @@ impl Mod for AirDef {
             grid_ids: Vec::new(),
             wave: wave::WaveConfig::default(),
             replay: None,
+            smoke: Default::default(),
             far: true,
             moving: None,
             hd: false,
@@ -1084,7 +1093,7 @@ impl Mod for AirDef {
         self.ground.answer(render::ground(), now);
         // The blocks themselves (issues #42, #43): what changed, and the sections asked for last tick.
         let changes = render::world_changes();
-        self.ground.world.changed(changes.epoch, changes.overflow, &changes.sections);
+        self.ground.world.changed_rev(changes.epoch, changes.revision, changes.overflow, &changes.sections);
         let sections = render::sections()
             .into_iter()
             .map(|s| sim::world::SectionAnswer {
@@ -1101,15 +1110,39 @@ impl Mod for AirDef {
             })
             .collect();
         self.ground.world.answer(sections, now);
+        // Exact collision shapes of blocks a flight met (#63): the answers to last tick's rays.
+        let replies: Vec<sim::world::RayReply> = render::rays()
+            .into_iter()
+            .map(|r| sim::world::RayReply {
+                id: r.id,
+                clear: matches!(r.verdict, render::Verdict::Clear),
+                hit: matches!(r.verdict, render::Verdict::Hit),
+                fraction: r.fraction,
+                normal: [r.normal.0, r.normal.1, r.normal.2],
+                block: [r.block.0, r.block.1, r.block.2],
+            })
+            .collect();
+        self.ground.world.answer_rays(&replies);
         let mut out = Out::default();
         self.listener = DVec3::new(p.x, p.y + 1.6, p.z);
         self.sim.night = game::get_clock().is_some_and(|c| (13000..23000).contains(&(c.day_time % 24000)));
         self.sim.day_time = game::get_clock().map(|c| c.day_time);
         self.sim.step(&mut self.ground, Some(DVec3::new(p.x, p.y, p.z)), &mut out);
+        self.smoke.update(&self.sim);
         let wanted = self.ground.take_wanted();
         if !wanted.is_empty() {
             render::query_ground(&wanted);
         }
+        let rays: Vec<render::Ray> = self
+            .ground
+            .world
+            .take_rays(now)
+            .into_iter()
+            .map(|(id, a, b)| render::Ray { id, start: (a.x, a.y, a.z), end: (b.x, b.y, b.z), policy: render::Policy::Collision })
+            .collect();
+        if !rays.is_empty() {
+            render::query_rays(&rays);
+        }
         let sections = self.ground.world.take_wanted(now);
         if !sections.is_empty() {
             render::query_sections(render::Policy::Collision, &sections);

airdef-mod/src/sim/ew.rs

@@ -169,22 +169,22 @@ impl Sim {
                 continue;
             }
             // Only those not yet sent at a unit.
-            if self.sams.iter().any(|s| s.pos.distance(d.target) < 6.0) {
+            if self.sams.iter().any(|s| s.pos.distance(d.target - d.err) < 6.0) {
                 continue;
             }
             let to = if !ew.is_empty() { pick(n, &ew) } else { pick(n, &known) };
-            d.target = to;
+            d.target = to + d.err;
             d.route.clear();
             retargeted.push((true, qi));
             n += 1;
         }
         // In flight: a target system destroyed — the next known one, or keep going.
         for (di, d) in self.drones.iter_mut().enumerate().filter(|(_, d)| d.alive() && d.smart) {
-            let aimed_at_wreck = self.sams.iter().any(|s| !s.alive() && s.pos.distance(d.target) < 6.0);
+            let aimed_at_wreck = self.sams.iter().any(|s| !s.alive() && s.pos.distance(d.target - d.err) < 6.0);
             if aimed_at_wreck {
                 let next = known.iter().min_by(|a, b| a.1.distance(d.pos).total_cmp(&b.1.distance(d.pos)));
                 if let Some((_, at)) = next {
-                    d.target = *at;
+                    d.target = *at + d.err;
                     d.route.clear();
                     retargeted.push((false, di));
                 }

airdef-mod/src/sim/fires.rs

@@ -6,8 +6,11 @@
 //! oldest dying down first. A replay draws the same fires from its events (`replay_fire`).
 use super::*;
 
-/// Fires burning at once.
+/// Fires drawn at full strength at once (flames, smoke columns, lights, fire blocks): the strongest `MAX`.
 pub const MAX: usize = 12;
+/// Fires kept at all, burning places the player may come back to: past it the weakest are put out (#69).
+/// The rest of them, beyond `MAX`, only smoulder (a thin smoke, now and then), with no light.
+pub const LIST_MAX: usize = 32;
 /// A fire put out by the water it fell in lasts this long (steam only).
 const STEAM: u32 = 160;
 /// Ticks the oldest fire has left when a newer one pushes it out.
@@ -32,6 +35,8 @@ pub struct Fire {
     blocks: Vec<(i32, i32, i32)>,
     /// The host's wreck is flaming: this fire leaves the flames to it.
     pub quiet: bool,
+    /// Among the `MAX` strongest this tick: the only ones drawn in full and lit (#69).
+    pub shown: bool,
 }
 
 #[derive(Default)]
@@ -117,7 +122,20 @@ impl Sim {
             asked: 0,
             blocks: Vec::new(),
             quiet: false,
+            shown: true,
         });
+        // A hard bound on the places kept (#69): the weakest, soonest out, goes now and its fire blocks with it.
+        while self.fires.list.len() > LIST_MAX {
+            let weakest = (0..self.fires.list.len())
+                .min_by(|&a, &b| {
+                    let (fa, fb) = (&self.fires.list[a], &self.fires.list[b]);
+                    let w = |f: &Fire| f.size as f64 * (f.life as f64 - now.saturating_sub(f.start) as f64).max(0.0);
+                    w(fa).total_cmp(&w(fb)).then(fa.id.cmp(&fb.id))
+                })
+                .unwrap_or(0);
+            let gone = self.fires.list.swap_remove(weakest);
+            self.fires.cleanup.extend(gone.take_blocks());
+        }
         if self.fires.list.len() > MAX {
             // The oldest dies down (and is gone) instead of burning on.
             let old = self.fires.list.iter_mut().filter(|f| now.saturating_sub(f.start) as u32 + FADE < f.life).min_by_key(|f| f.start);
@@ -133,6 +151,19 @@ impl Sim {
         out.commands.append(&mut self.fires.cleanup);
         let damage = self.damage;
         let mut fires = std::mem::take(&mut self.fires.list);
+        // The strongest `MAX` are drawn in full and lit; the rest smoulder (#69).
+        let mut rank: Vec<(f32, u32, usize)> = fires
+            .iter()
+            .enumerate()
+            .map(|(i, f)| {
+                let (fl, sm) = f.level(now);
+                (f.size * (fl + 0.3 * sm), f.id, i)
+            })
+            .collect();
+        rank.sort_by(|a, b| b.0.total_cmp(&a.0).then(a.1.cmp(&b.1)));
+        for (k, &(_, _, i)) in rank.iter().enumerate() {
+            fires[i].shown = k < MAX;
+        }
         for f in &mut fires {
             let age = now.saturating_sub(f.start);
             // Where the land is under it: it burns on the surface, not at the height of what fell.
@@ -159,7 +190,12 @@ impl Sim {
             f.quiet = f.host.is_some_and(|id| self.sams.iter().any(|s| s.id == id && !s.alive() && s.burn > 0));
             let (fl, sm) = f.level(now);
             let s = f.size;
-            if !f.quiet {
+            if !f.quiet && !f.shown {
+                // Beyond the budget: a thin smoke now and then, no flames, no light, no new fire blocks.
+                if sm > 0.04 && now % 24 == (f.id % 24) as u64 {
+                    out.particles("minecraft:large_smoke", f.at + DVec3::Y, 0.4 + 0.3 * f.size, DVec3::new(0.0, 0.1, 0.0), 0.03, 1);
+                }
+            } else if !f.quiet {
                 let top = f.at + DVec3::Y * 0.4;
                 let spread = 0.4 + 0.5 * s;
                 if fl > 0.04 && now % 2 == 0 {
@@ -180,7 +216,7 @@ impl Sim {
                 }
             }
             // Real fire, only where the damage is real: a few blocks on the solid ground.
-            if damage && f.land == Some(true) && fl > 0.3 && now % REFRESH == (f.id as u64) % REFRESH && age >= 20 {
+            if damage && f.shown && f.land == Some(true) && fl > 0.3 && now % REFRESH == (f.id as u64) % REFRESH && age >= 20 {
                 let (x, y, z) = (f.at.x.floor() as i32, f.at.y.floor() as i32, f.at.z.floor() as i32);
                 let n = if s >= 2.5 { 5 } else if s >= 1.5 { 3 } else { 1 };
                 for k in 0..n {

airdef-mod/src/sim/mod.rs

@@ -14,6 +14,7 @@ pub mod fires;
 mod raid;
 pub mod record;
 mod sight;
+mod terrain;
 mod ew;
 mod lights;
 mod logistics;
@@ -218,10 +219,19 @@ pub struct Ground {
     asked: std::collections::HashSet<(i32, i32)>,
     /// 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.
+    now: u64,
     /// The blocks themselves (issues #42, #43): what stops a flight.
     pub world: world::WorldCache,
 }
 
+/// The `when` of a height reported changed: due to be asked again.
+const STALE: u64 = u64::MAX;
+/// Ticks after which a land height used by the flights' look-ahead is asked again (#64), changes told of or not.
+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).
+pub const HOLD_PENDING: u16 = 45;
+pub const HOLD_NO_CHUNK: u16 = 240;
 /// Ticks between full clean-ups of a big ground cache.
 const SWEEP_EVERY: u64 = 200;
 
@@ -234,7 +244,7 @@ impl Ground {
             Some(&(y, when)) => {
                 // Refreshes of known columns take at most a quarter of the questions: the rest
                 // stay free for columns never seen, or those would starve.
-                if now.saturating_sub(when) > 200 && self.wanted.len() < 64 && self.asked.insert(key) {
+                if (when == STALE || now.saturating_sub(when) > 200) && self.wanted.len() < 64 && self.asked.insert(key) {
                     self.wanted.push(key);
                 }
                 (y > -64).then_some(f64::from(y))
@@ -248,14 +258,54 @@ impl Ground {
         }
     }
     pub fn answer(&mut self, answers: Vec<(i32, i32, i32)>, now: u64) {
+        self.now = now;
         for (x, z, y) in answers {
             self.known.insert((x, z), (y, now));
         }
+        self.age_heights();
         if self.known.len() > 300_000 && now.saturating_sub(self.swept) >= SWEEP_EVERY {
             self.swept = now;
             self.known.retain(|_, (_, when)| now.saturating_sub(*when) < 2000);
         }
     }
+    /// 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.
+    fn age_heights(&mut self) {
+        let all = std::mem::take(&mut self.world.changed_all);
+        let cols = std::mem::take(&mut self.world.changed_cols);
+        if !all && cols.is_empty() {
+            return;
+        }
+        if all || cols.len() > 24 {
+            for (&(x, z), v) in self.known.iter_mut() {
+                if all || cols.contains(&(x >> 4, z >> 4)) {
+                    v.1 = STALE;
+                }
+            }
+        } else {
+            for &(sx, sz) in &cols {
+                for x in sx * 16..sx * 16 + 16 {
+                    for z in sz * 16..sz * 16 + 16 {
+                        if let Some(v) = self.known.get_mut(&(x, z)) {
+                            v.1 = STALE;
+                        }
+                    }
+                }
+                // The lattice columns of the flights' look-ahead (see `terrain`).
+                for x in (sx * 16..sx * 16 + 16).step_by(8) {
+                    for z in (sz * 16..sz * 16 + 16).step_by(8) {
+                        if let Some(v) = self.known.get_mut(&(x + 4, z + 4)) {
+                            v.1 = STALE;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /// Whether a known height is due to be asked again: reported old, or too old to trust.
+    fn due(&self, when: u64) -> bool {
+        when == STALE || self.now.saturating_sub(when) > HEIGHT_TTL
+    }
     pub fn take_wanted(&mut self) -> Vec<(i32, i32)> {
         self.asked.clear();
         std::mem::take(&mut self.wanted)
@@ -264,6 +314,48 @@ impl Ground {
     pub fn sweep(&mut self, a: DVec3, b: DVec3, skip_start: bool, now: u64) -> world::Sweep {
         self.world.sweep(a, b, skip_start, now)
     }
+    /// The step of flight `key` from `a` to `b`: the first solid block by the occupancy, then (#63) by the
+    /// block's exact collision shape, which the game answers a tick or two later (see `WorldCache::narrow`).
+    pub fn trace(&mut self, key: u32, a: DVec3, b: DVec3, skip_start: bool, now: u64) -> world::Sweep {
+        let s = self.world.sweep(a, b, skip_start, now);
+        self.world.narrow(key, s, a, b, now)
+    }
+    /// What to do with a step that ended in blocks the game hasn't told of (#61): `Some(t)` cuts the step at `t`
+    /// of the way (it holds there, the section is asked for urgently), `None` lets it go on. Unread is never
+    /// taken for clear: a section not answered yet holds a flight for up to `HOLD_PENDING` ticks, a chunk the
+    /// game doesn't have holds one that is low over the land (or inside it) for `HOLD_NO_CHUNK`; after that, and
+    /// high over the land, it goes on (the game has nothing there to hit) until a step is clear again.
+    pub fn unread(&mut self, sweep: &world::Sweep, hold: &mut u16, low: bool) -> Option<f64> {
+        match *sweep {
+            world::Sweep::Unknown { t, pending } => {
+                let limit = if pending {
+                    HOLD_PENDING
+                } else if low {
+                    HOLD_NO_CHUNK
+                } else {
+                    0
+                };
+                if *hold < limit {
+                    *hold += 1;
+                    self.world.stats.held += 1;
+                    Some((t - 1e-6).max(0.0))
+                } else {
+                    self.world.stats.passed_unknown += 1;
+                    None
+                }
+            }
+            world::Sweep::Clear => {
+                *hold = 0;
+                None
+            }
+            world::Sweep::Hit { .. } => None,
+            // The exact shape is being asked for: the flight holds at the face (a bounded wait, see `narrow`).
+            world::Sweep::Wait { t } => {
+                self.world.stats.held += 1;
+                Some((t - 1e-6).max(0.0))
+            }
+        }
+    }
     /// Has the sections along a flight read before it gets there.
     pub fn ahead(&mut self, pos: DVec3, vel: DVec3, ticks: f64, now: u64) {
         self.world.look_ahead(pos, vel, ticks, now);
@@ -745,6 +837,28 @@ pub struct Drone {
     sector: u8,
     /// Sent by the smart enemy: it may be turned on systems that give themselves away.
     smart: bool,
+    /// What the land ahead asks of its flight (see `terrain`).
+    nav: Nav,
+    /// Its navigation error (#65): `target` is the nominal aim plus this, kept apart so a new aim (a retarget)
+    /// keeps the error this airframe was born with instead of becoming exact.
+    err: DVec3,
+    /// Ticks held at the edge of blocks the game has not told of (#61); reset by a clear step.
+    hold: u16,
+}
+
+/// A drone's terrain following: refreshed every few ticks, used every one.
+#[derive(Clone, Copy, Debug)]
+struct Nav {
+    /// The height it must be at now to clear the land ahead (unknown: -inf).
+    need: f64,
+    /// The height from which a straight dive on its target clears the land (unknown: -inf).
+    dive: f64,
+}
+
+impl Default for Nav {
+    fn default() -> Self {
+        Nav { need: f64::NEG_INFINITY, dive: f64::NEG_INFINITY }
+    }
 }
 
 impl Drone {
@@ -952,6 +1066,50 @@ pub struct Missile {
     /// The system that fired it.
     sam: u32,
     age: u32,
+    /// Ticks held at the edge of blocks the game has not told of (#61).
+    hold: u16,
+    /// What it knows of its target (#66): the last fix, from the firing system's track (the data link)
+    /// or from its own seeker. It steers on this, never on the target's true position.
+    fix: Option<Fix>,
+    /// The tick its seeker last held the target (0: not yet).
+    seen: u64,
+}
+
+/// A missile's knowledge of its target: where it was and how it went when measured, and when.
+#[derive(Clone, Copy, Debug)]
+pub struct Fix {
+    pub pos: DVec3,
+    pub vel: DVec3,
+    pub tick: u64,
+    /// Measured by its own seeker (else by the firing system's radar, passed on by the link).
+    pub seeker: bool,
+}
+
+impl Fix {
+    /// Where the target should be by now, carrying the measurement on.
+    pub fn est(&self, now: u64) -> DVec3 {
+        self.pos + self.vel * now.saturating_sub(self.tick).min(MAX_COAST) as f64
+    }
+}
+
+/// Ticks a fix is carried on by its velocity; a missile with nothing newer than this has lost its target.
+pub const MAX_COAST: u64 = 240;
+/// Ticks the seeker keeps a target it lost sight of (it looks again round the last place).
+const REACQUIRE: u64 = 12;
+
+impl MissileKind {
+    /// How far its own seeker holds a target of average size (blocks); 0: command guidance only.
+    pub fn seeker(self) -> f64 {
+        match self {
+            MissileKind::M57e6 => 0.0,
+            MissileKind::Pac3 => 110.0,
+            MissileKind::M48n6 | MissileKind::M77n6 => 120.0,
+            MissileKind::IrisT | MissileKind::M9m317 => 90.0,
+            MissileKind::Amraam => 130.0,
+            MissileKind::M9m338 => 70.0,
+            MissileKind::P1sun => 60.0,
+        }
+    }
 }
 
 // ---------------------------------------------------------------- air defence
@@ -1073,6 +1231,10 @@ pub struct Sam {
     pub ew_lock: bool,
     /// Ticks till a gun fires its next illumination flare.
     flare_cd: u32,
+    /// Shots the land ruled out, by target: when it was judged and why (`terrain::MASKED`, `terrain::PATH_BLOCKED`).
+    pub(super) terrain: HashMap<u32, (u64, u8)>,
+    /// Targets whose land hasn't been answered yet, and since when it has been waited for.
+    waits: HashMap<u32, u64>,
 }
 
 impl Sam {
@@ -1124,6 +1286,8 @@ impl Sam {
             heat: 0.0,
             ew_lock: false,
             flare_cd: 0,
+            terrain: HashMap::new(),
+            waits: HashMap::new(),
         }
     }
     pub fn alive(&self) -> bool {
@@ -1355,36 +1519,9 @@ impl Sim {
     }
 
     fn add_drone(&mut self, kind: DroneKind, from: DVec3, dir: DVec3, target: DVec3) {
-        let id = self.id();
-        let spec = kind.spec();
-        // Its navigation error: it flies to, and strikes at, a point off the aim it was given.
-        let target = target + self.aim_error(kind);
-        let (vel, flight) = if spec.ballistic.is_some() {
-            // An arc from `from` to `target` at the kind's horizontal speed.
-            let flat = horizontal(target - from);
-            let time = (flat.length() / spec.speed).max(30.0);
-            let up = (target.y - from.y + 0.5 * GRAVITY * time * time) / time;
-            (flat / time + DVec3::Y * up, Flight::Ballistic)
-        } else {
-            (dir.normalize_or(DVec3::NEG_Z) * spec.speed, Flight::Cruise)
-        };
-        self.drones.push(Drone {
-            id,
-            kind,
-            pos: from,
-            vel,
-            target,
-            flight,
-            roll: 0.0,
-            spin: 0.0,
-            age: 0,
-            engaged: 0,
-            route: Vec::new(),
-            low: false,
-            jammed: false,
-            sector: 0,
-            smart: false,
-        });
+        // Its navigation error is drawn in `make_drone`, the one path of manual and raid launches (#65).
+        let d = self.make_drone(kind, from, dir, target);
+        self.drones.push(d);
         self.launched += 1;
     }
 
@@ -1433,7 +1570,7 @@ impl Sim {
     /// One game tick.
     pub fn step(&mut self, ground: &mut Ground, player: Option<DVec3>, out: &mut Out) {
         self.tick += 1;
-        self.plan_step(out);
+        self.plan_step(Some(&mut *ground), out);
         self.adapt();
         self.release_queue();
         self.step_drones(ground, player, out);
@@ -1443,7 +1580,7 @@ impl Sim {
         self.step_ew(out);
         self.update_sight(ground);
         self.step_lights(out);
-        self.step_sams(out);
+        self.step_sams(ground, out);
         self.step_missiles(ground, out);
         self.step_fx(ground, out);
         self.draw_targets(out);
@@ -1473,7 +1610,7 @@ impl Sim {
             let spec = d.kind.spec();
             let below = ground.at(d.pos, now);
             let from = d.pos;
-            ground.ahead(d.pos, d.vel, 20.0, now);
+            ground.ahead(d.pos, d.vel, (120.0 / d.vel.length().max(0.05)).max(20.0), now);
             // Near its aim it looks at the land there again: a platform or hilltop blown away
             // meanwhile, it goes for what is left below, not for the air where it stood.
             if d.flight != Flight::Falling
@@ -1488,9 +1625,11 @@ impl Sim {
                 d.vel *= 0.985;
                 d.spin += 0.35;
                 d.pos += d.vel;
-                let sweep = ground.sweep(from, d.pos, d.age <= 3, now);
+                let sweep = ground.trace(d.id, from, d.pos, d.age <= 3, now);
                 if let Some((_, p)) = sweep.hit() {
                     d.pos = p;
+                } else if let Some(t) = ground.unread(&sweep, &mut d.hold, below.is_some_and(|g| from.y < g + 12.0)) {
+                    d.pos = from.lerp(d.pos, t);
                 }
                 if self.rng.chance(0.5) {
                     out.particles("minecraft:large_smoke", d.pos, 0.2, DVec3::new(0.0, 0.05, 0.0), 0.02, 1);
@@ -1519,9 +1658,11 @@ impl Sim {
                     d.vel = turn(d.vel, d.target - d.pos, spec.turn) * sp;
                 }
                 d.pos += d.vel;
-                let sweep = ground.sweep(from, d.pos, d.age <= 3, now);
+                let sweep = ground.trace(d.id, from, d.pos, d.age <= 3, now);
                 if let Some((_, p)) = sweep.hit() {
                     d.pos = p;
+                } else if let Some(t) = ground.unread(&sweep, &mut d.hold, below.is_some_and(|g| from.y < g + 12.0)) {
+                    d.pos = from.lerp(d.pos, t);
                 }
                 let speed = d.vel.length();
                 let landed = sweep.hit().is_some() || ground.ground_hit(below, d.pos, 0.2, &sweep, now);
@@ -1596,9 +1737,6 @@ impl Sim {
                 }
                 continue;
             }
-            if d.flight == Flight::Cruise && d.route.len() <= 1 && horizontal(d.target - d.pos).length() < spec.dive {
-                d.flight = Flight::Dive;
-            }
             // An interceptor coming: drones drop to the treetops (radars lose them sooner).
             if d.engaged > 0 && matches!(spec.class, Class::Drone | Class::Jet) {
                 d.low = true;
@@ -1614,32 +1752,97 @@ impl Sim {
             {
                 d.route.remove(0);
             }
-            let goal = if d.flight == Flight::Dive {
-                d.target
-            } else {
-                // Cruise height over the target, and `clearance` over the land ahead.
-                let ahead = ground.at(d.pos + horizontal(d.vel).normalize_or_zero() * 20.0, now);
-                let floor = match (below, ahead) {
-                    (Some(a), Some(b)) => a.max(b) + spec.clearance,
-                    (Some(g), None) | (None, Some(g)) => g + spec.clearance,
-                    (None, None) => d.target.y + spec.clearance,
-                };
-                let to = d.route.first().copied().unwrap_or(d.target);
-                // Under the radars: as low as the land lets it, all the way.
-                let height = if d.low { floor.max(d.target.y + 4.0) } else { (d.target.y + spec.cruise).max(floor) };
-                DVec3::new(to.x, height, to.z)
+            let climb = d.kind.climb();
+            // A dive begins far enough out to bring it down onto the target: a missile that turns slowly needs a long
+            // way to lose height it has over the aim.
+            let dive_at = {
+                let r = spec.speed * 1.35 / (spec.turn * 3.5).max(0.01);
+                let drop = (d.pos.y - d.target.y).clamp(0.0, r);
+                spec.dive.max(((2.0 * r * drop - drop * drop).sqrt() * 1.1).min(spec.dive * 2.5))
             };
+            let way = d.route.first().copied().unwrap_or(d.target);
+            let to_target = horizontal(d.target - d.pos).length();
+            // What the land ahead asks: along its heading and towards its next point, several seconds out.
+            if d.age <= 1 || (now + u64::from(d.id)) % 3 == 0 {
+                let heading = horizontal(d.vel).normalize_or_zero();
+                let towards = horizontal(way - d.pos).normalize_or_zero();
+                let look = d.kind.look_len();
+                let mut lines = vec![(heading, look)];
+                let angle = heading.angle_between(towards);
+                if towards != DVec3::ZERO && angle > 0.1 {
+                    let reach = look.min(horizontal(way - d.pos).length() + 30.0);
+                    lines.push((towards, reach));
+                    if angle > 0.4 {
+                        lines.push(((heading + towards).normalize_or_zero(), reach));
+                    }
+                }
+                d.nav.need = terrain::required_height(ground, d.pos, &lines, spec.clearance, &climb).unwrap_or(f64::NEG_INFINITY);
+                d.nav.dive = if to_target < dive_at * 3.0 {
+                    terrain::dive_height(ground, d.pos, d.target, terrain::DIVE_MARGIN).unwrap_or(f64::NEG_INFINITY)
+                } else {
+                    f64::NEG_INFINITY
+                };
+            }
+            // The dive into the target starts when the line down to it is clear of the land, else it comes in higher;
+            // a dive that finds the line blocked pulls out and climbs.
+            if d.flight == Flight::Cruise && d.route.len() <= 1 && to_target < dive_at && d.pos.y >= d.nav.dive - 1.0 && d.vel.y < 0.3 * spec.speed {
+                d.flight = Flight::Dive;
+            } else if d.flight == Flight::Dive && to_target > 40.0 && d.pos.y < d.nav.dive - 4.0 {
+                d.flight = Flight::Cruise;
+            }
             let rate = if d.flight == Flight::Dive { spec.turn * 3.5 } else { spec.turn };
             let old = d.vel.normalize_or(DVec3::NEG_Z);
-            let new = turn(old, goal - d.pos, rate);
+            let probe_len = (spec.speed * 10.0).clamp(50.0, 150.0);
+            let new = if d.flight == Flight::Dive {
+                let mut new = turn(old, d.target - d.pos, rate);
+                // Something solid across the dive, short of the target (a building the heights don't show): up and round.
+                if to_target > 40.0
+                    && d.age > 8
+                    && let world::Sweep::Hit { point, .. } = ground.world.probe(d.pos, d.pos + new * probe_len.min(to_target - 20.0), now)
+                    && point.distance(d.target) > 16.0
+                {
+                    d.flight = Flight::Cruise;
+                    d.nav.need = d.nav.need.max(point.y + spec.clearance);
+                    new = turn(old, horizontal(way - d.pos).normalize_or(horizontal(old)) + DVec3::Y * climb.pitch.tan(), spec.turn);
+                }
+                new
+            } else {
+                let heading = horizontal(way - d.pos).normalize_or(horizontal(old).normalize_or(DVec3::NEG_Z));
+                // Cruise height over the target; as low as the land lets it when under the radars.
+                let base = if d.low { d.target.y + 4.0 } else { d.target.y + spec.cruise };
+                let own = below.map_or(f64::NEG_INFINITY, |g| g + spec.clearance);
+                let need = d.nav.need.max(own);
+                let safe = if need.is_finite() { need + 2.0 } else { d.target.y + spec.clearance };
+                let height = base.max(safe).max(d.nav.dive + 1.0);
+                let full = climb.pitch.tan();
+                let urgent = need.is_finite() && d.pos.y < need;
+                let slope = if urgent {
+                    full
+                } else {
+                    ((height - d.pos.y) / (climb.radius * 1.5).min((to_target * 0.5).max(30.0)).max(30.0)).clamp(-0.35, full)
+                };
+                let mut new = terrain::fly_towards(old, heading, slope, rate, urgent);
+                // Something solid ahead that the heights don't show (trees, a building, an overhang): climb.
+                if d.age > 8
+                    && let world::Sweep::Hit { point, .. } =
+                        ground.world.probe(d.pos - DVec3::Y * 4.0, d.pos - DVec3::Y * 4.0 + new * probe_len, now)
+                {
+                    d.nav.need = d.nav.need.max(point.y + spec.clearance);
+                    new = terrain::fly_towards(old, heading, full, rate, true);
+                }
+                terrain::clamp_pitch(new, -0.6, climb.pitch, heading)
+            };
             let side = old.cross(new).y;
             d.roll += ((side * 40.0).clamp(-0.8, 0.8) - d.roll) * 0.15;
             let speed = if d.flight == Flight::Dive { spec.speed * 1.35 } else { spec.speed };
             d.vel = new * speed;
             d.pos += d.vel;
-            let sweep = ground.sweep(from, d.pos, d.age <= 3, now);
+            let sweep = ground.trace(d.id, from, d.pos, d.age <= 3, now);
             if let Some((_, p)) = sweep.hit() {
                 d.pos = p;
+            } else if let Some(t) = ground.unread(&sweep, &mut d.hold, below.is_some_and(|g| from.y < g + 12.0)) {
+                // Not told of what lies ahead: it doesn't fly into it unseen (a held flight waits, a tick or two).
+                d.pos = from.lerp(d.pos, t);
             }
             let at_target = d.pos.distance(d.target) < speed.max(1.5);
             let in_ground = sweep.hit().is_some() || ground.ground_hit(below, d.pos, 0.2, &sweep, now);
@@ -1733,6 +1936,9 @@ impl Sim {
                 jammed: false,
                 sector,
                 smart: false,
+                nav: Nav::default(),
+                err: DVec3::ZERO,
+                hold: 0,
             });
         }
         for d in &self.drones {
@@ -1884,7 +2090,7 @@ impl Sim {
 
     // ------------------------------------------------ air defence
 
-    fn step_sams(&mut self, out: &mut Out) {
+    fn step_sams(&mut self, ground: &mut Ground, out: &mut Out) {
         if self.hold {
             for i in 0..self.sams.len() {
                 if self.sams[i].alive() && !self.sams[i].moving() {
@@ -1923,6 +2129,11 @@ impl Sim {
                     sam.dish = sam.beam;
                 }
                 sam.jam = sam.jam.saturating_sub(1);
+                if self.tick % 64 == 0 {
+                    let now = self.tick;
+                    sam.terrain.retain(|_, (when, _)| now.saturating_sub(*when) < 4 * terrain::VERDICT_AGE);
+                    sam.waits.retain(|_, since| now.saturating_sub(*since) < 4 * terrain::WAIT_TICKS);
+                }
                 if sam.reloading > 0 {
                     sam.reloading -= 1;
                     if sam.reloading == 0 {
@@ -1950,7 +2161,10 @@ impl Sim {
             let (had_target, had_gun) = (self.sams[i].target, self.sams[i].gun_target);
             let now = self.tick;
             let (target, gun_target) = {
-                let tracks = &self.sams[i].tracks;
+                let me = &self.sams[i];
+                let tracks = &me.tracks;
+                // A shot the land ruled out a moment ago is not tried again at once.
+                let open = |id: u32| me.terrain_verdict(id, now).is_none_or(|b| b == 0);
                 // The conditions are `why`'s, shared with the diagnostic. A system knows its targets by their tracks:
                 // the forecast of the last measurement, never the true place.
                 let drone = |tr: &Track| drone_at.get(&tr.id).map(|&k| &self.drones[k]);
@@ -1958,7 +2172,7 @@ impl Sim {
                 let needed = why::needed;
                 let target = spec.missile.as_ref().map(|load| {
                     let ok = |tr: &Track, k: f64| {
-                        drone(tr).is_some_and(|d| why::allowed(roles, tr, now, d) && why::in_reach(load.min, load.max, k, pos, tr.est(now)))
+                        drone(tr).is_some_and(|d| why::allowed(roles, tr, now, d) && open(tr.id) && why::in_reach(load.min, load.max, k, pos, tr.est(now)))
                     };
                     let keep = had_target.filter(|t| tracks.iter().any(|tr| tr.id == *t && ok(tr, 1.1)));
                     keep.or_else(|| {
@@ -2133,9 +2347,38 @@ impl Sim {
                 // The missile turns after its boost, but the launcher must point near the target.
                 let t = sam.track(mt).filter(|_| drone_at.contains_key(&mt)).map(|tr| tr.est(now));
                 let aligned = why::missile_aligned(spec.family, sam.yaw, mount, t, aim_id, mt, aim_error);
-                if ready && aligned {
-                    let n = load.magazine - sam.missiles;
-                    let (muzzle, dir) = sam.muzzle(n);
+                let n = load.magazine - sam.missiles;
+                let (muzzle, dir) = sam.muzzle(n);
+                // The land: a target behind a hill, or a path the hill closes, is not fired at; the system looks for another.
+                let land = if ready && aligned {
+                    match (sam.terrain_verdict(mt, now), sam.track(mt)) {
+                        (Some(bits), _) => bits,
+                        (None, Some(tr)) => {
+                            let mut bits = terrain::launch_blocks(ground, load.kind, muzzle, sight::antenna(sam), tr.est(now), tr.vel);
+                            if bits == terrain::WAIT {
+                                // The land is being asked for: a moment's wait, not a long one (the game may not answer).
+                                if now.saturating_sub(*sam.waits.entry(mt).or_insert(now)) > terrain::WAIT_TICKS {
+                                    bits = 0;
+                                }
+                            } else {
+                                sam.waits.remove(&mt);
+                                if bits != 0 {
+                                    sam.terrain.insert(mt, (now, bits));
+                                }
+                            }
+                            bits
+                        }
+                        (None, None) => 0,
+                    }
+                } else {
+                    0
+                };
+                if land == terrain::WAIT {
+                    // The land under the shot is not known yet: it waits.
+                } else if land != 0 {
+                    retarget(&mut missile_on, Some(mt), None);
+                    sam.target = None;
+                } else if ready && aligned {
                     launches.push((load.kind, muzzle, dir, mt, sam.id));
                     // Its missile is on it from now, so the systems after this one this tick see
                     // the target taken; this one's next launch looks for another.
@@ -2168,10 +2411,17 @@ impl Sim {
             if let Some(s) = self.sams.iter().find(|s| s.id == sam) {
                 self.intel.revealed.push((sam, s.pos, self.tick));
             }
+            // It leaves with the track the system fired on (#66).
+            let fix = self
+                .sams
+                .iter()
+                .find(|s| s.id == sam)
+                .and_then(|s| s.track(target))
+                .map(|tr| Fix { pos: tr.pos, vel: tr.vel, tick: tr.tick, seeker: false });
             let spec = kind.spec();
             let id = self.id();
             let v0 = if spec.cold > 0 { 0.7 } else { 0.8 };
-            self.missiles.push(Missile { id, kind, pos: muzzle, vel: dir * v0, target, sam, age: 0 });
+            self.missiles.push(Missile { id, kind, pos: muzzle, vel: dir * v0, target, sam, age: 0, hold: 0, fix, seen: 0 });
             if spec.cold > 0 {
                 // Thrown out by gas: a puff, a thump; the motor lights later.
                 out.particles("minecraft:cloud", muzzle, 0.6, dir * 0.05, 0.05, 30);
@@ -2204,8 +2454,18 @@ impl Sim {
         let now = self.tick;
         let mut done: Vec<(u32, Option<u32>, bool, u32)> = Vec::new(); // (missile, target, kill, sam)
         let (mut missed, mut expired, mut orphaned) = (0u32, 0u32, 0u32);
-        let mut blocked = 0u32;
+        let (mut blocked, mut scrubbed) = (0u32, 0u32);
         let sams_fit: HashMap<u32, f64> = self.sams.iter().map(|s| (s.id, 1.0 - 0.3 * (1.0 - s.health.clamp(0.0, 1.0)))).collect();
+        // The data link (#66): the track the firing system holds of each missile's target, if it is up.
+        let links: HashMap<(u32, u32), Track> = self
+            .missiles
+            .iter()
+            .filter_map(|m| {
+                let s = self.sams.iter().find(|s| s.id == m.sam)?;
+                (s.alive() && !s.moving()).then_some(())?;
+                Some(((m.sam, m.target), *s.track(m.target)?))
+            })
+            .collect();
         for m in &mut self.missiles {
             m.age += 1;
             let spec = m.kind.spec();
@@ -2217,16 +2477,52 @@ impl Sim {
                 (m.vel.length() + spec.accel).min(spec.speed)
             };
             let dir = m.vel.normalize_or(DVec3::Y);
-            let new = match target {
-                Some(t) if m.age >= spec.boost => {
+            // What it knows: the link's newest track, and its own seeker once the target is in its reach and in view.
+            if let Some(tr) = links.get(&(m.sam, m.target))
+                && m.fix.is_none_or(|f| tr.tick > f.tick && !(f.seeker && now.saturating_sub(f.tick) <= REACQUIRE))
+            {
+                m.fix = Some(Fix { pos: tr.pos, vel: tr.vel, tick: tr.tick, seeker: false });
+            }
+            if let Some(t) = target
+                && lit
+                && m.age >= spec.boost
+                && m.kind.seeker() > 0.0
+            {
+                let range = m.kind.seeker() * t.kind.rcs().powf(0.25).clamp(0.6, 1.6);
+                let to = t.pos - m.pos;
+                let in_view = to.length() < range && to.normalize_or_zero().dot(dir) > 0.5;
+                if in_view && !matches!(ground.world.probe(m.pos, t.pos, now), world::Sweep::Hit { .. }) {
+                    m.seen = now;
+                }
+                if m.seen > 0 && now.saturating_sub(m.seen) <= REACQUIRE {
+                    // The seeker measures the target (the track of its own, newer than any link's).
+                    m.fix = Some(Fix { pos: if m.seen == now { t.pos } else { m.fix.map_or(t.pos, |f| f.pos) }, vel: t.vel, tick: if m.seen == now { now } else { m.fix.map_or(now, |f| f.tick) }, seeker: true });
+                }
+            }
+            // Nothing new for too long and no seeker on it: the interceptor has lost its target.
+            if target.is_some() && m.fix.is_none_or(|f| now.saturating_sub(f.tick) > MAX_COAST) && m.age > spec.boost + 20 {
+                expired += 1;
+                done.push((m.id, None, false, m.sam));
+                continue;
+            }
+            let aim = m.fix.map(|f| (f.est(now), f.vel));
+            let new = match aim {
+                Some((at, vel)) if m.age >= spec.boost => {
                     // Time to go by the closing speed: head-on targets come to meet it.
-                    let los = (t.pos - m.pos).normalize_or_zero();
-                    let closing = (speed - t.vel.dot(los)).max(1.0);
-                    let tgo = t.pos.distance(m.pos) / closing;
-                    turn(dir, t.pos + t.vel * tgo - m.pos, spec.turn)
+                    let los = (at - m.pos).normalize_or_zero();
+                    let closing = (speed - vel.dot(los)).max(1.0);
+                    let tgo = at.distance(m.pos) / closing;
+                    // Over the land in the way: lofted as far as the missile can, else it blows up before the ridge.
+                    let (want, fail) = terrain::steer(ground, m.kind, m.pos, speed, at + vel * tgo);
+                    if fail {
+                        scrubbed += 1;
+                        done.push((m.id, target.map(|t| t.id), false, m.sam));
+                        continue;
+                    }
+                    turn(dir, want, spec.turn)
                 }
                 // After a cold launch it tips over towards the target while the motor burns.
-                Some(t) if lit && spec.cold > 0 => turn(dir, t.pos - m.pos, spec.turn * 0.5),
+                Some((at, _)) if lit && spec.cold > 0 => turn(dir, at - m.pos, spec.turn * 0.5),
                 _ => dir,
             };
             let before = m.pos;
@@ -2234,7 +2530,24 @@ impl Sim {
             m.pos += m.vel;
             // The first block on the way this tick; a fuse that goes off earlier along the way still counts.
             ground.ahead(m.pos, m.vel, 10.0, now);
-            let world = ground.sweep(before, m.pos, m.age <= 12, now).hit();
+            let sweep = ground.trace(m.id | 0x8000_0000, before, m.pos, m.age <= 12, now);
+            let mut world = sweep.hit();
+            // Blocks not told of (#61): the interceptor holds at the edge of what is read, and no fuse is
+            // counted beyond it; low over a chunk the game doesn't have, it is lost there as against a wall.
+            if world.is_none()
+                && let world::Sweep::Unknown { t, pending } = sweep
+            {
+                let low = ground.at(m.pos, now).is_some_and(|g| before.y < g + 12.0);
+                if !pending && low {
+                    world = Some((t, before.lerp(m.pos, t)));
+                } else if let Some(t) = ground.unread(&sweep, &mut m.hold, low || pending) {
+                    m.pos = before.lerp(m.pos, t);
+                }
+            } else if let world::Sweep::Wait { t } = sweep {
+                m.pos = before.lerp(m.pos, (t - 1e-6).max(0.0));
+            } else if matches!(sweep, world::Sweep::Clear) {
+                m.hold = 0;
+            }
             if let Some(t) = target {
                 // Closest approach this tick, both moving (fast targets cross a fuse in a tick).
                 let rel0 = (t.pos - t.vel) - before;
@@ -2303,6 +2616,7 @@ impl Sim {
             t.expired += expired;
             t.orphaned += orphaned;
             t.blocked += blocked;
+            t.scrubbed += scrubbed;
         });
         for (mid, target, kill, sam) in done {
             if let Some(i) = self.missiles.iter().position(|m| m.id == mid) {

airdef-mod/src/sim/raid.rs

@@ -84,6 +84,12 @@ pub(super) struct Plan {
     approach: Approach,
     total: u32,
     centre: DVec3,
+    /// The land under the grid's cells (NaN where the game has none to tell of), the cells still unanswered, and
+    /// the ticks the planner has waited for the answers. A smart raid is routed over the land, not round it.
+    heights: Vec<f32>,
+    unanswered: Vec<u32>,
+    waited: u32,
+    mapped: bool,
 }
 
 /// The raid in progress: the counts at its start, for the report.
@@ -123,6 +129,20 @@ impl Grid {
 
 /// The cheapest way over `grid` from `from` to `to` by its prices (A*): points along it, `to` last.
 pub(super) fn plan_route(grid: &Grid, prices: &[f32], from: DVec3, to: DVec3) -> (Vec<DVec3>, usize) {
+    plan_route_on(grid, prices, None, from, to)
+}
+
+/// The land a route crosses: its height under each cell (NaN unknown), the climb a kind holds for long
+/// (rise a block), and the height above which the land forces a drone up from its low altitude.
+pub(super) struct Relief<'a> {
+    pub heights: &'a [f32],
+    pub slope: f32,
+    pub floor: f32,
+}
+
+/// [`plan_route`] over relief: a climb steeper than the kind holds is dear (a cliff or a ridge it would have to
+/// pull up over), and high land costs more than a valley, where it can fly low and stay under the radars.
+pub(super) fn plan_route_on(grid: &Grid, prices: &[f32], relief: Option<&Relief>, from: DVec3, to: DVec3) -> (Vec<DVec3>, usize) {
     let mut opened = 0;
     let n = grid.size;
     let at = |(i, j): (i32, i32)| (i * n + j) as usize;
@@ -151,7 +171,21 @@ pub(super) fn plan_route(grid: &Grid, prices: &[f32], from: DVec3, to: DVec3) ->
             }
             let len = if di != 0 && dj != 0 { std::f32::consts::SQRT_2 } else { 1.0 };
             // The target's own cell is where it must go, whatever covers it.
-            let price = if nb == goal { len } else { len * prices[at(nb)] };
+            let mut price = if nb == goal { len } else { len * prices[at(nb)] };
+            if let Some(r) = relief
+                && nb != goal
+            {
+                let (h0, h1) = (r.heights[at(c)], r.heights[at(nb)]);
+                if h1.is_finite() {
+                    price += len * ((h1 - r.floor) / 30.0).clamp(0.0, 4.0);
+                    if h0.is_finite() {
+                        let slope = (h1 - h0) / (len * grid.cell as f32);
+                        if slope > r.slope {
+                            price += (slope - r.slope) * 20.0 * len;
+                        }
+                    }
+                }
+            }
             let ng = g + price;
             if ng < best[at(nb)] {
                 best[at(nb)] = ng;
@@ -250,15 +284,53 @@ impl Sim {
             approach: order.approach,
             total,
             centre,
+            heights: Vec::new(),
+            unanswered: Vec::new(),
+            waited: 0,
+            mapped: !smart,
         });
         // A raid without routes is ready at once.
-        self.plan_step(out);
+        self.plan_step(None, out);
         total
     }
 
     /// Works on the raid's plan a while (a tick's share), and launches it when it is ready.
-    pub(super) fn plan_step(&mut self, out: &mut Out) {
+    pub(super) fn plan_step(&mut self, ground: Option<&mut Ground>, out: &mut Out) {
         let Some(mut plan) = self.plan.take() else { return };
+        // A smart raid first learns the land under its grid: asked for in bulk, a thousand columns a tick, for
+        // up to two seconds (what the game has no land for stays unknown and costs nothing).
+        if !plan.mapped {
+            let Some(ground) = ground else {
+                self.plan = Some(plan);
+                return;
+            };
+            let n = plan.grid.size;
+            if plan.heights.is_empty() {
+                plan.heights = vec![f32::NAN; (n * n) as usize];
+                plan.unanswered = (0..(n * n) as u32).collect();
+            }
+            let Plan { grid, heights, unanswered, .. } = &mut plan;
+            unanswered.retain(|&k| {
+                let (i, j) = (k as i32 / n, k as i32 % n);
+                let c = grid.centre((i, j), 0.0);
+                match ground.column(c.x.floor() as i32, c.z.floor() as i32, 1024) {
+                    None => true,
+                    Some(h) => {
+                        if let Some(h) = h {
+                            heights[k as usize] = h as f32;
+                        }
+                        false
+                    }
+                }
+            });
+            plan.waited += 1;
+            if plan.unanswered.is_empty() || plan.waited >= 40 {
+                plan.mapped = true;
+            } else {
+                self.plan = Some(plan);
+                return;
+            }
+        }
         let mut work = 0usize;
         while plan.next < plan.items.len() && work < WORK_PER_TICK {
             let i = plan.next;
@@ -268,17 +340,40 @@ impl Sim {
             };
             let spec = kind.spec();
             let mut d = plan.items[i].d.clone();
+            // It starts over the land, not in it: a hill under the starting point lifts it.
+            let mut from = from;
+            if !plan.heights.is_empty() {
+                let (gi, gj) = plan.grid.index(from);
+                let g = plan.heights[(gi * plan.grid.size + gj) as usize];
+                let floor = f64::from(g) + if spec.ballistic.is_some() { 10.0 } else { spec.clearance + 10.0 };
+                if g.is_finite() && from.y < floor {
+                    from.y = floor;
+                    d.pos.y = floor;
+                    if spec.ballistic.is_some() {
+                        let aimed = aim + d.err;
+                        let flat = horizontal(aimed - from);
+                        let time = (flat.length() / spec.speed).max(30.0);
+                        d.vel = flat / time + DVec3::Y * ((aimed.y - from.y + 0.5 * GRAVITY * time * time) / time);
+                    }
+                }
+            }
             let mut path = from.distance(aim);
             if let Some(key) = key {
                 let route = match plan.routes.get(&key) {
                     Some(r) => r.clone(),
                     None => {
                         if !plan.prices.contains_key(&kind) {
-                            let (p, cost) = self.price_grid(&plan.grid, kind);
+                            let heights = (!plan.heights.is_empty()).then_some(plan.heights.as_slice());
+                            let (p, cost) = self.price_grid_on(&plan.grid, kind, heights);
                             work += cost;
                             plan.prices.insert(kind, p);
                         }
-                        let (r, cost) = plan_route(&plan.grid, &plan.prices[&kind], from, aim);
+                        let relief = (!plan.heights.is_empty()).then(|| Relief {
+                            heights: &plan.heights,
+                            slope: (kind.climb_pitch().tan() * 0.5) as f32,
+                            floor: (aim.y + spec.clearance) as f32,
+                        });
+                        let (r, cost) = plan_route_on(&plan.grid, &plan.prices[&kind], relief.as_ref(), from, aim);
                         work += cost;
                         plan.routes.insert(key, r.clone());
                         r
@@ -333,6 +428,10 @@ impl Sim {
     pub(super) fn make_drone(&mut self, kind: DroneKind, from: DVec3, dir: DVec3, target: DVec3) -> Drone {
         let id = self.id();
         let spec = kind.spec();
+        // Its navigation error (CEP and a rare gross fault, #59/#65): the same for a manual launch and a raid.
+        // The raid's own ±4 spread of aim points is the tactical dispersal and stays on top of it.
+        let err = self.aim_error(kind);
+        let target = target + err;
         let (vel, flight) = if spec.ballistic.is_some() {
             let flat = horizontal(target - from);
             let time = (flat.length() / spec.speed).max(30.0);
@@ -357,6 +456,9 @@ impl Sim {
             jammed: false,
             sector: 0,
             smart: false,
+            nav: Nav::default(),
+            err,
+            hold: 0,
         }
     }
 
@@ -404,6 +506,12 @@ impl Sim {
     /// 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.
     pub(super) fn price_grid(&self, grid: &Grid, kind: DroneKind) -> (Vec<f32>, usize) {
+        self.price_grid_on(grid, kind, None)
+    }
+
+    /// The same over known land: a cell's drone flies `height` over the land there, not over the system's feet,
+    /// so what a radar sees and what a hill hides follow the relief.
+    pub(super) fn price_grid_on(&self, grid: &Grid, kind: DroneKind, land: Option<&[f32]>) -> (Vec<f32>, usize) {
         let mut cost = 0;
         let spec = kind.spec();
         let height = spec.clearance.max(6.0);
@@ -446,7 +554,8 @@ impl Sim {
             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 p = grid.centre((i, j), s.pos.y + height);
+                    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(s.pos.y + height, |g| f64::from(g) + height));
                     let d = horizontal(p - s.pos).length();
                     if d > far {
                         continue;

airdef-mod/src/sim/record.rs

@@ -65,6 +65,8 @@ pub struct Tally {
     pub ammo_waits: u32,
     /// Interceptors lost against the land or a building on their way.
     pub blocked: u32,
+    /// Interceptors that blew up in the air short of land they could not climb over.
+    pub scrubbed: u32,
 }
 
 impl Tally {
@@ -76,6 +78,7 @@ impl Tally {
             tracks_lost: self.tracks_lost.saturating_sub(start.tracks_lost),
             ammo_waits: self.ammo_waits.saturating_sub(start.ammo_waits),
             blocked: self.blocked.saturating_sub(start.blocked),
+            scrubbed: self.scrubbed.saturating_sub(start.scrubbed),
         }
     }
     /// The non-zero counts as a line, or nothing.
@@ -87,6 +90,7 @@ impl Tally {
             (self.tracks_lost, "потерь трека"),
             (self.ammo_waits, "ожиданий БК"),
             (self.blocked, "ракет разбились о препятствие"),
+            (self.scrubbed, "ракет самоуничтожились у рельефа"),
         ]
         .into_iter()
         .filter(|p| p.0 > 0)

airdef-mod/src/sim/regress.rs

@@ -137,7 +137,7 @@ fn retargeted_smart_drone_gets_a_route_round_the_defences() {
     sim.tick = 40;
     sim.adapt();
     let d = &sim.drones[0];
-    assert!(d.target.distance(DVec3::new(0.0, 70.0, 1000.0)) < 1.0, "not sent at the unit");
+    assert!((d.target - d.err).distance(DVec3::new(0.0, 70.0, 1000.0)) < 1.0, "not sent at the unit");
     assert!(d.route.len() > 1, "no route after the new target: it flies straight through the defences");
 }
 
@@ -187,7 +187,8 @@ fn turret_waits_for_its_aim() {
     sim.sams.push(Sam::new(id, SamKind::Radar, DVec3::new(0.0, 70.0, 0.0), 0.0));
     // Straight behind the turret's heading, a slow target well inside the gun's reach.
     sim.add_drone(DroneKind::Shahed, DVec3::new(0.0, 75.0, 60.0), DVec3::ZERO, DVec3::new(0.0, 70.0, 900.0));
-    sim.drones[0].vel = DVec3::ZERO;
+    // (Pointing away from the gun, so that it doesn't start by turning back over it.)
+    sim.drones[0].vel = DVec3::Z * 0.01;
     let (mut ground, mut out) = (Ground::default(), Out::default());
     let mut turned = 0;
     for _ in 0..200 {
@@ -374,8 +375,12 @@ fn fast_drone_must_not_cross_a_one_block_wall() {
     sim.add_drone(DroneKind::Zircon, DVec3::new(0.0, 100.0, 0.0), DVec3::X, DVec3::new(1000.0, 100.0, 0.0));
     sim.drones[0].flight = Flight::Dive;
     warm(&mut ground, &src, DVec3::new(0.0, 100.0, 0.0), DVec3::new(30.0, 100.0, 0.0));
-    fly(&mut sim, &mut ground, &src);
-    assert!(sim.drones.is_empty(), "crossed the wall in one tick");
+    // The wall's exact shape is asked of the game (#63): a tick or two, the drone holds at its face meanwhile.
+    for _ in 0..4 {
+        fly(&mut sim, &mut ground, &src);
+        assert!(sim.drones.first().is_none_or(|d| d.pos.x < 3.5), "crossed the wall");
+    }
+    assert!(sim.drones.is_empty(), "stuck at the wall");
     let at = sim.blasts.first().expect("no blast").at;
     assert!((at.x - 3.0).abs() < 0.05 && (at.y - 100.0).abs() < 1.5, "burst at {at:?}, not at the wall face x=3");
     assert_eq!((sim.crashes, sim.hits), (1, 0), "a wall in the way is a crash, not a hit on the aim");
@@ -392,7 +397,9 @@ fn drone_flying_into_a_hill_explodes_at_its_face() {
         let mut sim = Sim::new(3);
         sim.damage = false;
         let mut ground = Ground::default();
-        sim.add_drone(kind, DVec3::new(0.0, 80.0, 0.0), DVec3::X, DVec3::new(600.0, 80.0, 0.0));
+        // The aim is on the far side of the face, close enough that the dive is not called off for the hill (it is
+        // below, at the end of the dive, where flight planning leaves it alone).
+        sim.add_drone(kind, DVec3::new(0.0, 80.0, 0.0), DVec3::X, DVec3::new(80.0, 80.0, 0.0));
         sim.drones[0].flight = Flight::Dive;
         for _ in 0..300 {
             if sim.drones.is_empty() {
@@ -419,10 +426,14 @@ fn missile_cannot_pass_through_a_wall() {
     sim.drones[0].vel = DVec3::ZERO;
     sim.drones[0].engaged = 1;
     let (target, id) = (sim.drones[0].id, sim.id());
-    sim.missiles.push(Missile { id, kind: MissileKind::Pac3, pos: DVec3::new(0.0, 100.0, 0.0), vel: DVec3::X * 3.0, target, sam: 0, age: 20 });
+    sim.missiles.push(Missile { id, kind: MissileKind::Pac3, pos: DVec3::new(0.0, 100.0, 0.0), vel: DVec3::X * 3.0, target, sam: 0, age: 20, hold: 0, fix: None, seen: 0 });
     warm(&mut ground, &src, DVec3::new(0.0, 100.0, 0.0), DVec3::new(30.0, 100.0, 0.0));
-    sim.tick = 1;
-    sim.step_missiles(&mut ground, &mut Out::default());
+    for _ in 0..4 {
+        sim.tick += 1;
+        sim.step_missiles(&mut ground, &mut Out::default());
+        let wanted = ground.world.take_wanted(sim.tick);
+        ground.world.serve(&src, wanted, sim.tick);
+    }
     assert!(sim.missiles.is_empty(), "the missile is still flying");
     assert_eq!(sim.kills, 0, "a kill through the wall");
     assert!(sim.drones[0].alive(), "the target died behind the wall");
@@ -547,3 +558,653 @@ fn fires_start_merge_and_are_limited() {
     assert!(fl > 0.0 && sm > 0.0);
     assert_eq!(fires::level(3000.0, 3000.0).0, 0.0);
 }
+
+// ---- flight over the land: strike drones follow it, launchers keep their missiles for shots the land allows,
+// 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.
+struct Land<F: Fn(i32, i32) -> i32>(F);
+impl<F: Fn(i32, i32) -> i32> world::WorldSource for Land<F> {
+    fn solid(&self, x: i32, y: i32, z: i32) -> Option<bool> {
+        Some(y < (self.0)(x, z))
+    }
+}
+
+/// 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) {
+    let columns = ground.take_wanted().into_iter().map(|(x, z)| (x, z, (land.0)(x, z))).collect();
+    ground.answer(columns, now);
+    let sections = ground.world.take_wanted(now);
+    ground.world.serve(land, sections, now);
+}
+
+/// A ridge across the way, `rise` blocks high over a flat at 64, `half` blocks of slope to each side, crest at x=300.
+fn ridge(rise: i32, half: i32) -> Land<impl Fn(i32, i32) -> i32> {
+    ridge_at(300, rise, half)
+}
+
+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))
+}
+
+/// Flies one drone of `kind` along +x over `land` from x=0 to its aim at x=750, to the end. Returns the sim.
+fn fly_over<F: Fn(i32, i32) -> i32>(kind: DroneKind, land: &Land<F>, low: bool) -> Sim {
+    let mut sim = Sim::new(5);
+    sim.damage = false;
+    let mut ground = Ground::default();
+    let spec = kind.spec();
+    let height = if spec.cruise > 0.0 { spec.cruise } else { 25.0 };
+    sim.add_drone(kind, DVec3::new(0.0, 64.0 + height, 0.0), DVec3::X, DVec3::new(750.0, 64.0, 0.0));
+    sim.drones[0].low = low;
+    for _ in 0..4 {
+        sim.tick += 1;
+        answer_land(&mut ground, land, sim.tick);
+    }
+    let mut out = Out::default();
+    for _ in 0..4000 {
+        if sim.drones.is_empty() {
+            break;
+        }
+        sim.tick += 1;
+        sim.step_drones(&mut ground, None, &mut out);
+        answer_land(&mut ground, land, sim.tick);
+    }
+    sim
+}
+
+// Strike drones climb over a hill they could not have seen 20 blocks ahead.
+#[test]
+fn a_raid_crossing_a_hill_flies_over_it() {
+    for (rise, half) in [(60, 100), (60, 60), (90, 120)] {
+        let land = ridge(rise, half);
+        for kind in [DroneKind::Shahed, DroneKind::Geran3, DroneKind::Lancet, DroneKind::Gerbera, DroneKind::Kh101, DroneKind::Kalibr, DroneKind::Kh22, DroneKind::Zircon] {
+            for low in [false, true] {
+                let sim = fly_over(kind, &land, low);
+                assert!(sim.drones.is_empty(), "{kind:?}: still flying");
+                // It bursts at its aim, not on the hill 450 blocks short of it (where a crash or a decoy's end shows too).
+                let at = sim.blasts.first().expect("no blast").at;
+                assert!(at.x > 700.0, "{kind:?} low={low} burst at x={:.0} over a {rise}-block hill ({half} to the crest)", at.x);
+            }
+        }
+    }
+}
+
+// A low drone hugs the land: it does not fly at cruise height over the flat behind the ridge.
+#[test]
+fn a_low_drone_hugs_the_land_after_the_ridge() {
+    let land = ridge(60, 100);
+    let mut sim = Sim::new(5);
+    sim.damage = false;
+    let mut ground = Ground::default();
+    sim.add_drone(DroneKind::Shahed, DVec3::new(0.0, 75.0, 0.0), DVec3::X, DVec3::new(900.0, 64.0, 0.0));
+    sim.drones[0].low = true;
+    let mut out = Out::default();
+    let mut highest_after = 0.0f64;
+    for _ in 0..4000 {
+        if sim.drones.is_empty() {
+            break;
+        }
+        sim.tick += 1;
+        sim.step_drones(&mut ground, None, &mut out);
+        answer_land(&mut ground, &land, sim.tick);
+        if let Some(d) = sim.drones.first()
+            && d.pos.x > 560.0
+            && d.pos.x < 800.0
+        {
+            highest_after = highest_after.max(d.pos.y);
+        }
+    }
+    assert_eq!(sim.crashes, 0);
+    assert!(highest_after < 64.0 + 40.0, "still {highest_after:.0} high far behind the ridge");
+}
+
+/// A target flying slowly along the ridge's far side at `x`, with a radar on the crest to see it.
+fn behind_ridge(land: &Land<impl Fn(i32, i32) -> i32>, crest: i32, kind: SamKind, x: f64, ticks: u32) -> Sim {
+    let mut sim = Sim::new(9);
+    sim.damage = false;
+    let ground_y = (land.0)(0, 0) as f64;
+    let id = sim.id();
+    sim.sams.push(Sam::new(id, kind, DVec3::new(0.0, ground_y, 0.0), 0.0));
+    let id = sim.id();
+    sim.sams.push(Sam::new(id, SamKind::Radar, DVec3::new(f64::from(crest), (land.0)(crest, 0) as f64, -60.0), 0.0));
+    let mut ground = Ground::default();
+    let mut out = Out::default();
+    for _ in 0..40 {
+        sim.tick += 1;
+        answer_land(&mut ground, land, sim.tick);
+    }
+    // It crawls along the far side of the ridge, 20 blocks over the land.
+    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));
+    for _ in 0..ticks {
+        sim.step(&mut ground, None, &mut out);
+        answer_land(&mut ground, land, sim.tick);
+    }
+    sim
+}
+
+// A short-range system behind a hill does not fire at a target the hill masks from it, whatever the network says.
+#[test]
+fn a_system_does_not_fire_at_a_target_masked_by_a_hill() {
+    // A short-range system 250 blocks short of the crest, the target 80 blocks beyond it.
+    type Boxed = Land<Box<dyn Fn(i32, i32) -> i32>>;
+    let hill: Boxed = Land(Box::new(|x, _| 64 + (60 - (x - 150).abs()).max(0)));
+    let flat: Boxed = Land(Box::new(|_, _| 64));
+    let shot = |land: &Boxed| {
+        let mut sim = Sim::new(9);
+        sim.damage = false;
+        let id = sim.id();
+        sim.sams.push(Sam::new(id, SamKind::Tor, DVec3::new(100.0, 64.0, 0.0), 0.0));
+        let id = sim.id();
+        sim.sams.push(Sam::new(id, SamKind::Radar, DVec3::new(150.0, (land.0)(150, 0) as f64, -60.0), 0.0));
+        let mut ground = Ground::default();
+        let mut out = Out::default();
+        for _ in 0..40 {
+            sim.tick += 1;
+            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));
+        let mut masked = 0u32;
+        let mut seen = false;
+        let mut told = false;
+        for _ in 0..300 {
+            sim.step(&mut ground, None, &mut out);
+            answer_land(&mut ground, land, sim.tick);
+            seen |= sim.sams[0].seen.len() == 1;
+            masked += sim.sams[0].terrain.values().filter(|(_, b)| *b == terrain::MASKED).count() as u32;
+            // `why` names the reason while the verdict stands.
+            told |= sim.why(0).iter().any(|c| !c.ok && c.text.contains("за рельефом"));
+        }
+        (sim, seen, masked, told)
+    };
+    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);
+    let (shut, seen, masked, told) = shot(&hill);
+    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!(masked > 0, "no launch was judged and refused for the land");
+    assert_eq!(shut.tally.blocked + shut.tally.scrubbed, 0);
+    assert!(told, "`why` never named the land as the reason");
+}
+
+// A long-range system lofts over a low ridge (its interceptor does not hit it) but not over a mountain.
+#[test]
+fn a_long_range_system_lofts_over_a_ridge_or_waits() {
+    let low = ridge_at(150, 25, 60);
+    let sim = behind_ridge(&low, 150, SamKind::IrisT, 230.0, 300);
+    assert!(sim.sams[0].fired > 0, "an IRIS-T SLM must loft over a 25-block ridge");
+    assert_eq!(sim.tally.blocked + sim.tally.scrubbed, 0, "its interceptors hit the ridge");
+    let tall = ridge_at(150, 400, 100);
+    // The track is fresh only for a while (the target creeps out of reach): the reason is read at several moments.
+    let mut told = false;
+    for ticks in (150..=300).step_by(10) {
+        let sim = behind_ridge(&tall, 150, SamKind::IrisT, 230.0, ticks);
+        assert_eq!(sim.sams[0].fired, 0, "no missile can climb a 400-block mountain at this range");
+        assert_eq!(sim.tally.blocked + sim.tally.scrubbed, 0);
+        told |= sim.why(0).iter().any(|c| !c.ok && c.text.contains("рельеф"));
+    }
+    assert!(told, "`why` never named the land as the reason");
+}
+
+// Interceptors fly over rolling land at a target low over it, and none ends in the ground.
+#[test]
+fn an_interceptor_over_rolling_land_does_not_hit_the_ground() {
+    let rolling = Land(|x: i32, z: i32| 70 + (28.0 * ((f64::from(x) / 21.0).sin() + (f64::from(z) / 33.0).cos()) / 2.0).round() as i32);
+    for kind in [MissileKind::Pac3, MissileKind::M48n6, MissileKind::IrisT, MissileKind::M57e6, MissileKind::M9m338, MissileKind::P1sun] {
+        for dx in [160.0, 260.0, 380.0] {
+            let mut sim = Sim::new(4);
+            sim.damage = false;
+            let mut ground = Ground::default();
+            let mut out = Out::default();
+            for _ in 0..4 {
+                sim.tick += 1;
+                answer_land(&mut ground, &rolling, sim.tick);
+            }
+            // A Gerbera 20 blocks over the land at the far end, flying away from the launcher.
+            let at = DVec3::new(dx, (rolling.0)(dx as i32, 0) as f64 + 20.0, 0.0);
+            sim.add_drone(DroneKind::Gerbera, at, DVec3::X, DVec3::new(5000.0, 64.0, 0.0));
+            let (target, id) = (sim.drones[0].id, sim.id());
+            let from = DVec3::new(0.0, (rolling.0)(0, 0) as f64 + 3.0, 0.0);
+            sim.drones[0].engaged = 1;
+            sim.missiles.push(Missile { id, kind, pos: from, vel: DVec3::new(0.5, 0.8, 0.0).normalize() * 0.8, target, sam: 0, age: 0, hold: 0, fix: Some(fix_of(&sim.drones[0], sim.tick)), seen: 0 });
+            for _ in 0..500 {
+                if sim.missiles.is_empty() {
+                    break;
+                }
+                sim.tick += 1;
+                sim.step_missiles(&mut ground, &mut out);
+                answer_land(&mut ground, &rolling, sim.tick);
+            }
+            assert!(sim.missiles.is_empty(), "{kind:?} at {dx}: still flying");
+            assert_eq!(sim.tally.blocked, 0, "{kind:?} at {dx}: the interceptor hit the ground");
+        }
+    }
+}
+
+/// The fix a link would have given on a target (a test stand-in for the firing system's track; these tests keep their targets still).
+fn fix_of(d: &Drone, tick: u64) -> Fix {
+    Fix { pos: d.pos, vel: DVec3::ZERO, tick, seeker: false }
+}
+
+// An interceptor with no way over the land blows up in the air, and that is counted.
+#[test]
+fn an_interceptor_without_a_way_over_blows_up_high() {
+    let wall = ridge(300, 40);
+    let mut sim = Sim::new(4);
+    sim.damage = false;
+    let mut ground = Ground::default();
+    let mut out = Out::default();
+    for _ in 0..4 {
+        sim.tick += 1;
+        answer_land(&mut ground, &wall, sim.tick);
+    }
+    sim.add_drone(DroneKind::Gerbera, DVec3::new(420.0, 90.0, 0.0), DVec3::X, DVec3::new(5000.0, 64.0, 0.0));
+    let (target, id) = (sim.drones[0].id, sim.id());
+    sim.drones[0].engaged = 1;
+    sim.missiles.push(Missile { id, kind: MissileKind::M57e6, pos: DVec3::new(230.0, 70.0, 0.0), vel: DVec3::X * 3.0, target, sam: 0, age: 20, hold: 0, fix: Some(fix_of(&sim.drones[0], sim.tick)), seen: 0 });
+    for _ in 0..200 {
+        if sim.missiles.is_empty() {
+            break;
+        }
+        sim.tick += 1;
+        sim.step_missiles(&mut ground, &mut out);
+        answer_land(&mut ground, &wall, sim.tick);
+    }
+    assert!(sim.missiles.is_empty());
+    assert_eq!((sim.tally.scrubbed, sim.tally.blocked), (1, 0), "{:?}", sim.tally);
+    assert_eq!(sim.drones[0].engaged, 0);
+    let at = sim.blasts.first().expect("no blast").at;
+    assert!(at.y > (wall.0)(at.x as i32, 0) as f64 + 3.0, "it burst in the ground at {at:?}");
+}
+
+// ---- #61-#66, #69 (review of 6f3fc64): unread blocks, cache lifetime, exact shapes, heights, accuracy, guidance, fires
+
+/// Blocks with finer shapes: `shape` gives the boxes of a block (none: from `solid`).
+struct Shaped<S: Fn(i32, i32, i32) -> Option<Vec<[f64; 6]>>>(S);
+impl<S: Fn(i32, i32, i32) -> Option<Vec<[f64; 6]>>> world::WorldSource for Shaped<S> {
+    fn solid(&self, x: i32, y: i32, z: i32) -> Option<bool> {
+        (self.0)(x, y, z).map(|b| !b.is_empty())
+    }
+    fn boxes(&self, x: i32, y: i32, z: i32) -> Vec<[f64; 6]> {
+        (self.0)(x, y, z).unwrap_or_default()
+    }
+}
+
+// #61: a flight on a cold cache does not cross the wall before the game has answered
+#[test]
+fn cold_cache_never_means_clear_for_a_drone() {
+    let src = Blocks(|x, y, z| Some(y < 64 || (x == 3 && (64..141).contains(&y) && z.abs() < 50)));
+    let mut sim = Sim::new(1);
+    sim.damage = false;
+    let mut ground = Ground::default();
+    sim.add_drone(DroneKind::Zircon, DVec3::new(0.0, 100.0, 0.0), DVec3::X, DVec3::new(1000.0, 100.0, 0.0));
+    sim.drones[0].flight = Flight::Dive;
+    // No warm-up: nothing is read. One tick: the drone has not gone through, and asks for the sections.
+    sim.tick += 1;
+    sim.step_drones(&mut ground, None, &mut Out::default());
+    assert!(sim.drones[0].pos.x < 3.5, "crossed the wall unread: x = {}", sim.drones[0].pos.x);
+    assert!(ground.world.stats.held > 0);
+    let mut hit_wall = false;
+    for _ in 0..8 {
+        let wanted = ground.world.take_wanted(sim.tick);
+        ground.world.serve(&src, wanted, sim.tick);
+        sim.tick += 1;
+        sim.step_drones(&mut ground, None, &mut Out::default());
+        assert!(sim.drones.first().is_none_or(|d| d.pos.x < 3.5), "crossed the wall");
+        hit_wall |= sim.drones.is_empty();
+    }
+    assert!(hit_wall && sim.crashes == 1, "the wall was not found once read: crashes {}", sim.crashes);
+}
+
+// #61: nor does an interceptor fuse past the unread part of its way
+#[test]
+fn cold_cache_does_not_fuse_through_a_wall() {
+    let src = Blocks(|x, y, z| Some(y < 64 || (x == 3 && (64..141).contains(&y) && z.abs() < 50)));
+    let mut sim = Sim::new(1);
+    let mut ground = Ground::default();
+    sim.add_drone(DroneKind::Shahed, DVec3::new(8.5, 100.0, 0.0), DVec3::ZERO, DVec3::new(0.0, 100.0, 900.0));
+    sim.drones[0].vel = DVec3::ZERO;
+    sim.drones[0].engaged = 1;
+    let (target, id) = (sim.drones[0].id, sim.id());
+    let fix = Some(fix_of(&sim.drones[0], 0));
+    sim.missiles.push(Missile { id, kind: MissileKind::Pac3, pos: DVec3::new(0.0, 100.0, 0.0), vel: DVec3::X * 3.0, target, sam: 0, age: 20, hold: 0, fix, seen: 0 });
+    sim.tick = 1;
+    sim.step_missiles(&mut ground, &mut Out::default());
+    assert_eq!(sim.missiles.len(), 1, "the missile went on (held) at the edge of what is read");
+    assert!(sim.missiles[0].pos.x < 3.5 && sim.kills == 0 && sim.tally.missed == 0, "fused unread");
+    for _ in 0..6 {
+        let wanted = ground.world.take_wanted(sim.tick);
+        ground.world.serve(&src, wanted, sim.tick);
+        sim.tick += 1;
+        sim.step_missiles(&mut ground, &mut Out::default());
+    }
+    assert!(sim.missiles.is_empty() && sim.kills == 0 && sim.tally.blocked == 1, "{:?}", sim.tally);
+}
+
+// #61: a chunk the game does not have holds a low flight for a bounded time, then it goes on; a section
+// that was queued as a look-ahead moves up when a step needs it, even with the queue full.
+#[test]
+fn unknown_policy_is_bounded_and_urgent_sections_jump_the_queue() {
+    let none = Blocks(|_, _, _| None);
+    let mut ground = Ground::default();
+    // Ground known: the flight is 5 blocks over it, so it is low.
+    ground.answer((-40..400).map(|x| (x, 0, 64)).collect(), 0);
+    let mut sim = Sim::new(1);
+    sim.damage = false;
+    sim.add_drone(DroneKind::Shahed, DVec3::new(0.0, 69.0, 0.0), DVec3::X, DVec3::new(5000.0, 69.0, 0.0));
+    let mut held = 0;
+    for _ in 0..900 {
+        let before = sim.drones[0].pos;
+        sim.tick += 1;
+        sim.step_drones(&mut ground, None, &mut Out::default());
+        let wanted = ground.world.take_wanted(sim.tick);
+        ground.world.serve(&none, wanted, sim.tick);
+        held += (sim.drones[0].pos.distance(before) < 1e-3) as u32;
+    }
+    assert!(held > 20, "an unloaded chunk was no obstacle at all ({held})");
+    assert!(sim.drones[0].pos.x > 100.0, "held for ever at x = {}", sim.drones[0].pos.x);
+    // Urgent over ahead.
+    let mut w = world::WorldCache::default();
+    for i in 0..600 {
+        w.look_ahead(DVec3::new(f64::from(i) * 16.0, 70.0, 0.0), DVec3::X, 1.0, 1);
+    }
+    w.sweep(DVec3::new(500.5, 70.5, 0.5), DVec3::new(501.5, 70.5, 0.5), false, 1);
+    let first = w.take_wanted(1);
+    assert!(first.contains(&(31, 4, 0)), "the section a step needs waited behind look-aheads");
+}
+
+// #62: a chunk's unload or replacement voids what was known; light-only changes cost nothing
+#[test]
+fn chunk_replacement_and_age_invalidate_known_sections() {
+    let mut w = world::WorldCache::default();
+    let (a, b) = (DVec3::new(0.5, 70.5, 0.5), DVec3::new(30.5, 70.5, 0.5));
+    let empty = Blocks(|_, _, _| Some(false));
+    let wall = Blocks(|x, _, _| Some(x == 20));
+    w.changed_rev(1, 10, false, &[]);
+    for t in 1..4 {
+        w.sweep(a, b, false, t);
+        let q = w.take_wanted(t);
+        w.serve(&empty, q, t);
+    }
+    assert_eq!(w.sweep(a, b, false, 5), world::Sweep::Clear);
+    // Light only: the counter does not move, nothing happens.
+    let n = w.stats.invalidated;
+    w.changed_rev(1, 10, false, &[]);
+    assert_eq!(w.stats.invalidated, n, "a light update invalidated the cache");
+    // The chunk is replaced by a packet with a wall: the game says which column (unload/replace note).
+    w.columns_changed(&[(0, 0), (1, 0)]);
+    assert!(matches!(w.sweep(a, b, false, 6), world::Sweep::Unknown { pending: true, .. }), "an unloaded chunk still answers from memory");
+    for t in 7..10 {
+        w.sweep(a, b, false, t);
+        let q = w.take_wanted(t);
+        w.serve(&wall, q, t);
+    }
+    assert!(matches!(w.sweep(a, b, false, 10), world::Sweep::Hit { block: [20, 70, 0], .. }));
+    // A replacement nobody listed: the counter moved with no section named; everything read is read again.
+    w.changed_rev(1, 11, false, &[]);
+    assert!(matches!(w.sweep(a, b, false, 11), world::Sweep::Hit { .. }), "old data is used until the answer");
+    let q = w.take_wanted(11);
+    assert!(!q.is_empty());
+    w.serve(&empty, q, 12);
+    assert_eq!(w.sweep(a, b, false, 13), world::Sweep::Clear);
+    // And a section in use is read again after a while, told of or not.
+    for t in (14..14 + 1300).step_by(100) {
+        w.sweep(a, b, false, t);
+    }
+    assert!(w.stats.aged > 0 && !w.take_wanted(1400).is_empty(), "never read again");
+    // Another world, as ever.
+    w.changed_rev(2, 0, false, &[]);
+    assert!(w.is_empty());
+}
+
+// #63: a lower slab does not stop what flies over its free half; a full wall and the slab's own half do
+#[test]
+fn partial_blocks_use_exact_shapes() {
+    let slab = Shaped(|x, y, z| {
+        if y < 64 {
+            Some(vec![[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]])
+        } else if (x, y, z) == (10, 70, 0) {
+            Some(vec![[0.0, 0.0, 0.0, 1.0, 0.5, 1.0]])
+        } else if x == 20 && z == 0 {
+            Some(vec![[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]])
+        } else {
+            Some(vec![])
+        }
+    });
+    let mut g = Ground::default();
+    let run = |g: &mut Ground, a: DVec3, b: DVec3| {
+        let mut r = g.trace(7, a, b, false, 1);
+        for t in 1..8 {
+            let q = g.world.take_wanted(t);
+            g.world.serve(&slab, q, t);
+            if !matches!(r, world::Sweep::Wait { .. } | world::Sweep::Unknown { .. }) {
+                break;
+            }
+            r = g.trace(7, a, b, false, t + 1);
+        }
+        r
+    };
+    // The free upper half: clear (and the wall at x=20 is further on than the segment).
+    let r = run(&mut g, DVec3::new(9.5, 70.75, 0.5), DVec3::new(11.5, 70.75, 0.5));
+    assert_eq!(r, world::Sweep::Clear, "the free half of a slab was an obstacle");
+    // Through the slab's own half: a hit where its shape starts.
+    let mut g = Ground::default();
+    let r = run(&mut g, DVec3::new(9.5, 70.25, 0.5), DVec3::new(11.5, 70.25, 0.5));
+    let world::Sweep::Hit { point, normal, block, .. } = r else { panic!("{r:?}") };
+    assert!((point.x - 10.0).abs() < 1e-9 && normal == [-1, 0, 0] && block == [10, 70, 0], "{r:?}");
+    // A full-size wall is a hit at its face, like the section's cube.
+    let mut g = Ground::default();
+    let r = run(&mut g, DVec3::new(18.5, 70.5, 0.5), DVec3::new(22.5, 70.5, 0.5));
+    assert!(matches!(r, world::Sweep::Hit { block: [20, 70, 0], normal: [-1, 0, 0], .. }), "{r:?}");
+    // The flight holds at the face meanwhile (a pending answer is a wait, not a pass).
+    let mut g = Ground::default();
+    let w = world::WorldCache::default();
+    drop(w);
+    for t in 0..4 {
+        let q = g.world.take_wanted(t);
+        g.world.serve(&slab, q, t);
+        g.world.sweep(DVec3::new(18.5, 70.5, 0.5), DVec3::new(22.5, 70.5, 0.5), false, t);
+    }
+    let first = g.trace(9, DVec3::new(18.5, 70.5, 0.5), DVec3::new(22.5, 70.5, 0.5), false, 5);
+    assert!(matches!(first, world::Sweep::Wait { .. }), "{first:?}");
+    // Never answered: after the wait the solid cube of the sections stands.
+    let last = g.trace(9, DVec3::new(18.5, 70.5, 0.5), DVec3::new(22.5, 70.5, 0.5), false, 5 + 31);
+    assert!(matches!(last, world::Sweep::Hit { .. }), "{last:?}");
+}
+
+// #64: heights known are old when blocks change, a chunk is replaced, or time passes; they are asked again
+#[test]
+fn land_heights_follow_world_changes_and_age() {
+    let mut g = Ground::default();
+    g.answer(vec![(4, 4, 150)], 0);
+    assert_eq!(g.land(DVec3::new(4.0, 70.0, 4.0)), Some(150.0));
+    assert!(g.take_wanted().is_empty(), "a fresh height was asked again");
+    // The mountain is blown away: the game says which section changed.
+    g.world.changed(1, false, &[(0, 9, 0)]);
+    g.answer(vec![], 10);
+    assert_eq!(g.land(DVec3::new(4.0, 70.0, 4.0)), Some(150.0), "the old height is used until the new one comes");
+    assert!(g.take_wanted().contains(&(4, 4)), "a changed column was not asked again");
+    g.answer(vec![(4, 4, 70)], 11);
+    assert_eq!(g.land(DVec3::new(4.0, 70.0, 4.0)), Some(70.0));
+    // Another column is not touched by that.
+    g.answer(vec![(100, 100, 90)], 12);
+    g.world.changed(1, false, &[(0, 9, 0)]);
+    g.answer(vec![], 13);
+    assert_eq!(g.land(DVec3::new(100.0, 70.0, 100.0)), Some(90.0));
+    assert!(!g.take_wanted().contains(&(100, 100)));
+    // Time alone: the issue's case, 500 seconds on.
+    g.answer(vec![], 10_000);
+    assert_eq!(g.land(DVec3::new(4.0, 70.0, 4.0)), Some(70.0));
+    assert!(g.take_wanted().contains(&(4, 4)), "never asked again after 500 s");
+    // A planner column too.
+    let mut g = Ground::default();
+    g.answer(vec![(20, 20, 80)], 0);
+    g.answer(vec![], 5000);
+    assert_eq!(g.column(20, 20, 1000), Some(Some(80.0)));
+    assert!(g.take_wanted().contains(&(20, 20)));
+    // A chunk replaced.
+    let mut g = Ground::default();
+    g.answer(vec![(4, 4, 150), (8, 8, 150)], 0);
+    g.world.columns_changed(&[(0, 0)]);
+    g.answer(vec![], 1);
+    g.land(DVec3::new(4.0, 70.0, 4.0));
+    assert!(g.take_wanted().contains(&(4, 4)));
+}
+
+// #65: manual launches and raids draw their navigation error the same way, and a retarget keeps it
+#[test]
+fn raids_have_the_same_strike_accuracy_as_manual_launches() {
+    for kind in [DroneKind::Kh101, DroneKind::Shahed, DroneKind::Zircon] {
+        let (cep, gross) = kind.accuracy();
+        let aim = DVec3::new(0.0, 70.0, 1000.0);
+        let mut sim = Sim::new(1);
+        let (mut manual, mut raid) = (Vec::new(), Vec::new());
+        for _ in 0..600 {
+            sim.add_drone(kind, DVec3::new(0.0, 120.0, 0.0), DVec3::Z, aim);
+            let d = sim.drones.pop().unwrap();
+            manual.push(horizontal(d.target - aim).length());
+            let d = sim.make_drone(kind, DVec3::new(0.0, 120.0, 0.0), DVec3::Z, aim);
+            raid.push(horizontal(d.target - aim).length());
+            assert!(d.err != DVec3::ZERO && (d.target - aim - d.err).length() < 1e-9);
+        }
+        for (name, v) in [("manual", &mut manual), ("raid", &mut raid)] {
+            v.sort_by(f64::total_cmp);
+            let median = v[v.len() / 2];
+            assert!((median - cep).abs() < cep * 0.25, "{kind:?} {name}: median {median} for a CEP of {cep}");
+            let far = v.iter().filter(|r| **r > MISS_RADIUS).count() as f64 / v.len() as f64;
+            assert!(far > gross * 0.4 && far < gross * 2.5 + 0.02, "{kind:?} {name}: {far} beyond the blast for a fault rate of {gross}");
+        }
+    }
+    // A planned raid's drones all carry their error, and a smart retarget gives the new aim on top of it.
+    let mut sim = Sim::new(3);
+    let id = sim.id();
+    sim.sams.push(Sam::new(id, SamKind::Ew, DVec3::new(0.0, 70.0, 900.0), 0.0));
+    sim.intel.revealed.push((id, DVec3::new(0.0, 70.0, 900.0), 0));
+    let order = RaidOrder { kinds: vec![(DroneKind::Zircon, 20)], approach: Approach::Sector, dist: 400.0, aim: Aim::Objects };
+    sim.order_raid(&order, &[DVec3::new(0.0, 70.0, 0.0)], &mut Out::default());
+    for _ in 0..40 {
+        if !sim.planning() {
+            break;
+        }
+        sim.step(&mut Ground::default(), None, &mut Out::default());
+    }
+    assert!(!sim.queue.is_empty() && sim.queue.iter().all(|(_, d)| d.err != DVec3::ZERO), "raid drones without a navigation error");
+    let mut d = sim.make_drone(DroneKind::Zircon, DVec3::new(0.0, 100.0, -500.0), DVec3::Z, DVec3::new(0.0, 70.0, 0.0));
+    let err = d.err;
+    d.smart = true;
+    sim.queue.clear();
+    sim.queue.push((0, d));
+    sim.tick = 40;
+    sim.adapt();
+    let d = &sim.queue[0].1;
+    assert!((d.target - d.err - DVec3::new(0.0, 70.0, 900.0)).length() < 1e-9 && d.err == err, "the retarget lost or doubled the error");
+}
+
+// #66: an interceptor steers on what it was told or what its seeker holds, not on the true position
+#[test]
+fn interceptors_guide_on_tracks_and_seekers_not_on_truth() {
+    let fly = |hidden: DVec3, fix: Option<Fix>| {
+        let mut sim = Sim::new(1);
+        sim.add_drone(DroneKind::Shahed, hidden, DVec3::ZERO, DVec3::new(0.0, 100.0, 5000.0));
+        sim.drones[0].vel = DVec3::ZERO;
+        let (target, id) = (sim.drones[0].id, sim.id());
+        sim.missiles.push(Missile { id, kind: MissileKind::Pac3, pos: DVec3::new(0.0, 100.0, 0.0), vel: DVec3::Z * 3.0, target, sam: 999, age: 100, hold: 0, fix, seen: 0 });
+        sim.tick = 100;
+        sim.step_missiles(&mut Ground::default(), &mut Out::default());
+        sim.missiles.first().map(|m| m.vel)
+    };
+    // The issue's case: no system, no track, a target 600 away that is somewhere else in the second copy.
+    let a = fly(DVec3::new(0.0, 100.0, 600.0), None);
+    let b = fly(DVec3::new(300.0, 100.0, 600.0), None);
+    assert_eq!(a, b, "the missile knows where the target is without any measurement");
+    // The data link's fix is what it steers on, wherever the target went since.
+    let told = Some(Fix { pos: DVec3::new(300.0, 100.0, 600.0), vel: DVec3::ZERO, tick: 100, seeker: false });
+    let (c, d) = (fly(DVec3::new(0.0, 100.0, 600.0), told), fly(DVec3::new(-300.0, 100.0, 600.0), told));
+    assert_eq!(c, d);
+    assert!(c.unwrap().x > 0.05, "it did not turn to the fix: {c:?}");
+    // The seeker takes over once the target is in its reach: now the truth steers it.
+    let near = |at: DVec3| {
+        let mut sim = Sim::new(1);
+        sim.add_drone(DroneKind::Shahed, at, DVec3::ZERO, DVec3::new(0.0, 100.0, 5000.0));
+        sim.drones[0].vel = DVec3::ZERO;
+        let (target, id) = (sim.drones[0].id, sim.id());
+        let stale = Some(Fix { pos: DVec3::new(-60.0, 100.0, 80.0), vel: DVec3::ZERO, tick: 90, seeker: false });
+        sim.missiles.push(Missile { id, kind: MissileKind::Pac3, pos: DVec3::new(0.0, 100.0, 0.0), vel: DVec3::Z * 3.0, target, sam: 999, age: 100, hold: 0, fix: stale, seen: 0 });
+        sim.tick = 100;
+        sim.step_missiles(&mut Ground::default(), &mut Out::default());
+        (sim.missiles[0].vel, sim.missiles[0].seen)
+    };
+    let (v, seen) = near(DVec3::new(40.0, 100.0, 70.0));
+    assert!(seen == 100 && v.x > 0.05, "the seeker did not hold a target in its reach: {v:?}");
+    let (v, seen) = near(DVec3::new(300.0, 100.0, 70.0));
+    assert!(seen == 0 && v.x < -0.05, "a target outside its reach steered it: {v:?}");
+    // Behind a mountain the seeker sees nothing.
+    let mut sim = Sim::new(1);
+    sim.add_drone(DroneKind::Shahed, DVec3::new(40.0, 100.0, 70.0), DVec3::ZERO, DVec3::new(0.0, 100.0, 5000.0));
+    sim.drones[0].vel = DVec3::ZERO;
+    let (target, id) = (sim.drones[0].id, sim.id());
+    sim.missiles.push(Missile { id, kind: MissileKind::Pac3, pos: DVec3::new(0.0, 100.0, 0.0), vel: DVec3::Z * 3.0, target, sam: 999, age: 100, hold: 0, fix: Some(Fix { pos: DVec3::new(0.0, 100.0, 300.0), vel: DVec3::ZERO, tick: 90, seeker: false }), seen: 0 });
+    let hill = Blocks(|x, y, z| Some(y < 64 || ((10..14).contains(&x) && (0..40).contains(&z) && y < 300)));
+    let mut ground = Ground::default();
+    for t in 0..6 {
+        ground.world.probe(DVec3::new(0.0, 100.0, 0.0), DVec3::new(40.0, 100.0, 70.0), t);
+        let q = ground.world.take_wanted(t);
+        ground.world.serve(&hill, q, t);
+    }
+    sim.tick = 100;
+    sim.step_missiles(&mut ground, &mut Out::default());
+    assert_eq!(sim.missiles[0].seen, 0, "the seeker saw through a mountain");
+    // No fix for too long and no seeker on it: the interceptor is lost, and counted so.
+    let mut sim = Sim::new(1);
+    sim.add_drone(DroneKind::Shahed, DVec3::new(0.0, 100.0, 3000.0), DVec3::ZERO, DVec3::new(0.0, 100.0, 5000.0));
+    sim.drones[0].vel = DVec3::ZERO;
+    let (target, id) = (sim.drones[0].id, sim.id());
+    let old = Some(Fix { pos: DVec3::new(0.0, 100.0, 300.0), vel: DVec3::ZERO, tick: 0, seeker: false });
+    sim.missiles.push(Missile { id, kind: MissileKind::Pac3, pos: DVec3::new(0.0, 100.0, 0.0), vel: DVec3::Z * 3.0, target, sam: 999, age: 100, hold: 0, fix: old, seen: 0 });
+    sim.tick = MAX_COAST + 50;
+    sim.step_missiles(&mut Ground::default(), &mut Out::default());
+    assert!(sim.missiles.is_empty() && sim.tally.expired == 1, "{:?}", sim.tally);
+}
+
+// #69: many separate strikes: the list, what is drawn and the lights are bounded; the rest end properly
+#[test]
+fn mass_strikes_keep_fires_effects_and_lights_bounded() {
+    let mut sim = Sim::new(1);
+    sim.damage = true;
+    let mut ground = Ground::default();
+    ground.answer((-100..2000).flat_map(|x| (-10..10).map(move |z| (x, z, 70))).collect(), 0);
+    for i in 0..120 {
+        sim.ignite(DVec3::new(f64::from(i) * 10.0, 70.0, 0.0), (i % 5) as u32, None);
+    }
+    assert!(sim.fires.len() <= fires::LIST_MAX, "{} fires kept", sim.fires.len());
+    let mut peak_particles = 0;
+    for _ in 0..200 {
+        sim.tick += 1;
+        let mut out = Out::default();
+        sim.step_fires(&mut ground, &mut out);
+        peak_particles = peak_particles.max(out.particles.iter().map(|p| p.count as usize).sum::<usize>());
+        assert!(sim.fires.list.iter().filter(|f| f.shown).count() <= fires::MAX);
+        assert!(sim.fires.len() <= fires::LIST_MAX);
+    }
+    // Twelve fires at full strength: well under what 120 would have been.
+    assert!(peak_particles < 12 * 24 + fires::LIST_MAX, "{peak_particles} particles in a tick");
+    // A long stream of strikes, one every few ticks, stays bounded; at the end all go out and the blocks go with them.
+    for i in 0..400 {
+        sim.tick += 5;
+        sim.ignite(DVec3::new(f64::from(i % 150) * 12.0, 70.0, 0.0), 2, None);
+        sim.step_fires(&mut ground, &mut Out::default());
+        assert!(sim.fires.len() <= fires::LIST_MAX);
+    }
+    let mut commands = 0;
+    for _ in 0..8000 {
+        sim.tick += 1;
+        let mut out = Out::default();
+        sim.step_fires(&mut ground, &mut out);
+        commands += out.commands.len();
+        if sim.fires.is_empty() {
+            break;
+        }
+    }
+    assert!(sim.fires.is_empty(), "fires burn for ever");
+    let _ = commands;
+}

airdef-mod/src/sim/terrain.rs

@@ -0,0 +1,354 @@
+//! Flights and the land. Strike drones follow the terrain with a look-ahead worth several seconds of flight
+//! (what they can still climb is a question of their speed and turn rate), dive only down a clear line, and
+//! interceptors keep a safety height over the land ahead, loft over a ridge when the line is blocked, and
+//! blow up high when there is no way over. The launch predicates (`why`) ask the same questions of a
+//! shot before it is fired, so a system doesn't spend missiles on targets behind a hill.
+//!
+//! The land comes from `Ground::land`: heights sampled on a coarse lattice, so many flights share columns and
+//! the questions to the game stay few; what the heights miss (trees, buildings, overhangs) is caught by a
+//! probe through the block cache.
+use super::*;
+
+/// Land heights are sampled at the centres of cells this wide.
+const LATTICE: i32 = 8;
+/// Land questions waiting at once: flights ask for more than a tick can send, and wait.
+const ASK_MAX: usize = 192;
+
+/// What the game has said of the land at a place.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub(super) enum Rise {
+    /// Not yet: asked.
+    Pending,
+    /// There is no land to tell of (no chunk).
+    Void,
+    /// One above the highest solid block.
+    At(f64),
+}
+
+impl Ground {
+    /// One above the highest solid block at the lattice cell holding `p`, if known; asked for when it isn't.
+    /// Like `at` it asks again for a column that is old or was reported changed (#64), and it leaves room for the questions that matter more.
+    pub fn land(&mut self, p: DVec3) -> Option<f64> {
+        match self.rise(p) {
+            Rise::At(g) => Some(g),
+            _ => None,
+        }
+    }
+
+    /// The same, saying whether the game has not answered yet or has no land there to tell of.
+    pub(super) fn rise(&mut self, p: DVec3) -> Rise {
+        let key = (
+            (p.x.floor() as i32).div_euclid(LATTICE) * LATTICE + LATTICE / 2,
+            (p.z.floor() as i32).div_euclid(LATTICE) * LATTICE + LATTICE / 2,
+        );
+        match self.known.get(&key) {
+            Some(&(y, when)) => {
+                // Old or reported changed: still used, asked again with the questions to spare.
+                if self.due(when) && self.wanted.len() < ASK_MAX / 2 && self.asked.insert(key) {
+                    self.wanted.push(key);
+                }
+                if y > -64 { Rise::At(f64::from(y)) } else { Rise::Void }
+            }
+            None => {
+                if self.wanted.len() < ASK_MAX && self.asked.insert(key) {
+                    self.wanted.push(key);
+                }
+                Rise::Pending
+            }
+        }
+    }
+
+    /// The land's height at a column for the raid planner: `None` while the game hasn't answered, `Some(None)`
+    /// where it has no land to tell of. Asks, up to `cap` questions waiting.
+    pub(super) fn column(&mut self, x: i32, z: i32, cap: usize) -> Option<Option<f64>> {
+        match self.known.get(&(x, z)) {
+            Some(&(y, when)) => {
+                if self.due(when) && self.wanted.len() < cap / 2 && self.asked.insert((x, z)) {
+                    self.wanted.push((x, z));
+                }
+                Some((y > -64).then_some(f64::from(y)))
+            }
+            None => {
+                if self.wanted.len() < cap && self.asked.insert((x, z)) {
+                    self.wanted.push((x, z));
+                }
+                None
+            }
+        }
+    }
+}
+
+/// What a flight can do about a rise ahead.
+#[derive(Clone, Copy, Debug)]
+pub(super) struct Climb {
+    /// Radius of its tightest pull-up (blocks).
+    pub radius: f64,
+    /// The steepest climb it holds (radians).
+    pub pitch: f64,
+}
+
+impl Climb {
+    /// How much height it can have gained by the time it has gone `s` blocks on, starting level.
+    pub fn gain(&self, s: f64) -> f64 {
+        let arc = self.radius * self.pitch.sin();
+        if s <= arc {
+            self.radius - (self.radius * self.radius - s * s).max(0.0).sqrt()
+        } else {
+            self.radius * (1.0 - self.pitch.cos()) + (s - arc) * self.pitch.tan()
+        }
+    }
+}
+
+impl DroneKind {
+    /// The steepest climb it holds in cruise (radians): cruise missiles are the shallowest.
+    pub(super) fn climb_pitch(self) -> f64 {
+        match self {
+            DroneKind::Kh101 | DroneKind::Kalibr => 0.45,
+            DroneKind::Lancet => 0.7,
+            DroneKind::Geran3 | DroneKind::Kh22 => 0.6,
+            _ => 0.5,
+        }
+    }
+    pub(super) fn climb(self) -> Climb {
+        let s = self.spec();
+        Climb { radius: (s.speed / s.turn.max(0.01) * 1.15).max(12.0), pitch: self.climb_pitch() }
+    }
+    /// Blocks it looks ahead: eight seconds of flight, at least a pull-up and a climb over a hill.
+    pub(super) fn look_len(self) -> f64 {
+        let s = self.spec();
+        (s.speed * 160.0).clamp(160.0, 900.0)
+    }
+}
+
+/// A flight's new heading: it turns in yaw towards `heading` and in pitch towards a climb of `slope`, together
+/// at most `rate` radians a tick, so a turn on to a new course doesn't dip or climb by itself (a great-circle
+/// turn between nearly opposite headings can go either way). With `climb` set the pitch comes first and the
+/// yaw gets what is left of the rate.
+pub(super) fn fly_towards(old: DVec3, heading: DVec3, slope: f64, rate: f64, climb: bool) -> DVec3 {
+    let (old_yaw, old_pitch) = (old.x.atan2(old.z), old.y.clamp(-1.0, 1.0).asin());
+    let want_yaw = heading.x.atan2(heading.z);
+    let mut yaw = angle_diff(old_yaw, want_yaw);
+    let mut pitch = slope.atan() - old_pitch;
+    if climb {
+        pitch = pitch.clamp(-rate, rate);
+        yaw = yaw.clamp(-(rate * rate - pitch * pitch).max(0.0).sqrt(), (rate * rate - pitch * pitch).max(0.0).sqrt());
+    } else {
+        let total = yaw.hypot(pitch);
+        if total > rate {
+            yaw *= rate / total;
+            pitch *= rate / total;
+        }
+    }
+    let (yaw, pitch) = (old_yaw + yaw, old_pitch + pitch);
+    DVec3::new(yaw.sin() * pitch.cos(), pitch.sin(), yaw.cos() * pitch.cos())
+}
+
+/// How far over the land a dive's line passes.
+pub(super) const DIVE_MARGIN: f64 = 8.0;
+
+/// `v` with its pitch held between `lo` and `hi` (radians); `level` is the way it faces if it points straight up or down.
+pub(super) fn clamp_pitch(v: DVec3, lo: f64, hi: f64, level: DVec3) -> DVec3 {
+    let pitch = v.y.clamp(-1.0, 1.0).asin();
+    if (lo..=hi).contains(&pitch) {
+        return v;
+    }
+    let pitch = pitch.clamp(lo, hi);
+    horizontal(v).normalize_or(level) * pitch.cos() + DVec3::Y * pitch.sin()
+}
+
+/// Distances ahead where the land is sampled.
+const REACH: [f64; 21] = [
+    0.0, 8.0, 16.0, 24.0, 32.0, 44.0, 56.0, 72.0, 90.0, 112.0, 136.0, 164.0, 196.0, 232.0, 272.0, 316.0, 366.0, 424.0, 500.0, 600.0,
+    720.0,
+];
+
+/// The height a flight must be at *now* to clear the land along each of `lines` (a unit horizontal direction and
+/// how far out to look) by `clear`, given what it can climb: the greatest over the samples of the land's height plus clearance
+/// less the height it can gain on the way. `None` when nothing is known.
+pub(super) fn required_height(ground: &mut Ground, pos: DVec3, lines: &[(DVec3, f64)], clear: f64, climb: &Climb) -> Option<f64> {
+    let mut need: Option<f64> = None;
+    for &(dir, len) in lines {
+        for &s in REACH.iter().chain(&[900.0]) {
+            if s > len {
+                break;
+            }
+            if let Some(g) = ground.land(pos + dir * s) {
+                let h = g + clear - climb.gain(s);
+                need = Some(need.map_or(h, |n: f64| n.max(h)));
+            }
+        }
+    }
+    need
+}
+
+/// The least height to start from, over here, so that the straight line down to `target` stays `margin` over the
+/// land (the last stretch before the aim is the target's own business). `None` when the land isn't known.
+pub(super) fn dive_height(ground: &mut Ground, pos: DVec3, target: DVec3, margin: f64) -> Option<f64> {
+    let flat = horizontal(target - pos);
+    let total = flat.length();
+    if total < 20.0 {
+        return None;
+    }
+    let dir = flat / total;
+    let mut need: Option<f64> = None;
+    let n = ((total - 14.0) / 12.0).clamp(1.0, 40.0) as i32;
+    for k in 0..=n {
+        let s = (total - 14.0) * f64::from(k) / f64::from(n);
+        if let Some(g) = ground.land(pos + dir * s) {
+            let f = s / total;
+            let y = (g + margin - target.y * f) / (1.0 - f);
+            need = Some(need.map_or(y, |m: f64| m.max(y)));
+        }
+    }
+    need
+}
+
+/// The slope (rise a block) a flight at `from` must hold to clear the land by `margin` on its way towards
+/// `to`, with a pull-up of `radius` for the climb to begin early, ignoring the last `skip` blocks before `to`.
+/// Returns the slope and how far away the land that asks for it is; `None` when nothing is in the way or known.
+pub(super) fn rope(ground: &mut Ground, from: DVec3, to: DVec3, margin: f64, radius: f64, (near, reach, skip): (f64, f64, f64), pending: &mut bool) -> Option<(f64, f64)> {
+    let flat = horizontal(to - from);
+    let total = flat.length();
+    if total < 1.0 {
+        return None;
+    }
+    let dir = flat / total;
+    let end = (total - skip).min(reach);
+    let mut best: Option<(f64, f64)> = None;
+    let mut s = near;
+    while s <= end {
+        match ground.rise(from + dir * s) {
+            Rise::At(g) => {
+                let slope = (g + margin - from.y) / (s - radius * 0.6).max(6.0);
+                if best.is_none_or(|b| slope > b.0) {
+                    best = Some((slope, s));
+                }
+            }
+            Rise::Pending => *pending = true,
+            Rise::Void => {}
+        }
+        s += if s < 64.0 { 8.0 } else { 16.0 };
+    }
+    best
+}
+
+// ---------------------------------------------------------------- interceptors
+
+impl MissileKind {
+    /// The steepest climb it flies to get over land (radians): long-range missiles loft, short-range ones don't.
+    pub(super) fn loft(self) -> f64 {
+        match self {
+            MissileKind::M77n6 => 1.25,
+            MissileKind::M48n6 => 1.1,
+            MissileKind::Pac3 | MissileKind::IrisT | MissileKind::Amraam => 0.9,
+            MissileKind::M9m317 => 0.8,
+            MissileKind::P1sun => 0.5,
+            MissileKind::M57e6 | MissileKind::M9m338 => 0.3,
+        }
+    }
+    /// Whether it lofts over a ridge to a target behind it.
+    pub(super) fn lofts(self) -> bool {
+        self.loft() >= 0.5
+    }
+}
+
+/// How high above the land an interceptor keeps.
+pub(super) const MISSILE_MARGIN: f64 = 8.0;
+
+/// What keeps an interceptor from being launched at a target for the land in the way.
+pub(super) const MASKED: u8 = 1;
+pub(super) const PATH_BLOCKED: u8 = 2;
+/// The land under the line of fire has been asked for and not answered: the shot waits a tick or two.
+pub(super) const WAIT: u8 = 4;
+/// Ticks a shot waits for the land to be answered before it is judged on what is known.
+pub(super) const WAIT_TICKS: u64 = 30;
+
+/// Whether a shot from `muzzle` (launcher at `antenna`) at a target forecast at `est` moving at `vel` may be
+/// fired for the land: the intercept point must not be behind a hill from the launcher, unless the missile
+/// lofts, and the path the missile would fly must be clear.
+pub(super) fn launch_blocks(ground: &mut Ground, kind: MissileKind, muzzle: DVec3, antenna: DVec3, est: DVec3, vel: DVec3) -> u8 {
+    let spec = kind.spec();
+    // Where it meets the target: the forecast carried on for the flight time.
+    let mut at = est;
+    for _ in 0..2 {
+        let tgo = muzzle.distance(at) / (spec.speed * 0.8);
+        at = est + vel * tgo;
+    }
+    let flat = horizontal(at - antenna);
+    let total = flat.length();
+    if total < 40.0 {
+        return 0;
+    }
+    let dir = flat / total;
+    // The line of sight from the launcher: any rise of the land over the line to the intercept point masks it.
+    let mut masked = false;
+    let mut waiting = false;
+    let mut s = 12.0;
+    while s < total - 12.0 {
+        match ground.rise(antenna + dir * s) {
+            Rise::At(g) if g + 1.0 > antenna.y + (at.y - antenna.y) * s / total => {
+                masked = true;
+                break;
+            }
+            Rise::Pending => waiting = true,
+            _ => {}
+        }
+        s += 16.0;
+    }
+    if !masked && waiting {
+        return WAIT;
+    }
+    if !masked {
+        return 0;
+    }
+    if !kind.lofts() {
+        return MASKED;
+    }
+    // A lofted path: climbs at the slope the highest land in the way asks for, and comes down on the target.
+    let radius = spec.speed / spec.turn.max(0.05);
+    let mut pending = false;
+    let path = rope(ground, muzzle, at, MISSILE_MARGIN, radius, (32.0, total, 24.0), &mut pending);
+    match path {
+        Some((slope, _)) if slope > kind.loft().tan() => PATH_BLOCKED,
+        _ if pending => WAIT,
+        _ => 0,
+    }
+}
+
+impl Sam {
+    /// What the land said of a shot at `target` when it was last judged, if lately.
+    pub(super) fn terrain_verdict(&self, target: u32, now: u64) -> Option<u8> {
+        self.terrain.get(&target).filter(|(when, _)| now.saturating_sub(*when) <= VERDICT_AGE).map(|(_, bits)| *bits)
+    }
+}
+
+/// Ticks a launch verdict (the land in the way) is kept before the shot is judged again.
+pub(super) const VERDICT_AGE: u64 = 20;
+
+/// Which way an interceptor steers to keep clear of the land: `aim` is where it would go; the result is a direction
+/// (unit) raised as far as its loft allows, and whether the land is in the way beyond that.
+pub(super) fn steer(ground: &mut Ground, kind: MissileKind, pos: DVec3, speed: f64, aim: DVec3) -> (DVec3, bool) {
+    let spec = kind.spec();
+    let want = (aim - pos).normalize_or(DVec3::Y);
+    let flat = horizontal(want);
+    let flat_len = flat.length();
+    let reach = (speed * 18.0).clamp(60.0, 320.0);
+    let radius = speed / spec.turn.max(0.05);
+    let Some((slope, at)) = rope(ground, pos, aim, MISSILE_MARGIN, radius, (8.0, reach, 20.0), &mut false) else { return (want, false) };
+    let wanted = if flat_len > 1e-6 { want.y / flat_len } else { f64::INFINITY };
+    if slope <= wanted {
+        return (want, false);
+    }
+    let cap = kind.loft().tan();
+    let dir = flat.normalize_or(DVec3::X);
+    let raised = (dir + DVec3::Y * slope.min(cap)).normalize();
+    // No way over, and the land close enough ahead that the next ticks will end in it: blow up before.
+    let mut fail = false;
+    if slope > cap + 0.02 && at < (speed * 6.0).max(40.0) {
+        fail = (1..=4).any(|k| {
+            let p = pos + raised * speed * f64::from(k);
+            ground.land(p).is_some_and(|g| g + 2.0 > p.y)
+        });
+    }
+    (raised, fail)
+}

airdef-mod/src/sim/why.rs

@@ -308,7 +308,19 @@ impl Sim {
             let aligned = missile_aligned(spec.family, sam.yaw, mount, Some(est), t.id, t.id, err);
             let turn = if vertical { "вертикальный старт" } else { "доворот" };
             v.push(check(aligned, format!("{turn}: ошибка наведения {:.0}°{}", err.to_degrees(), if aligned { "" } else { " — ещё доворачивается" })));
-            fires |= reach == 0 && free < need && mb == 0 && aligned && blocks == 0;
+            // The land: the verdict the launch decision gave this target (`terrain::launch_blocks`) a moment ago.
+            let land = sam.terrain_verdict(t.id, now).unwrap_or(0);
+            if land != 0 {
+                v.push(check(
+                    false,
+                    if land & terrain::MASKED != 0 {
+                        "рельеф: цель за рельефом — ракета не стартует, ждём, пока цель выйдет из-за него"
+                    } else {
+                        "рельеф: траектория перекрыта рельефом — подняться над ним ракета не может"
+                    },
+                ));
+            }
+            fires |= reach == 0 && free < need && mb == 0 && aligned && blocks == 0 && land == 0;
         }
         if let Some(gun) = &spec.gun {
             let on_it = guns_on.get(&t.id).copied().unwrap_or(0) - u32::from(sam.gun_target == Some(t.id));

airdef-mod/src/sim/world.rs

@@ -18,6 +18,8 @@ pub const PER_TICK: usize = 64;
 const MAX_SECTIONS: usize = 12_000;
 /// Ticks before an unanswered or unknown section is asked again.
 const RETRY: u64 = 60;
+/// Ticks after which a section in use is read again, whether or not a change was reported (#62).
+const RECHECK: u64 = 1200;
 /// Longest stretch of a flight asked for ahead, in blocks.
 const AHEAD_MAX: f64 = 192.0;
 /// Questions waiting: more are dropped (they are asked again when needed).
@@ -57,8 +59,11 @@ pub enum Sweep {
     Clear,
     /// The first solid block: where the segment meets it, which way the face looks, and the block.
     Hit { t: f64, point: DVec3, normal: [i32; 3], block: [i32; 3] },
-    /// The walk reached blocks the game doesn't know (before any solid one), `t` of the way.
-    Unknown { t: f64 },
+    /// The walk reached blocks the game doesn't know (before any solid one), `t` of the way. `pending`: the
+    /// section hasn't been answered yet (it is asked for, urgently); else the game said it has no chunk there.
+    Unknown { t: f64, pending: bool },
+    /// A solid block was met at `t` and its exact shape is being asked for (#63): the flight holds at its face.
+    Wait { t: f64 },
 }
 
 impl Sweep {
@@ -83,10 +88,60 @@ pub struct WorldStats {
     pub invalidated: u64,
     pub evicted: u64,
     pub world_changes: u64,
+    /// Steps cut short at unread blocks (#61), and steps let through after waiting for too long.
+    pub held: u64,
+    pub passed_unknown: u64,
+    /// Sections dropped or re-read for a chunk's unload or replacement, or for age (#62).
+    pub aged: u64,
+    pub columns_changed: u64,
+}
+
+/// What the game's exact ray said of a flight's step, once it answered (#63).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Exact {
+    Pending,
+    /// The collision shapes leave the way open.
+    Clear,
+    /// Where the shapes stop it: the point, the face and the block.
+    Hit { point: DVec3, normal: [i32; 3], block: [i32; 3] },
+}
+
+struct RayEntry {
+    id: u32,
+    a: DVec3,
+    b: DVec3,
+    state: Exact,
+    asked: u64,
+}
+
+/// The game's verdict on an exact ray, as `render.rays` gives it.
+#[derive(Clone, Copy, Debug)]
+pub struct RayReply {
+    pub id: u32,
+    pub clear: bool,
+    pub hit: bool,
+    pub fraction: f64,
+    pub normal: [i32; 3],
+    pub block: [i32; 3],
+}
+
+/// Ticks an exact ray may take to be answered before the block counts as the solid cube the sections say.
+const RAY_WAIT: u64 = 30;
+/// Exact rays asked in one tick (the game's budget is 256).
+const RAYS_PER_TICK: usize = 128;
+
+#[derive(Default)]
+struct RayDesk {
+    next: u32,
+    /// By flight and block: a flight that meets the same block again finds its answer.
+    entries: HashMap<(u32, [i32; 3]), RayEntry>,
+    by_id: HashMap<u32, (u32, [i32; 3])>,
+    out: Vec<(u32, DVec3, DVec3)>,
 }
 
 #[derive(Default)]
 pub struct WorldCache {
+    rays: RayDesk,
     secs: HashMap<Sec, Entry>,
     urgent: Vec<Sec>,
     ahead: Vec<Sec>,
@@ -94,6 +149,15 @@ pub struct WorldCache {
     /// Sections asked, and when.
     asked: HashMap<Sec, u64>,
     epoch: u32,
+    /// The game's count of block changes, as of the last note, and the one the section entries were read at.
+    revision: u64,
+    /// The last `solid` that could not tell: the section was not answered yet.
+    unread_pending: bool,
+    /// Sweeps made as a look ahead (flight planning) ask for sections after the urgent ones.
+    quiet: bool,
+    /// Columns (section x, z) where blocks changed since the land heights last looked (#64); `all`: too many to say.
+    pub(super) changed_cols: HashSet<(i32, i32)>,
+    pub(super) changed_all: bool,
     pub stats: WorldStats,
 }
 
@@ -134,6 +198,22 @@ impl WorldCache {
     /// The game's note of changes: another world voids everything; changed
     /// sections (or too many to say) are read again when next used.
     pub fn changed(&mut self, epoch: u32, overflow: bool, sections: &[Sec]) {
+        self.changed_rev(epoch, self.revision, overflow, sections);
+    }
+
+    /// The same with the game's change counter: a jump in it that the listed sections don't explain
+    /// (changes the game didn't list, a chunk replaced behind the subscription's back) makes every section
+    /// read before it due for a new read when it is next used (#62).
+    pub fn changed_rev(&mut self, epoch: u32, revision: u64, overflow: bool, sections: &[Sec]) {
+        let unexplained = self.epoch == epoch && revision != self.revision && sections.is_empty() && !overflow;
+        self.revision = revision;
+        if unexplained {
+            // Not named, so not known which: a light update alone doesn't move the counter, a block change does.
+            for e in self.secs.values_mut() {
+                e.stale = true;
+            }
+            self.stats.invalidated += self.secs.len() as u64;
+        }
         if epoch != self.epoch {
             if self.epoch != 0 {
                 self.secs.clear();
@@ -141,9 +221,13 @@ impl WorldCache {
                 self.ahead.clear();
                 self.queued.clear();
                 self.asked.clear();
+                self.changed_all = true;
             }
             self.epoch = epoch;
         }
+        if overflow || unexplained {
+            self.changed_all = true;
+        }
         if overflow {
             for e in self.secs.values_mut() {
                 e.stale = true;
@@ -151,6 +235,7 @@ impl WorldCache {
             self.stats.invalidated += self.secs.len() as u64;
         }
         for s in sections {
+            self.note_column(s.0, s.2);
             if let Some(e) = self.secs.get_mut(s) {
                 e.stale = true;
                 self.stats.invalidated += 1;
@@ -159,6 +244,38 @@ impl WorldCache {
         self.stats.world_changes += sections.len() as u64;
     }
 
+    fn note_column(&mut self, sx: i32, sz: i32) {
+        if self.changed_cols.len() >= 4096 {
+            self.changed_all = true;
+        } else {
+            self.changed_cols.insert((sx, sz));
+        }
+    }
+
+    /// Chunk columns (x, z in chunks) the game unloaded or replaced (#62): what is known of their sections is
+    /// void (`Unknown`) until they are read again. A new chunk packet replaces the blocks wholesale, which no
+    /// per-block note says.
+    pub fn columns_changed(&mut self, columns: &[(i32, i32)]) {
+        if columns.is_empty() {
+            return;
+        }
+        let set: HashSet<(i32, i32)> = columns.iter().copied().collect();
+        let mut n = 0u64;
+        for &(cx, cz) in columns {
+            self.note_column(cx, cz);
+        }
+        for (s, e) in self.secs.iter_mut() {
+            if set.contains(&(s.0, s.2)) {
+                e.fill = Fill::Unknown;
+                e.stale = true;
+                e.since = 0;
+                n += 1;
+            }
+        }
+        self.stats.invalidated += n;
+        self.stats.columns_changed += columns.len() as u64;
+    }
+
     /// An explosion is about to change the land: the sections round it are read again.
     pub fn touched(&mut self, at: DVec3, radius: f64) {
         let lo = sec_of((at.x - radius).floor() as i32, (at.y - radius).floor() as i32, (at.z - radius).floor() as i32);
@@ -218,11 +335,24 @@ impl WorldCache {
     }
 
     fn want(&mut self, s: Sec, urgent: bool, now: u64) {
-        if self.queued.contains(&s) || self.asked.get(&s).is_some_and(|&t| now.saturating_sub(t) < RETRY) {
+        if self.queued.contains(&s) {
+            // Already waiting as a look-ahead, and a step needs it now: it moves up (#61).
+            if urgent && let Some(i) = self.ahead.iter().position(|a| *a == s) {
+                self.ahead.swap_remove(i);
+                self.urgent.push(s);
+            }
+            return;
+        }
+        if self.asked.get(&s).is_some_and(|&t| now.saturating_sub(t) < RETRY) {
             return;
         }
         if self.urgent.len() + self.ahead.len() >= QUEUE_MAX {
-            return;
+            // Full: an urgent need pushes a look-ahead out, a look-ahead waits.
+            if !urgent || self.ahead.is_empty() {
+                return;
+            }
+            let gone = self.ahead.swap_remove(0);
+            self.queued.remove(&gone);
         }
         if urgent {
             self.urgent.push(s);
@@ -264,7 +394,12 @@ impl WorldCache {
             return false;
         };
         e.used = now;
-        let refresh = e.stale || (e.fill == Fill::Unknown && now.saturating_sub(e.since) >= RETRY);
+        // Whatever is in use is read again now and then, bounded: a change nobody told of ends up seen (#62).
+        let aged = e.fill != Fill::Unknown && now.saturating_sub(e.since) >= RECHECK;
+        if aged {
+            self.stats.aged += 1;
+        }
+        let refresh = e.stale || aged || (e.fill == Fill::Unknown && now.saturating_sub(e.since) >= RETRY);
         if refresh {
             self.want(s, urgent, now);
         }
@@ -277,10 +412,19 @@ impl WorldCache {
         let s = sec_of(x, y, z);
         if *last != Some(s) {
             *last = Some(s);
-            self.touch(s, true, now);
+            self.touch(s, !self.quiet, now);
         }
-        match &self.secs.get(&s)?.fill {
-            Fill::Unknown => None,
+        self.unread_pending = false;
+        let Some(entry) = self.secs.get(&s) else {
+            self.unread_pending = true;
+            return None;
+        };
+        match &entry.fill {
+            Fill::Unknown => {
+                // Asked and answered unknown: no chunk there. Asked again (or not at all yet): waiting.
+                self.unread_pending = entry.stale && entry.since == 0;
+                None
+            }
             Fill::Empty => Some(false),
             Fill::Full => Some(true),
             Fill::Mixed(bits) => {
@@ -301,6 +445,84 @@ impl WorldCache {
         self.solid(&mut None, x, y, z, now) == Some(true)
     }
 
+    /// A sweep made to plan a flight, not to move one: the sections it needs are asked after the urgent ones,
+    /// and a start inside a block is not a hit.
+    pub fn probe(&mut self, a: DVec3, b: DVec3, now: u64) -> Sweep {
+        self.quiet = true;
+        let r = self.sweep(a, b, true, now);
+        self.quiet = false;
+        r
+    }
+
+    /// A step of flight `key` from `a` to `b` that met a solid block (`hit`): the occupancy says "stops
+    /// something", the shape may leave room (slabs, stairs, fences, panes). The block's exact shapes are asked
+    /// of the game (a ray over the step) and the flight holds at the face meanwhile; a `Hit` comes back as the
+    /// exact contact, a `Clear` lets this flight through that block. An answer that doesn't come in
+    /// [`RAY_WAIT`] ticks, or `unknown`, leaves the hit as the solid cube.
+    pub fn narrow(&mut self, key: u32, hit: Sweep, a: DVec3, b: DVec3, now: u64) -> Sweep {
+        let Sweep::Hit { t, block, .. } = hit else { return hit };
+        let k = (key, block);
+        let Some(e) = self.rays.entries.get_mut(&k) else {
+            if self.rays.entries.len() >= 4096 {
+                return hit;
+            }
+            self.rays.next = self.rays.next.wrapping_add(1);
+            let id = self.rays.next;
+            self.rays.entries.insert(k, RayEntry { id, a, b, state: Exact::Pending, asked: now });
+            self.rays.by_id.insert(id, k);
+            self.rays.out.push((id, a, b));
+            return Sweep::Wait { t };
+        };
+        if e.state == Exact::Pending && now.saturating_sub(e.asked) > RAY_WAIT {
+            e.state = Exact::Hit { point: a + (b - a) * t, normal: [0; 3], block };
+        }
+        match e.state {
+            Exact::Pending => Sweep::Wait { t },
+            Exact::Clear => Sweep::Clear,
+            Exact::Hit { point, normal, block } => {
+                let d = b - a;
+                let f = ((point - a).dot(d) / d.length_squared().max(1e-12)).max(0.0);
+                if f > 1.0 {
+                    // The shape's face is beyond this step: nothing is met yet.
+                    Sweep::Clear
+                } else {
+                    Sweep::Hit { t: f, point, normal, block }
+                }
+            }
+        }
+    }
+
+    /// The exact rays to ask this tick: id, start, end.
+    pub fn take_rays(&mut self, now: u64) -> Vec<(u32, DVec3, DVec3)> {
+        let n = RAYS_PER_TICK.min(self.rays.out.len());
+        let out: Vec<_> = self.rays.out.drain(..n).collect();
+        if now % 128 == 0 {
+            let dead: Vec<_> = self.rays.entries.iter().filter(|(_, e)| now.saturating_sub(e.asked) > 600).map(|(k, _)| *k).collect();
+            for k in dead {
+                if let Some(e) = self.rays.entries.remove(&k) {
+                    self.rays.by_id.remove(&e.id);
+                }
+            }
+        }
+        out
+    }
+
+    /// The game's answers to the exact rays.
+    pub fn answer_rays(&mut self, replies: &[RayReply]) {
+        for r in replies {
+            let Some(k) = self.rays.by_id.get(&r.id).copied() else { continue };
+            let Some(e) = self.rays.entries.get_mut(&k) else { continue };
+            e.state = if r.clear {
+                Exact::Clear
+            } else if r.hit {
+                Exact::Hit { point: e.a + (e.b - e.a) * r.fraction, normal: r.normal, block: r.block }
+            } else {
+                // No verdict: the solid cube the sections said.
+                Exact::Hit { point: e.a, normal: [0; 3], block: k.1 }
+            };
+        }
+    }
+
     /// The first solid block along `a` to `b`, by walking the blocks it
     /// crosses; `skip_start` ignores the block it starts in (a launch from a
     /// pad that is part of the land).
@@ -329,7 +551,7 @@ impl WorldCache {
             match self.solid(&mut last, pos[0], pos[1], pos[2], now) {
                 None => {
                     self.stats.unknown_sweeps += 1;
-                    return Sweep::Unknown { t };
+                    return Sweep::Unknown { t, pending: self.unread_pending };
                 }
                 Some(true) if !(first && skip_start) => {
                     self.stats.hits += 1;
@@ -355,7 +577,7 @@ impl WorldCache {
             face[axis] = -step[axis];
         }
         self.stats.unknown_sweeps += 1;
-        Sweep::Unknown { t }
+        Sweep::Unknown { t, pending: false }
     }
 }
 
@@ -364,6 +586,38 @@ impl WorldCache {
 pub trait WorldSource {
     /// Whether the block stops a projectile; `None` where there is no chunk.
     fn solid(&self, x: i32, y: i32, z: i32) -> Option<bool>;
+    /// The collision boxes of the block (`[x0, y0, z0, x1, y1, z1]` inside the block): a full cube where
+    /// it is solid, unless the world has finer shapes.
+    fn boxes(&self, x: i32, y: i32, z: i32) -> Vec<[f64; 6]> {
+        if self.solid(x, y, z) == Some(true) { vec![[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]] } else { Vec::new() }
+    }
+}
+
+/// The first entry of segment `a` to `b` into the box (slab test): the fraction and the axis.
+fn enter_box(a: DVec3, d: DVec3, lo: DVec3, hi: DVec3) -> Option<(f64, usize)> {
+    let (mut t0, mut t1, mut axis) = (0.0f64, 1.0f64, usize::MAX);
+    for i in 0..3 {
+        let (o, v) = (a[i], d[i]);
+        if v.abs() < 1e-12 {
+            if o < lo[i] || o > hi[i] {
+                return None;
+            }
+        } else {
+            let (mut n, mut f) = ((lo[i] - o) / v, (hi[i] - o) / v);
+            if n > f {
+                std::mem::swap(&mut n, &mut f);
+            }
+            if n > t0 {
+                t0 = n;
+                axis = i;
+            }
+            t1 = t1.min(f);
+            if t0 > t1 {
+                return None;
+            }
+        }
+    }
+    Some((t0, axis))
 }
 
 /// A [`WorldSource`] as the game would answer `render.query-sections` with it.
@@ -391,9 +645,48 @@ pub fn section_of(source: &dyn WorldSource, s: Sec) -> Fill {
 }
 
 impl WorldCache {
+    /// Answers the exact rays of the last tick from a synthetic world, as the game does one tick later.
+    pub fn serve_rays(&mut self, source: &dyn WorldSource, rays: Vec<(u32, DVec3, DVec3)>) {
+        let replies: Vec<RayReply> = rays
+            .into_iter()
+            .map(|(id, a, b)| {
+                let d = b - a;
+                let mut best: Option<(f64, usize, [i32; 3])> = None;
+                let (lo, hi) = (a.min(b).floor(), a.max(b).floor());
+                for x in lo.x as i32..=hi.x as i32 {
+                    for y in lo.y as i32..=hi.y as i32 {
+                        for z in lo.z as i32..=hi.z as i32 {
+                            for bx in source.boxes(x, y, z) {
+                                let o = DVec3::new(f64::from(x), f64::from(y), f64::from(z));
+                                if let Some((t, axis)) = enter_box(a, d, o + DVec3::new(bx[0], bx[1], bx[2]), o + DVec3::new(bx[3], bx[4], bx[5]))
+                                    && best.is_none_or(|b| t < b.0)
+                                {
+                                    best = Some((t, axis, [x, y, z]));
+                                }
+                            }
+                        }
+                    }
+                }
+                match best {
+                    None => RayReply { id, clear: true, hit: false, fraction: 0.0, normal: [0; 3], block: [0; 3] },
+                    Some((t, axis, block)) => {
+                        let mut normal = [0; 3];
+                        if axis < 3 {
+                            normal[axis] = if d[axis] > 0.0 { -1 } else { 1 };
+                        }
+                        RayReply { id, clear: false, hit: true, fraction: t, normal, block }
+                    }
+                }
+            })
+            .collect();
+        self.answer_rays(&replies);
+    }
+
     /// Answers the questions of the last tick from a synthetic world, as the game does one tick later.
     pub fn serve(&mut self, source: &dyn WorldSource, wanted: Vec<Sec>, now: u64) {
         let answers = wanted.into_iter().map(|sec| SectionAnswer { sec, fill: section_of(source, sec) }).collect();
         self.answer(answers, now);
+        let rays = self.take_rays(now);
+        self.serve_rays(source, rays);
     }
 }

airdef-mod/src/smoke.rs

@@ -0,0 +1,179 @@
+//! Smoke for the HD renderer (`render.set-smoke`): exhaust trails of drones and missiles that leave
+//! a clear tunnel in fog and cloud, smoke columns over fires, and the smoke of blasts. The game
+//! derives everything from a segment's age, so the columns and blasts are a pure function of the
+//! tick (nothing grows twice when a frame is shown again); trails are the only state, and they are
+//! cut back when the tick goes backwards.
+use crate::sim::{Class, Sim};
+use glam::DVec3;
+use horizon_mod_sdk::render::SmokeSegment;
+use std::collections::HashMap;
+
+const MAX_TRAIL: usize = 2400;
+const MAX_TOTAL: usize = 4000;
+
+struct Trail {
+    seg: SmokeSegment,
+}
+
+#[derive(Default)]
+pub struct Smoke {
+    trails: Vec<Trail>,
+    /// Where each flying thing last left a segment: (kind, id) -> (position, tick).
+    last: HashMap<(u8, u32), (DVec3, u64)>,
+    last_tick: u64,
+    next: u32,
+    /// The renderer draws the smoke (the answer of the last call).
+    pub hd: bool,
+}
+
+fn seg(id: u32, a: DVec3, b: DVec3, born: u64, life: u32) -> SmokeSegment {
+    SmokeSegment {
+        id,
+        ax: a.x,
+        ay: a.y,
+        az: a.z,
+        bx: b.x,
+        by: b.y,
+        bz: b.z,
+        born: born as f64,
+        life: life as f32,
+        radius_start: 1.0,
+        radius_end: 6.0,
+        density: 0.5,
+        heat: 0.0,
+        soot: 0.4,
+        rise: 0.2,
+        clear: 0.0,
+    }
+}
+
+impl Smoke {
+    fn trail(&mut self, key: (u8, u32), at: DVec3, tick: u64, style: impl Fn(&mut SmokeSegment)) {
+        let Some(&(from, when)) = self.last.get(&key) else {
+            self.last.insert(key, (at, tick));
+            return;
+        };
+        if at.distance(from) < 5.0 && tick - when < 10 {
+            return;
+        }
+        // A jump (a teleport, a respawn) is no trail.
+        if at.distance(from) < 400.0 {
+            self.next = self.next.wrapping_add(1);
+            let mut s = seg(self.next, from, at, tick, 1200);
+            style(&mut s);
+            self.trails.push(Trail { seg: s });
+        }
+        self.last.insert(key, (at, tick));
+    }
+
+    /// Follows the simulation one tick: new trail segments for what flies, old ones dropped.
+    pub fn update(&mut self, sim: &Sim) {
+        let tick = sim.tick;
+        if tick < self.last_tick {
+            self.trails.retain(|t| t.seg.born as u64 <= tick);
+            self.last.clear();
+        }
+        self.last_tick = tick;
+        for d in &sim.drones {
+            let class = d.kind.spec().class;
+            let (r0, r1, dens, heat, soot, clear, life): (f32, f32, f32, f32, f32, f32, f32) = match class {
+                Class::Drone => (0.9, 5.0, 2.0, 0.0, 0.45, 3.0, 1200.0),
+                Class::Jet | Class::Cruise => (1.1, 7.0, 2.5, 0.15, 0.35, 4.0, 1300.0),
+                Class::Supersonic => (1.4, 9.0, 3.2, 0.5, 0.2, 5.0, 1300.0),
+                Class::Ballistic => (2.0, 13.0, 4.0, 0.7, 0.15, 7.0, 1500.0),
+            };
+            self.trail((0, d.id), d.pos, tick, |s| {
+                s.radius_start = r0;
+                s.radius_end = r1;
+                s.density = dens;
+                s.heat = heat;
+                s.soot = soot;
+                s.clear = clear;
+                s.life = life;
+            });
+        }
+        for m in &sim.missiles {
+            self.trail((1, m.id), m.pos, tick, |s| {
+                s.radius_start = 0.6;
+                s.radius_end = 5.0;
+                s.density = 3.0;
+                s.heat = 0.8;
+                s.soot = 0.05;
+                s.clear = 3.0;
+                s.life = 1000.0;
+            });
+        }
+        // Forget what is gone.
+        if tick % 100 == 0 {
+            let alive: std::collections::HashSet<(u8, u32)> = sim
+                .drones
+                .iter()
+                .map(|d| (0, d.id))
+                .chain(sim.missiles.iter().map(|m| (1, m.id)))
+                .collect();
+            self.last.retain(|k, _| alive.contains(k));
+        }
+        self.trails.retain(|t| tick < t.seg.born as u64 + t.seg.life as u64);
+        if self.trails.len() > MAX_TRAIL {
+            let cut = self.trails.len() - MAX_TRAIL;
+            self.trails.drain(..cut);
+        }
+    }
+
+    /// Every segment alive at the simulation's tick: trails, fire columns, blast smoke.
+    pub fn segments(&self, sim: &Sim) -> Vec<SmokeSegment> {
+        let tick = sim.tick;
+        let mut out: Vec<SmokeSegment> = self.trails.iter().map(|t| t.seg.clone()).collect();
+        // A column over each fire: a puff every 15 ticks that rises, spreads and thins.
+        for f in &sim.fires.list {
+            if f.quiet && f.size < 1.0 {
+                continue;
+            }
+            // Only the strongest fires get a full column; the rest a thin puff now and then.
+            let step = if f.shown { 15 } else { 90 };
+            let first = f.start.max(tick.saturating_sub(520));
+            let mut k = first.div_ceil(step) * step;
+            while k <= tick && out.len() < MAX_TOTAL {
+                let (flame, smoke) = f.level(k);
+                if smoke > 0.05 && k >= f.start {
+                    let id = 0x4000_0000 | (f.id.wrapping_mul(131) ^ (k / step) as u32) & 0x3fff_ffff;
+                    let at = f.at + DVec3::Y * 0.6;
+                    let mut s = seg(id, at, at, k, 540);
+                    s.radius_start = 1.0 * f.size;
+                    s.radius_end = 8.0 * f.size + 2.0;
+                    s.density = 2.6 * smoke * f.size.sqrt() * if f.shown { 1.0 } else { 0.5 };
+                    s.heat = flame * 0.6;
+                    s.soot = 0.85;
+                    s.rise = 2.6;
+                    out.push(s);
+                }
+                k += step;
+            }
+        }
+        // Blasts: a billow of puffs going up.
+        for b in &sim.blasts {
+            let age = tick.saturating_sub(b.start);
+            if age > 900 {
+                continue;
+            }
+            for j in 0..6u64 {
+                let born = b.start + j * 3;
+                if born > tick {
+                    break;
+                }
+                let h = b.size as f64 * (0.2 + 0.5 * j as f64);
+                let at = b.at + DVec3::Y * h;
+                let mut s = seg(0x5000_0000 | (b.id.wrapping_mul(7) + j as u32) & 0x0fff_ffff, at, at, born, 800);
+                s.radius_start = b.size * 0.6;
+                s.radius_end = b.size * 3.2 + 4.0;
+                s.density = 2.4 / (1.0 + j as f32 * 0.25);
+                s.heat = if j < 3 { 1.0 } else { 0.4 };
+                s.soot = 0.55;
+                s.rise = 4.0 - 0.3 * j as f32;
+                out.push(s);
+            }
+        }
+        out.truncate(MAX_TOTAL);
+        out
+    }
+}

docs/HD-RENDERER.md

@@ -19,12 +19,17 @@ Horizon действует правило clean-room. Исключение — P
 
 | Что | Где |
 |---|---|
-| Весь HD-конвейер: цели, проходы, WGSL-шейдеры (строками), тайлы света, AO, тени, bloom, tonemap, TAA | `horizon/crates/horizon-client/src/gfx/hd.rs` |
-| Объёмные облака (рэймарч слоя, тени облаков на землю) и объёмный туман (лучи света через тени каскадов), их цели и проходы; CPU-шум (2D, 3D Worley) | `horizon/crates/horizon-client/src/gfx/hd_volumes.rs`, `hd_noise.rs` |
-| Атмосфера: сборка текстуры неба (WGSL), чтение неба/дымки/тона света в шейдерах, цвет солнца (`sun_transmittance`) | `horizon/crates/horizon-client/src/gfx/hd_sky.rs` (+ `THIRD_PARTY_PHOTON.md`) |
+| Оркестровка HD: `Hd`, общие цели, буфер кадра, `resize`/`write`, сборка шейдеров (`assemble`: прелюдия + тело), контракты цвета/глубины/альф/времени (комментарий в начале файла) | `horizon/crates/horizon-client/src/gfx/hd/mod.rs` |
+| Униформ кадра `HdFrame` (Rust) и сцена `HdScene`/`HdLight`/`HdSettings`, свет солнца/луны/облаков (`light_of`, `cloud_light`); общая WGSL-прелюдия (`HdFrame`, `FullOut`, `vs_full`) | `gfx/hd/frame.rs`, `gfx/hd/prelude.wgsl` |
+| Тени (каскады, `Shadows`, `cascades()`); G-буфер (`GBuffer`, форматы) | `gfx/hd/shadows.rs`; `gfx/hd/gbuffer.rs` |
+| AO (GTAO + блюр); освещение `fs_light` (+ тайлы источников: `tiles.rs`); вода (проход геометрии и композит) | `gfx/hd/ao.rs` + `ao.wgsl`, `ao_blur.wgsl`; `gfx/hd/lighting.rs` + `light.wgsl`, `gfx/hd/tiles.rs`; `gfx/hd/water.rs` + `water.wgsl` |
+| TAA/TAAU и джиттер; bloom; tonemap (+ `Hd::finish`) | `gfx/hd/taa.rs` + `taa.wgsl`; `gfx/hd/bloom.rs` + `bloom.wgsl`; `gfx/hd/tonemap.rs` + `tonemap.wgsl` |
+| Объёмные облака (рэймарч слоя, тени облаков на землю) и объёмный туман, их цели и проходы; CPU-шум (2D, 3D Worley) | `gfx/hd/volumes.rs` + `cloud_common.wgsl`, `cloud.wgsl`, `cloud_shadow.wgsl`, `fog.wgsl`; `gfx/hd/noise.rs` |
+| Атмосфера: сборка текстуры неба (WGSL), чтение неба/дымки/тона света в шейдерах, цвет солнца (`sun_transmittance`) | `gfx/hd/sky.rs` + `sky.wgsl`, `sky_funcs.wgsl` (+ `THIRD_PARTY_PHOTON.md`) |
 | Встраивание в кадр: G-буфер-проход, каскады теней, вызовы `hd.light` / `hd.finish`, джиттер, тайминги | `horizon/crates/horizon-client/src/gfx.rs` (`Renderer::render`, ищи `hd_on`, `AirDef fork:`) |
 | G-буфер террейна: `fs_gbuffer`, `fs_shadow` | `horizon/crates/horizon-client/src/terrain.wgsl` |
 | G-буфер сущностей и моделей мода: `fs_entity_gbuffer`, `fs_entity_shadow` | `horizon/crates/horizon-client/src/entity.wgsl` |
+| Материалы (классы спрайтов: листва, растения, металл, полированное), ветер, мокрые поверхности | `gfx/hd/materials.rs`; `terrain.wgsl` (`terrain_vertex`/`wind_offset`, `material_params`), `entity.wgsl`, `gfx/hd/light.wgsl` (`shade_surface`) |
 | Пост-проход мода (взрывы, дым, вспышки, свечение) и его прелюдия | `airdef-mod/shaders/effects.wgsl`, прелюдия в `horizon/.../gfx/mod_post.rs` |
 | Источники света мода (пламя, ракеты, взрывы, прожекторы) | `airdef-mod/src/lib.rs`, `fn lights` |
 | API мода: `render.set-lights`, `render.set-lighting` (уровень API 10) | `horizon/crates/horizon-mod-sdk/wit/horizon.wit`, `horizon/crates/horizon-mods/src/runtime.rs` |
@@ -120,6 +125,28 @@ Bind groups кэшируются и пересоздаются только пр
 
 Композит воды (`WATER`, group 0): 0 `HdFrame`, 1 `lit`, 2 глубина G-буфера, 3 цвет воды, 4 нормаль воды, 5 глубина воды, 6–7 тени, 8 лайтмап, 9 сэмплер, 10 текстура неба. Проход неба (`SKY_PASS`, group 0): только `HdFrame`.
 
+## Контракты (цвет, глубина, альфа, время)
+
+Полная таблица «проход: что читает → что пишет» — в начале `gfx/hd/mod.rs`, подробности — в начале файла каждого прохода.
+
+- **Цвет.** От освещения до tonemap всё в «показанном» пространстве ванили (гамма, основные цвета Rec. 709), значения могут быть > 1
+  (`Rgba16Float`); tonemap не трогает ≤ 0.8. Исключения: текстура неба — линейная яркость Rec. 709 (марш в Rec. 2020; показывают
+  читатели через `sky_show`); albedo G-буфера — `Rgba8Unorm` в том же показанном пространстве.
+- **Глубина.** Камера: reversed-Z, `Depth32Float`, 1 — близко, 0 — далеко/ничего (очистка в 0; глубина воды 0 — воды нет). Тени:
+  обычная Z ортопроекции света (0 — у света, 1 — далеко), сравнение `<=`.
+- **Альфа.** albedo.a — эмиссия (свет добавляет `rgb·a·1.5`); `lit.a`: 1 — обычный пиксель, 0.5 — вода (в rgb дно без воздуха),
+  0.6 — прозрачное перед водой; `air.a` — пропускание воздуха; облака и туман: `a` — пропускание (`c·a + rgb`); вода: цвет.a —
+  свет блоков, нормаль.a — свет неба; история TAA: a — дистанция; AO: x — окклюзия, y — дистанция.
+- **Координаты.** Позиции относительно камеры; для узоров (волны, шум облаков, ветер) мировая координата передаётся по модулю периода
+  (256, 65536). Мировая проекция с джиттером; `prev_view_proj` — с джиттером для `fs_taa` и без для `fs_taau` (выбирает `Hd::write`).
+- **Время.** Три разных часа: счётчик кадров (`params.w`, mod 64, вращение шума), время воды (`water.y`, секунды стенных часов mod 600),
+  игровое время (`clouds.w`, секунды `HdScene.seconds` mod 300000, ветер облаков). Реплей, замораживающий игровое время, не
+  останавливает воду.
+- **Истории.** Две цели TAA и две цели облаков принадлежат своим проходам, создаются в `resize`, сбрасываются при resize, телепорте
+  (> 64 блоков), выключенном TAA; один `Hd` обслуживает одну камеру, истории разных камер не смешиваются.
+- **Размеры.** world — масштабированная цель мира (G-буфер, AO ½, свет, вода, облака/туман ½), out — окно (TAA, bloom, tonemap).
+- **Bind groups** кэшируются по видам, которые читают; пересоздаются при resize и смене входного вида; нет роста в установившемся кадре.
+
 ## Как проверять
 
 ```bash
@@ -129,8 +156,10 @@ cargo test -p horizon-client --lib hd        # naga-разбор всех HD-ш
 cd ../airdef-mod && cargo horizon-mod build && cargo test                    # мод и его шейдер
 ```
 
-WGSL-ошибки в `hd.rs` всплывают только в рантайме — поэтому каждый новый шейдер добавляй в naga-тест
-`lighting_shader_parses`.
+WGSL-ошибки всплывают только в рантайме — поэтому каждый новый шейдер добавляй в список `shaders()` в тестах
+`gfx/hd/mod.rs`: `lighting_shader_parses` (naga-разбор каждого итогового шейдера), `every_wgsl_file_is_tested` (каждый `.wgsl`
+входит в проверенный шейдер), `bindings_match_the_layouts` (привязки WGSL = `*_BINDINGS` в Rust: номера, виды, размерности),
+`frame_layout_matches_the_prelude` (поля и размер `HdFrame` в Rust и в прелюдии).
 
 Игра офскрин (только одна копия за раз; данные в `run-home/`, мир `Polygon`):
 
@@ -158,7 +187,10 @@ TAAU (2560×1440, GPU avg кадр, сцена Polygon): scale 1.0 — 18.1 мс
 Графический полигон: `python3 tools/hd_bench.py` (`--list` — сцены; `--only polygon_noon` — одна сцена; `--env
 HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off` — A/B; `--baseline run-home-bench/out/before` — diff ×6 и
 пороги; `--budget-ms 18` — GPU-бюджет). Сам копирует `Polygon`/`Hills` в `run-home-bench/home`, сокет
-`run-home-bench/c.sock`, одна игра за раз; отчёт `report.md` с таблицей, проходами GPU и кадрами.
+`run-home-bench/c.sock`, одна игра за раз; отчёт `report.md` с таблицей, проходами GPU и кадрами. Время и погода
+заморожены (`gamerule advance_time/advance_weather false`); вода и листва идут по часам стены, поэтому кадры сравниваются
+по статичным пикселям: 3 кадра подряд, пиксели с размахом > 16/255 (вода, облака, листва) не участвуют в сравнении с базой
+и в мерцании (маска `<сцена>_motion.png`); `--no-freeze` — живой замер производительности; `--help` — все пороги.
 
 Отладка: временно выводи промежуточные величины цветом в `fs_light` (так нашли пустую карту теней и неверное
 направление солнца). Помни: солнце в мире идёт по оси X (`(-sin a, cos a, 0)`), а `Globals.sun` неба — в своей
@@ -190,11 +222,16 @@ HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off` — A/B; `--baseline run-home
 | #35: ванильные облака (HD-облака выключены) красятся закатным цветом в собственном проходе (`hd::vanilla_cloud_tint` → цвет в `clouds::Input`), эвристика по глубине G-буфера убрана из `fs_light` | готово | в рабочем дереве форка |
 | #37: воздух (ванильный туман, aerial, объёмный туман, лучи, ореолы) на воде считается до **поверхности** и кладётся один раз поверх готовой воды: `fs_light` пишет во вторую цель `air` (рассеяние + пропускание), `fs_water` применяет её после поглощения | готово | в рабочем дереве форка |
 | #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`) | готово | в рабочем дереве форка |
 | #39: веер восхода `vanilla_sunrise_weight` отсекается до цикла по 16 треугольникам выше горизонта (знак x стороны солнца и наклон ≤ α/3; проверено перебором 200 тыс. лучей без пропусков); `hd lighting` на рассвете 5.3 → 3.3 мс (M-серия, 2560×1440) | готово | в рабочем дереве форка |
 
+| Материалы и блики (план 5): G-буфер `levels.zw` = шероховатость, металличность; GGX-блик солнца с Френелем и отражение неба (`sky_along`/`atmosphere_sky`) в `shade_surface`; мокрые поверхности и лужи в дождь (`HdFrame.surface`); `HORIZON_HD_SPECULAR=0` — выкл. | готово | в рабочем дереве форка |
+| Ветер (план 7): листва и растения качаются в вершинной стадии террейна (`Globals.hd_wind`, `hd_materials`), те же смещения в тенях; `HORIZON_HD_WIND=0` — выкл. | готово | в рабочем дереве форка |
+| Объёмный дым и следы ракет (#54, п. 8 плана): API уровня 14 `render.set-smoke`, сетка дыма 128×64×128 по 3 блока (`gfx/hd/smoke.rs`, `smoke_grid.wgsl`), марш в проходе тумана, «туннель» в тумане и облаках, `HORIZON_HD_SMOKE=0`; мод: `airdef-mod/src/smoke.rs` (следы дронов и ракет, колонны над пожарами, дым взрывов) | готово, в рабочем дереве форка; вид не настраивался (см. «Дым и следы») | не закоммичено |
+
 ## План (по порядку) и ТЗ
 
-Каждый пункт — самостоятельная задача. Перед началом прочитай `hd.rs` целиком.
+Каждый пункт — самостоятельная задача. Перед началом прочитай `gfx/hd/mod.rs` (контракты) и файл нужного прохода.
 
 1. **TAAU — временной апскейлер** (поверх TAA) — СДЕЛАНО (патч 18, см. статус; масштаб — `HORIZON_HD_SCALE`, переопределяет «масштаб разрешения» настроек Horizon только для HD; поля в `HdSettings` нет). Осталось: LOD-bias текстур террейна, MetalFX. Исходное ТЗ: Мир и G-буфер рендерятся в `render_scale` (например 0.67),
    TAA-проход восстанавливает полное разрешение: история в полном разрешении, текущий кадр семплируется с учётом
@@ -209,10 +246,10 @@ HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off` — A/B; `--baseline run-home
    текстуре), солнце/луна дисками, звёзды из ванили; туман и лучи берут цвет из той же модели. Учесть дождь
    (`weather`), закат, Незер/Энд (там — ванильное небо).
 4. **Объёмные облака** — СДЕЛАНО (патч 24, см. «Закат, облака и туман»). Осталось: перистые/высококучевые слои Photon, облака в отражении воды.
-5. **Блики и материалы**: specular солнца для металла техники (маска по оверлею/альбедо или атрибут модели из
+5. **Блики и материалы** — СДЕЛАНО (см. «Материалы, мокрое, ветер»). Исходное ТЗ: specular солнца для металла техники (маска по оверлею/альбедо или атрибут модели из
    мода), мокрые поверхности и лужи в дождь.
 6. **PCSS** (мягкость тени по расстоянию до тенеотбрасывателя) и цветные тени через стекло/листву.
-7. **Ветер** листвы/травы (вершинный шейдер террейна по типу блока), рябь от дождя.
+7. **Ветер** — СДЕЛАНО (рябь от дождя на воде осталась). Исходное ТЗ: листвы/травы (вершинный шейдер террейна по типу блока), рябь от дождя.
 8. **Объёмный дым** пожаров и взрывов, принимающий свет и тени (сейчас дым — в `effects.wgsl`, без теней).
 9. Опционально: motion blur, DoF (для кинокамеры повторов).
 10. **RT-пресет**: `wgpu` `EXPERIMENTAL_RAY_QUERY` (Vulkan/DX12/Metal M3+), BLAS по секциям, ray-query тени и
@@ -266,7 +303,7 @@ HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off` — A/B; `--baseline run-home
 - **Облака (24).** Слой 192.33…264.33 блока (`CLOUD_BASE/CLOUD_THICKNESS`), ветер 3 блока/с (`CLOUD_WIND`), шум — текстуры, сгенерированные на CPU при создании HD (`hd_noise.rs`: 2D 256² покрытие/форма, 3D 64³ Worley). Плотность — по `clouds_cumulus_density` Photon (порог покрытия × форма, «яйцо» по высоте, эрозия Worley, резкий верх), рассеяние — `clouds_cumulus_scattering` (октавы, пудра, фазы). Цвет света — `cloud_light` (Rust): пропускание атмосферы на высоте солнца; солнце светит облакам до −0.2 по высоте, дальше луна. Воздушная перспектива `exp(−d/3600)` к цвету дымки. История сбрасывается при resize, телепорте и без TAA. Опция ванильных облаков «выкл» → `frame.clouds` пуст → нет ни облаков, ни теней. Тень: `cloud_shadow` в `fs_light` (карта оптической толщины; гаснет при солнце ниже ~0.1–0.25 по высоте).
 - **Туман (25).** `fs_fog`: 18 шагов, плотность `fog_sigma` (высотная дымка от y=62, масштаб 42; утренний туман — пока солнце на «утренней» стороне и низко; пятна из 3D-шума; дождь; затухание ниже y≈28–58, чтобы не светить в пещерах), свет — Photon-смесь двух HG, «вечернее свечение» ×1…3. Старые 14 шагов лучей остаются при `HORIZON_HD_VOLFOG=0`; ореолы вокруг источников мода — всегда.
 - **Тайминги.** Метки Metal (`HORIZON_SHADER_PACK_TIMING=1`, Hills, 2560×1440): `hd clouds` ≈ 6 мс (завышено: метка ловит ожидание соседних проходов), `hd cloud shadows` 0.2–3 (шум), `hd fog` ≈ 1.3. По среднему кадру GPU «оба выкл → оба вкл»: +0.2…3.7 мс (замеры шумные: рядом шла чужая игра на том же GPU). Как удешевить: у облаков — длина шага (14) и потолок шагов (26) в `fs_cloud`, 3 шага света, 4 октавы, облака в четверть разрешения; у тумана — `FOG_STEPS`.
-- **Разработка шейдеров.** `HORIZON_HD_SHADER_DIR=<папка>`: каждый HD-шейдер читается из `<папка>/<метка>.wgsl` (записывается из встроенного, если файла нет) — правки видны после перезапуска игры без пересборки; готовое переносится в константы вручную.
+- **Разработка шейдеров.** `HORIZON_HD_SHADER_DIR=<папка>`: каждый HD-шейдер читается из `<папка>/<метка>.wgsl` (записывается из встроенного, если файла нет; это тело без прелюдии, она добавляется всегда) — правки видны после перезапуска игры без пересборки; готовое переносится в `gfx/hd/*.wgsl` вручную.
 - **Слабые места.** Облака не отражаются в воде (SSR берёт небо без облаков); не закрывают далёкую землю выше слоя (только небо); карта теней облаков ±1200 блоков и почти не работает при солнце ниже ~10°; туман не знает рельефа (только высоту над y=62); нет перистых облаков; на быстром повороте камеры история облаков отбрасывается (кратковременный шум).
 
 ## Заметки по исправлениям #35–#41 (преемнику)
@@ -275,3 +312,19 @@ HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off` — A/B; `--baseline run-home
 - **Ванильная вода в HD.** Пока `hd.water_active()`, `fs_translucent` не рисует цвет воды (альфа 0), но пишет её глубину; флаг — `Globals.hd_flags.x` (поле добавлено в Rust-`Globals`, `terrain.wgsl`, `entity.wgsl`; пишется после `hd.write` и в `hd.main_globals`). Вода без дна (`g = 0`) считается водой толщиной 48.
 - **Не сделано.** Полупрозрачное перед водой берёт вес 0.7 на «вклад воды» (приближение: настоящий порядок «вода → прозрачное» потребовал бы разделить проход сцены). Частицы перед водой, `HORIZON_HD_SCALE=0.67`, поиск мерцания на рябь после этих правок не прогонялись.
 - **`HORIZON_HD_TAA=0`.** На Polygon в полдень (`tp @s 40 76 40 135 15`) HD с выключенным TAA выглядит так же (дымка, небо, тени на месте), GPU 16.5 мс против 18.1 мс с TAA (минус ≈ проход TAA); потери вида и падения до 4.8 мс не воспроизвелись. В коде `HORIZON_HD_TAA` читают только `taa_enabled()` (джиттер, проход `taa`, история), остальные проходы от него не зависят. Если проявится снова — проверь, что до шота прошёл `/airdef shader hd` (при неготовой команде кадр без HD ~5 мс).
+
+## Материалы, мокрое, ветер: что знать преемнику
+
+- **Класс спрайта.** `gfx/hd/materials.rs` по имени спрайта (`minecraft:block/<имя>`) даёт класс 0..8 (обычный, листва, растение, нижняя/верхняя половина двойного растения, металл, гладкое, глянец, дерево). Таблица — по 4 бита на слой, первые 2048 слоёв (`Globals.hd_materials`, 64 × `vec4<u32>`, считается в `game.rs` и кладётся в `Renderer`); спрайты модов дальше 2048 — обычные. Числа `MAT_*` в `terrain.wgsl` держать в синхроне. Добавить блок в класс — список имён в `classify`.
+- **G-буфер.** `levels.zw` (было не занято) = шероховатость и металличность (`material_params` в `terrain.wgsl`; для сущностей — по оверлею в `fs_entity_gbuffer`: обычные 0.9/0; модели мода `41` — крашеный металл 0.42/0.3 (по умолчанию для всех моделей мода, `game/mod_models.rs`), `42` — голый металл 0.28/1 (мод пока не умеет выбирать), `40` — свечение 0.5/0). Вода своим проходом, без материала.
+- **Блик.** В `shade_surface` (`light.wgsl`): GGX (α = rough², не ниже 0.03) × Смит × Френель Шлика, у шероховатых Френель почти не растёт (`max(gloss, F0)`); цвет — солнце × тень × `sky_reach`; потолок 6. Отражение неба: `atmosphere_sky(reflect)` × Френель × gloss² × доступ к небесному свету × AO, без SSR на террейне. Металл сохраняет 35% диффузного (карты окружения нет). Дно под водой блеск не получает.
+- **Мокро.** `HdFrame.surface.x` — влажность 0..1 (CPU, `Hd::wetness`): растёт за ~15 с дождя к уровню дождя мира, сохнет ~150 с. Под открытым небом (`lm.x` > 0.8) поверхности темнеют до ×0.7 (боковые грани слабее) и их шероховатость падает к 0.12; лужи — на плоских гранях вверх, по 2-октавному value-шуму в мировых координатах (`wet_noise`, период 256 блоков), с влажности ~0.3, альбедо ×0.6 и шероховатость 0.03, отражают небо.
+- **Ветер.** `terrain_vertex` смещает вершины листвы (±0.04 блока, непрерывно по мировой позиции, чтобы блоки не расходились) и растений (до 0.14 блока вверху спрайта; низ — по `uv.y`; двойные растения стыкуются на середине). Волны — целые циклы на 256 блоков и 600 секунд (как у воды). Данные ветра — в `Globals.hd_wind` (сила 1 + 1.2·дождь, секунды, камера mod 256); они же в глобалах каскадов теней, поэтому смещение одно и то же во всех проходах (ванильный, G-буфер, тени, глубина совпадают). Вне HD сила 0 — вершинный шейдер не меняется. TAA не знает о движении листвы (малые амплитуды).
+- **Переключатели.** `HORIZON_HD_WIND=0`, `HORIZON_HD_SPECULAR=0` (блик, отражения и мокрое).
+
+## Проверка материалов/мокрого/ветра (что видно и что нет)
+
+- Увидено в игре (Hills, `run-home-bench/out/mat1`, `out/rain`): ветер работает, листва и трава двигаются, артефактов швов нет; в дождь сцена заметно темнее (мокрое), небо серое. Не проверено глазами: блики на технике (в Polygon сцена бенча сейчас без техники, не сопоставима с базой `before-mat`), отдельные лужи (кадр дождя смотрит в небо), высыхание (`out/rain/drying_30s.png` снят, не разобран), ночь.
+- Мерцание: `hills_river_noon` 9% без ветра (`out/nowind`) против 31% с ветром — это движение листвы вблизи камеры, не шум; амплитуда листвы снижена с 0.04 до 0.025 после этого замера (повторно не мерилось).
+- Тайминги **не сняты**: параллельно шли игры других агентов (числа 25–155 мс недействительны). Перед замером брать `run-home/.gpu-lock`.
+- Известно: `shaders_translate_to_hlsl_for_directx_12` падает на `cloud.wgsl` (не мой файл).

horizon-patches/0001-Mod-API-AirDef-fork-world-models-client-particles-so.patch

@@ -1,7 +1,7 @@
 From 3de7a6875140a107e28563cc44489b55f5794517 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Wed, 28 Oct 2026 12:37:45 +0300
-Subject: [PATCH 01/25] Mod API (AirDef fork): world models, client particles,
+Subject: [PATCH 01/28] Mod API (AirDef fork): world models, client particles,
  sounds, ground heights
 
 render.set-models draws block models with an interpolated pose per id;

horizon-patches/0002-cargo-horizon-mod-report-particles-and-sounds.patch

@@ -1,7 +1,7 @@
 From a6d64e6415bf618539af464e521091e72b72d72f Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Wed, 28 Oct 2026 12:39:45 +0300
-Subject: [PATCH 02/25] cargo-horizon-mod: report particles and sounds
+Subject: [PATCH 02/28] cargo-horizon-mod: report particles and sounds
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
 ---

horizon-patches/0003-Mod-API-AirDef-fork-full-screen-post-pass-for-mods.patch

@@ -1,7 +1,7 @@
 From ee79b3562feebe51959a01f1585a9e85bd53ccb5 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Wed, 28 Oct 2026 13:33:10 +0300
-Subject: [PATCH 03/25] Mod API (AirDef fork): full-screen post pass for mods
+Subject: [PATCH 03/28] Mod API (AirDef fork): full-screen post pass for mods
 
 render.set-post compiles a mod's WGSL after a prelude (camera matrices,
 time, 256 vec4 of params, the world's colour and depth) and runs it after

horizon-patches/0004-Mod-models-draw-far-models-as-scaled-impostors-past-.patch

@@ -1,7 +1,7 @@
 From 2b137dbbedd540daeebc7f5e387847aeb56a1355 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Wed, 28 Oct 2026 22:09:30 +0300
-Subject: [PATCH 04/25] Mod models: draw far models as scaled impostors past
+Subject: [PATCH 04/28] Mod models: draw far models as scaled impostors past
  the far plane, cull at 4096
 
 ---

horizon-patches/0005-Mod-cameras-render.set-views-draws-the-world-from-ot.patch

@@ -1,7 +1,7 @@
 From c8ebca6e0af68630e65211844b34d25c5b985c03 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Wed, 28 Oct 2026 22:31:00 +0300
-Subject: [PATCH 05/25] Mod cameras: render.set-views draws the world from
+Subject: [PATCH 05/28] Mod cameras: render.set-views draws the world from
  other points into pictures that HUD view shapes show (API level 9)
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0006-Mods-more-fuel-per-tick-and-per-event-AirDef-plans-r.patch

@@ -1,7 +1,7 @@
 From 8d2261fc4f8072c32e454139cfea7a8c0cd9d664 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Wed, 28 Oct 2026 23:08:21 +0300
-Subject: [PATCH 06/25] Mods: more fuel per tick and per event (AirDef plans
+Subject: [PATCH 06/28] Mods: more fuel per tick and per event (AirDef plans
  raids)
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0007-Mod-cameras-up-to-1920x1080-full-screen-replays.patch

@@ -1,7 +1,7 @@
 From 6c548de34def8e4a624d734243418090798bd16a Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Wed, 28 Oct 2026 23:25:29 +0300
-Subject: [PATCH 07/25] Mod cameras up to 1920x1080 (full-screen replays)
+Subject: [PATCH 07/28] Mod cameras up to 1920x1080 (full-screen replays)
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
 ---

horizon-patches/0008-Mod-cameras-distant-terrain-tiles-fog-measured-from-.patch

@@ -1,7 +1,7 @@
 From 9b9e93269d67401cc620567a884d5ce97f68d76e Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 11:15:11 +0300
-Subject: [PATCH 08/25] Mod cameras: distant terrain tiles, fog measured from
+Subject: [PATCH 08/28] Mod cameras: distant terrain tiles, fog measured from
  the camera, no impostors while one is shown
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0009-Mods-game.world-id-so-mods-keep-state-per-world-API-.patch

@@ -1,7 +1,7 @@
 From 065d9fa02966238a5bd9ff460392a1a809db0b11 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 11:25:45 +0300
-Subject: [PATCH 09/25] Mods: game.world-id, so mods keep state per world (API
+Subject: [PATCH 09/28] Mods: game.world-id, so mods keep state per world (API
  level 9)
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0010-cargo-horizon-mod-trial-runs-behind-feature-full-so-.patch

@@ -1,7 +1,7 @@
 From 1bf28135fd9a31f837323dc3a8d81ed73343d816 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 12:01:08 +0300
-Subject: [PATCH 10/25] cargo-horizon-mod: trial runs behind feature full, so a
+Subject: [PATCH 10/28] cargo-horizon-mod: trial runs behind feature full, so a
  packing-only tool skips wasmtime
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0011-HD-lighting-G-buffer-pass-per-pixel-mod-point-lights.patch

@@ -1,7 +1,7 @@
 From 0a56f5616df4699588cbcc529d4720661baa810f Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 13:18:43 +0300
-Subject: [PATCH 11/25] HD lighting: G-buffer pass, per-pixel mod point lights
+Subject: [PATCH 11/28] HD lighting: G-buffer pass, per-pixel mod point lights
  in HDR, bloom and tone curve; render.set-lights and render.set-lighting (API
  level 10)
 

horizon-patches/0012-HD-lighting-stage-2-sun-and-moon-shadow-cascades-the.patch

@@ -1,7 +1,7 @@
 From 9ebf0031fe9ba6b7f02afb26e4fd3a1ba4ddb0d0 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 13:59:43 +0300
-Subject: [PATCH 12/25] HD lighting stage 2: sun and moon shadow cascades, the
+Subject: [PATCH 12/28] HD lighting stage 2: sun and moon shadow cascades, the
  world relit (sun by face angle and shadow, sky and block light through the
  lightmap), light shafts and halos, fog over it again, a light colour grade
 

horizon-patches/0013-HD-bind-groups-cached-until-a-resize-or-a-new-source.patch

@@ -1,7 +1,7 @@
 From 7a5a38f68923aec62f10bfa0df50b436474ed612 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 16:19:53 +0300
-Subject: [PATCH 13/25] HD: bind groups cached until a resize or a new source,
+Subject: [PATCH 13/28] HD: bind groups cached until a resize or a new source,
  shadow passes draw only the entities that cast shadows
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0014-HD-lights-culled-per-16x16-tile-surface-and-halo-lis.patch

@@ -1,7 +1,7 @@
 From 8020811e57d4b5a9ea1cd72d30ce859dc5095d35 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 16:25:44 +0300
-Subject: [PATCH 14/25] HD: lights culled per 16x16 tile (surface and halo
+Subject: [PATCH 14/28] HD: lights culled per 16x16 tile (surface and halo
  lists built on the CPU), a naga test for the lighting shaders
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0015-HD-GPU-time-per-pass-in-the-F3-timing-list-half-reso.patch

@@ -1,7 +1,7 @@
 From 72d3fddfea329e578162656151350f0aa2efd323 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 16:43:36 +0300
-Subject: [PATCH 15/25] HD: GPU time per pass in the F3 timing list,
+Subject: [PATCH 15/28] HD: GPU time per pass in the F3 timing list,
  half-resolution GTAO with a depth-aware blur
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0016-HD-shadows-draw-only-sun-facing-quads-and-skip-burie.patch

@@ -1,7 +1,7 @@
 From 1fd83a821bf270879d8ece5aa583f200ed920d89 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 17:02:02 +0300
-Subject: [PATCH 16/25] HD: shadows draw only sun-facing quads and skip buried
+Subject: [PATCH 16/28] HD: shadows draw only sun-facing quads and skip buried
  sections, the far cascade every second frame; TAA (Halton jitter,
  reprojection by depth, YCoCg variance clipping) before bloom
 

horizon-patches/0017-Mods-model-handles-render.model-id-model-generation-.patch

@@ -1,7 +1,7 @@
 From 1502d359d599228fe0f44ce6b99a3fded2ac5ea0 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 17:02:02 +0300
-Subject: [PATCH 17/25] Mods: model handles (render.model-id, model-generation,
+Subject: [PATCH 17/28] Mods: model handles (render.model-id, model-generation,
  set-models-by-id; API level 11) so mods send no model names each tick;
  clear-post and set-lighting documented
 

horizon-patches/0018-HD-temporal-upscaling-HORIZON_HD_SCALE-world-G-buffe.patch

@@ -1,7 +1,7 @@
 From 0f9d99b8ad3e4b72e621d84c2396cf1d3d2b7a33 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 17:19:57 +0300
-Subject: [PATCH 18/25] HD: temporal upscaling (HORIZON_HD_SCALE: world,
+Subject: [PATCH 18/28] HD: temporal upscaling (HORIZON_HD_SCALE: world,
  G-buffer and lighting at a lower size, rebuilt to the window in the TAA
  pass); fix flickering shadows near the player (the near cascade lost its
  sections on frames the far one was held, the held far matrix ignored the

horizon-patches/0019-HD-water-its-own-pass-colour-normal-depth-the-floor-.patch

@@ -1,7 +1,7 @@
 From 38250c4392e27d5700842ca6ee47291dd1831b72 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 17:47:52 +0300
-Subject: [PATCH 19/25] HD water: its own pass (colour, normal, depth), the
+Subject: [PATCH 19/28] HD water: its own pass (colour, normal, depth), the
  floor under it lit, a composite with world-space waves, refraction with depth
  absorption in the biome colour, screen-space reflections, Fresnel and a
  shadowed sun glint (HORIZON_HD_WATER=0 to switch off)

horizon-patches/0020-HD-water-no-vanilla-texture-on-the-surface-the-biome.patch

@@ -1,7 +1,7 @@
 From dbc6f8a6e9c2eeabe1de15f1794013c90be7faa5 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 17:56:04 +0300
-Subject: [PATCH 20/25] HD water: no vanilla texture on the surface (the biome
+Subject: [PATCH 20/28] HD water: no vanilla texture on the surface (the biome
  colour only), a darker, deeper colour
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0021-HD-sky-and-light-a-physical-atmosphere-Rayleigh-Mie-.patch

@@ -1,7 +1,7 @@
 From 13e74537dd6e63482e3613e0e416de1158944dfe Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 18:38:19 +0300
-Subject: [PATCH 21/25] HD sky and light: a physical atmosphere (Rayleigh, Mie,
+Subject: [PATCH 21/28] HD sky and light: a physical atmosphere (Rayleigh, Mie,
  ozone; constants and transmittance after Photon, MIT) for the sky, haze, fog
  and water reflections; warmer sunlight from the atmosphere's transmittance, a
  gentle sky-coloured ambient, soft PCSS-lite shadows near the player, a haze

horizon-patches/0022-HD-water-a-darker-blue-a-little-clearer-ripples-a-li.patch

@@ -1,7 +1,7 @@
 From 6277e051a89c2537570982f6ef275887193c05cf Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 19:02:16 +0300
-Subject: [PATCH 22/25] HD water: a darker blue, a little clearer, ripples a
+Subject: [PATCH 22/28] HD water: a darker blue, a little clearer, ripples a
  little higher
 
 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

horizon-patches/0023-HD-Photon-style-sunsets-Rec.-2020-atmosphere-sun-tin.patch

@@ -1,7 +1,7 @@
 From 982265d21bb9d74ec0040db03feb5a55762286ad Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 21:41:48 +0300
-Subject: [PATCH 23/25] HD: Photon-style sunsets (Rec. 2020 atmosphere, sun
+Subject: [PATCH 23/28] HD: Photon-style sunsets (Rec. 2020 atmosphere, sun
  tint, blue hour; MIT), volumetric clouds with ground shadows instead of
  vanilla's in HD, volumetric fog with sun shafts and morning mist
  (HORIZON_HD_CLOUDS=0, HORIZON_HD_VOLFOG=0)

horizon-patches/0024-Mods-world-queries-for-simulations-render.query-rays.patch

@@ -1,7 +1,7 @@
 From 24971b3c67d8c87673eb2e0d204cedf8a2f46d1c Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 21:43:22 +0300
-Subject: [PATCH 24/25] Mods: world queries for simulations (render.query-rays,
+Subject: [PATCH 24/28] Mods: world queries for simulations (render.query-rays,
  query-sections, world-changes; API level 12): block-exact rays and section
  occupancy by collision, sight or sound, answered next tick within budgets,
  and a log of changed sections

horizon-patches/0025-HD-fixes-rain-level-from-the-world-not-from-rain-geo.patch

@@ -1,7 +1,7 @@
 From fdec4960983bdff82f3793460f9a5234f0cd3f49 Mon Sep 17 00:00:00 2001
 From: chexit <chexit@duck.com>
 Date: Thu, 29 Oct 2026 22:56:15 +0300
-Subject: [PATCH 25/25] HD fixes: rain level from the world not from rain
+Subject: [PATCH 25/28] HD fixes: rain level from the world not from rain
  geometry (#41), TAA history on the jittered grid (#38), vanilla cloud tint
  without a depth heuristic (#35), air fog once over water (#37), translucent
  things in front of HD water (#36), cheaper sunrise fan (#39), halos in thick

horizon-patches/0027-HD-clouds-noise-scales-that-divide-the-camera-s-6553.patch

@@ -0,0 +1,52 @@
+From 8d4cadbf8534309ac847d34e229f6d764770475d Mon Sep 17 00:00:00 2001
+From: chexit <chexit@duck.com>
+Date: Thu, 29 Oct 2026 23:22:19 +0300
+Subject: [PATCH 27/28] HD clouds: noise scales that divide the camera's
+ 65536-block wrap, so the clouds and their shadows no longer jump at x or z =
+ 0
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
+---
+ crates/horizon-client/src/gfx/hd/cloud_common.wgsl | 12 +++++++-----
+ 1 file changed, 7 insertions(+), 5 deletions(-)
+
+diff --git a/crates/horizon-client/src/gfx/hd/cloud_common.wgsl b/crates/horizon-client/src/gfx/hd/cloud_common.wgsl
+index 393ea564b..e2352f008 100644
+--- a/crates/horizon-client/src/gfx/hd/cloud_common.wgsl
++++ b/crates/horizon-client/src/gfx/hd/cloud_common.wgsl
+@@ -21,6 +21,8 @@ fn dampen(x: f32) -> f32 {
+ }
+ 
+ // Where a camera-relative point lies in the world's cloud pattern (the wind moves the pattern).
++// The camera's x, z come wrapped to 65536 blocks: every noise scale below must divide that (powers
++// of two), or the pattern jumps where the wrap happens (at x or z = 0).
+ fn cloud_xz(pos: vec3<f32>) -> vec2<f32> {
+     return vec2<f32>(pos.x + frame.cloud_cam.x, pos.z + frame.cloud_cam.y)
+         + vec2<f32>(0.8, 0.6) * (CLOUD_WIND * frame.clouds.w);
+@@ -33,8 +35,8 @@ fn cloud_density(pos: vec3<f32>, detail: f32) -> f32 {
+     let h = (pos.y - frame.clouds.x) / frame.clouds.y;
+     if h <= 0.0 || h >= 1.0 { return 0.0; }
+     let w = cloud_xz(pos);
+-    let cover = textureSampleLevel(noise2, repeat_s, w / 16000.0, 0.0).r;
+-    let shape = textureSampleLevel(noise2, repeat_s, w / 3000.0, 0.0).g;
++    let cover = textureSampleLevel(noise2, repeat_s, w / 16384.0, 0.0).r;
++    let shape = textureSampleLevel(noise2, repeat_s, w / 4096.0, 0.0).g;
+     let cu = mix(0.56, 0.80, cover) + frame.cloud_cam.z;
+     var d = linear_step(1.0 - cu, 1.0, shape);
+     // Carve an egg shape, thin out the bottom.
+@@ -43,9 +45,9 @@ fn cloud_density(pos: vec3<f32>, detail: f32) -> f32 {
+     if d < 0.002 { return 0.0; }
+     if detail > 0.0 {
+         let p3 = vec3<f32>(w.x, pos.y, w.y);
+-        let warp = (textureSampleLevel(noise3, repeat_s, p3 / 1100.0, 0.0).b - 0.5) * 0.4;
+-        let w0 = 1.0 - textureSampleLevel(noise3, repeat_s, p3 / 420.0 + vec3<f32>(warp), 0.0).r;
+-        let w1 = 1.0 - textureSampleLevel(noise3, repeat_s, p3 / 90.0 + vec3<f32>(warp * 3.0), 0.0).g;
++        let warp = (textureSampleLevel(noise3, repeat_s, p3 / 1024.0, 0.0).b - 0.5) * 0.4;
++        let w0 = 1.0 - textureSampleLevel(noise3, repeat_s, p3 / 512.0 + vec3<f32>(warp), 0.0).r;
++        let w1 = 1.0 - textureSampleLevel(noise3, repeat_s, p3 / 64.0 + vec3<f32>(warp * 3.0), 0.0).g;
+         let fade = 0.20 * smoothstep(0.85, 1.0, 1.0 - h) - 0.35 * smoothstep(0.05, 0.5, h) + 0.6;
+         d -= 0.55 * w0 * w0 * dampen(1.0 - d);
+         d -= 0.45 * w1 * w1 * dampen(1.0 - d) * fade;
+-- 
+2.54.0 (Apple Git-157)
+

tools/hd_bench.py

@@ -1,24 +1,37 @@
 #!/usr/bin/env python3
-"""Графический полигон HD (#44): фиксированные сцены, сравнение кадров, мерцание и GPU-бюджет.
+"""Графический полигон HD (#44, #71): фиксированные сцены, сравнение кадров, мерцание и GPU-бюджет.
 
     python3 tools/hd_bench.py --list                         # сцены и их параметры
     python3 tools/hd_bench.py                                # все сцены -> run-home-bench/out/<время>/
     python3 tools/hd_bench.py --only polygon_noon            # одна сцена (годится и при занятой игре)
     python3 tools/hd_bench.py --env HORIZON_HD_TAA=0 --out run-home-bench/out/taa-off
     python3 tools/hd_bench.py --baseline run-home-bench/out/before --out run-home-bench/out/after
+    python3 tools/hd_bench.py --no-freeze                    # живой замер производительности: время и погода идут
 
 Каждый прогон: свежая копия миров Polygon и Hills из run-home/saves в run-home-bench/home, мод airdef,
 игра офскрин на сокете run-home-bench/c.sock (одна за раз; чужой игре run-home/ctl.sock не мешаем).
-Для каждой сцены: время суток, ясная погода, телепорт, пауза на устаканивание, кадр, ещё один кадр
-(мерцание), `bench 4` (GPU avg, мс) и средние проходы из run-home-bench/c.log при HORIZON_SHADER_PACK_TIMING=1.
+Для каждой сцены: время и погода заморожены (`gamerule advance_time/advance_weather false`), время суток,
+ясная погода, телепорт, пауза на устаканивание, подряд --stills кадров (по умолчанию 3), прогрев, `bench 4`
+(GPU avg, мс) и средние проходы из run-home-bench/c.log при HORIZON_SHADER_PACK_TIMING=1.
 Итог: report.md и results.json в папке вывода.
 
+Анимация (#71). Игровое время и погоду мы замораживаем, но вода (волны, HD `water.y`) и листва (ветер,
+`wind_seconds`) идут по часам стены, поэтому два прогона одного бинарника разные и без изменений кода.
+Поэтому кадры не сравниваются целиком: по кадрам одного прогона пиксель, у которого размах значений между
+кадрами больше --motion-level (16 из 255), считается движущимся (вода, облака, листва). Такие пиксели не
+участвуют в сравнении с базой (ни в одном из двух прогонов). Мерцание считается по остальным пикселям:
+размах между кадрами больше --flicker-level (6 из 255) и не больше --motion-level. Для движущейся части
+выводится отдельная средняя разница, только для информации. Картинка `<сцена>_motion.png` показывает маску.
+
 Коды выхода: 0 — всё в порогах и бюджете; 1 — есть превышение; 2 — ошибка запуска или аргументов.
-Только стандартная библиотека; при установленном Pillow сравнение быстрее.
+Только стандартная библиотека; при установленном Pillow декодирование PNG быстрее.
 """
 import argparse
 import datetime
+import hashlib
+import itertools
 import json
+import operator
 import os
 import re
 import shutil
@@ -38,9 +51,12 @@ HOME = BENCH / "home"  # HORIZON_HOME одного прогона, пересо
 CTL = ROOT / "horizon" / "target" / "fast" / "horizon-ctl"
 SAVES = ROOT / "run-home" / "saves"
 OTHER_SOCK = "run-home/ctl.sock"  # чужая игра (другой агент): только читаем, не трогаем
-DIFF_LEVEL = 20  # порог «заметной» разницы по каналу, из 255
+DIFF_LEVEL = 20  # порог «заметной» разницы по каналу, из 255 (сравнение с базой)
 DIFF_GAIN = 6  # усиление разницы в diff-картинках
+MOTION_LEVEL = 16  # размах значения между кадрами одного прогона выше этого — движение (вода, облака, листва)
+FLICKER_LEVEL = 6  # размах выше этого на статичных пикселях — мерцание
 TIMING_RE = re.compile(r"shader pack GPU time per pass .*?: (.*) = ([\d.]+)\s*$")
+FREEZE_RULES = ("advance_time", "advance_weather")  # имена игровых правил в horizon-client-core/gamerules.rs
 
 
 @dataclass
@@ -173,6 +189,14 @@ def stop_game():
         SOCK.unlink()
 
 
+def file_sha256(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
 # --- кадры: PNG без Pillow и с ним -------------------------------------------------------------
 
 def _paeth(a, b, c):
@@ -248,51 +272,103 @@ def write_png_rgb(path, w, h, rgb):
                            + chunk(b"IEND", b""))
 
 
-try:  # необязательно: быстрее декодирование и сравнение
-    from PIL import Image, ImageChops, ImageStat
+try:  # необязательно: быстрее декодирование
+    from PIL import Image
 except ImportError:  # pragma: no cover
     Image = None
 
 
-def compare_frames(a, b, diff_out=None):
-    """Средняя разница по каналам (0..255) и доля пикселей с разницей > DIFF_LEVEL, в %."""
+def load_rgb(path):
     if Image is not None:
-        A = Image.open(a).convert("RGB")
-        B = Image.open(b).convert("RGB")
-        if A.size != B.size:
-            raise BenchError(f"размеры кадров разные: {A.size} и {B.size}")
-        d = ImageChops.difference(A, B)
-        mean = sum(ImageStat.Stat(d).mean) / 3
-        r, g, bl = d.split()
-        mx = ImageChops.lighter(ImageChops.lighter(r, g), bl)
-        hist = mx.histogram()
-        total = A.size[0] * A.size[1]
-        pct = 100.0 * sum(hist[DIFF_LEVEL + 1:]) / total
-        if diff_out:
-            d.point(lambda v: min(255, v * DIFF_GAIN)).save(diff_out)
-        return {"mean": mean, "pct": pct, "size": list(A.size)}
-    wa, ha, pa = read_png_rgb(a)
-    wb, hb, pb = read_png_rgb(b)
-    if (wa, ha) != (wb, hb):
-        raise BenchError(f"размеры кадров разные: {wa}x{ha} и {wb}x{hb}")
-    total_abs = 0
-    over = 0
-    diff = bytearray(len(pa)) if diff_out else None
-    for i in range(0, len(pa), 3):
-        dr = abs(pa[i] - pb[i])
-        dg = abs(pa[i + 1] - pb[i + 1])
-        db = abs(pa[i + 2] - pb[i + 2])
-        total_abs += dr + dg + db
-        if max(dr, dg, db) > DIFF_LEVEL:
-            over += 1
-        if diff is not None:
-            diff[i] = min(255, dr * DIFF_GAIN)
-            diff[i + 1] = min(255, dg * DIFF_GAIN)
-            diff[i + 2] = min(255, db * DIFF_GAIN)
+        im = Image.open(path).convert("RGB")
+        return im.size[0], im.size[1], im.tobytes()
+    return read_png_rgb(path)
+
+
+def load_frames(paths):
+    """(w, h, [bytes RGB каждого кадра]); размеры должны совпадать."""
+    w = h = None
+    rgbs = []
+    for p in paths:
+        pw, ph, px = load_rgb(p)
+        if w is None:
+            w, h = pw, ph
+        elif (pw, ph) != (w, h):
+            raise BenchError(f"размеры кадров разные: {w}x{h} и {pw}x{ph} ({Path(p).name})")
+        rgbs.append(px)
+    return w, h, rgbs
+
+
+def shot_frames(folder, name, n=None):
+    """Кадры сцены по порядку: <имя>.png, <имя>_still2.png, ... до n или пока файлы есть."""
+    paths = []
+    while n is None or len(paths) < n:
+        k = len(paths) + 1
+        p = Path(folder) / (f"{name}.png" if k == 1 else f"{name}_still{k}.png")
+        if not p.exists():
+            break
+        paths.append(p)
+    return paths
+
+
+# --- сравнение кадров с учётом анимации (#71) ---------------------------------------------------
+
+def _per_pixel_max(ch):
+    """Из байтов по каналам (RGB, по 3 на пиксель) — максимум по каналам на пиксель."""
+    return bytes(map(max, ch[0::3], ch[1::3], ch[2::3]))
+
+
+def _expand3(mask):
+    """Маска на пиксель -> маска на байт (по 3 на пиксель)."""
+    m = bytearray(3 * len(mask))
+    m[0::3] = mask
+    m[1::3] = mask
+    m[2::3] = mask
+    return m
+
+
+def motion_range(rgbs):
+    """Размах значения каждого пикселя между кадрами одного прогона (максимум по каналам, 0..255)."""
+    lo = hi = rgbs[0]
+    for f in rgbs[1:]:
+        lo = bytes(map(min, lo, f))
+        hi = bytes(map(max, hi, f))
+    return _per_pixel_max(bytes(map(operator.sub, hi, lo)))
+
+
+def flicker_stats(rng, w, h, n_frames, motion_level, flicker_level):
+    npx = w * h
+    flick = sum(1 for r in rng if flicker_level < r <= motion_level)
+    moving = sum(1 for r in rng if r > motion_level)
+    return {"pct": 100.0 * flick / npx, "animated_pct": 100.0 * moving / npx,
+            "frames": n_frames, "size": [w, h]}
+
+
+def compare_runs(cur_rgb, cur_rng, base_rgb, base_rng, w, h, motion_level, diff_out=None, motion_out=None):
+    """Первый кадр текущего прогона против первого кадра базы. Движущиеся пиксели (в любом из двух
+    прогонов) в сравнении не участвуют: mean и pct — только по статичным; для движущихся — отдельная
+    средняя разница (информация, не порог)."""
+    npx = w * h
+    static = bytes(1 if (a <= motion_level and b <= motion_level) else 0 for a, b in zip(cur_rng, base_rng))
+    d = bytes(map(abs, map(operator.sub, cur_rgb[0], base_rgb[0])))
+    dpix = _per_pixel_max(d)
+    n_static = sum(static)
+    n_moving = npx - n_static
+    mean = sum(itertools.compress(d, _expand3(static))) / (3.0 * n_static) if n_static else 0.0
+    over = sum(1 for p, s in zip(dpix, static) if s and p > DIFF_LEVEL)
+    moving_mean = (sum(itertools.compress(d, _expand3(bytes(1 - s for s in static)))) / (3.0 * n_moving)
+                   if n_moving else 0.0)
     if diff_out:
-        write_png_rgb(diff_out, wa, ha, bytes(diff))
-    npx = wa * ha
-    return {"mean": total_abs / (3.0 * npx), "pct": 100.0 * over / npx, "size": [wa, ha]}
+        img = bytearray(min(255, v * DIFF_GAIN) for v in d)
+        for i, s in enumerate(static):
+            if not s:  # движущиеся пиксели — синим, чтобы не путать с регрессией
+                j = 3 * i
+                img[j], img[j + 1], img[j + 2] = 0, 0, 80
+        write_png_rgb(diff_out, w, h, bytes(img))
+    if motion_out:
+        write_png_rgb(motion_out, w, h, bytes(_expand3(bytes(0 if s else 255 for s in static))))
+    return {"mean": mean, "pct": 100.0 * over / npx, "animated_pct": 100.0 * n_moving / npx,
+            "animated_mean": moving_mean, "size": [w, h]}
 
 
 # --- тайминги -----------------------------------------------------------------------------------
@@ -345,19 +421,26 @@ def bench_gpu_avg(reply):
 
 # --- сцена ------------------------------------------------------------------------------------
 
-def run_shot(shot, out, settle, bench_secs, timing):
+def run_shot(shot, out, settle, bench_secs, timing, stills, gap, warmup, freeze):
     x, y, z, yaw, pitch = shot.pose
+    if freeze:  # игровое время и погода стоят: облачные часы и погода не уходят между снимками
+        for rule in FREEZE_RULES:
+            ctl("command", f"gamerule {rule} false")
     ctl("command", f"time set {shot.time}")
     ctl("command", "weather clear")
     ctl("command", f"tp @s {x} {y} {z} {yaw} {pitch}")
     ctl("wait-ready", 120, timeout=150)
     time.sleep(settle)
-    first = out / f"{shot.name}.png"
-    ctl("screenshot", str(first.resolve()))
-    time.sleep(0.5)
-    second = out / f"{shot.name}_still2.png"
-    ctl("screenshot", str(second.resolve()))
-    result = {"frame": first.name, "still2": second.name, "gpu_avg_ms": None, "passes": {},
+    frames = []
+    for k in range(stills):
+        if k:
+            time.sleep(gap)
+        path = out / (f"{shot.name}.png" if k == 0 else f"{shot.name}_still{k + 1}.png")
+        ctl("screenshot", str(path.resolve()))
+        frames.append(path.name)
+    if warmup > 0:  # прогрев перед замером, не попадает в отчёт
+        ctl("bench", warmup, timeout=warmup + 60)
+    result = {"frame": frames[0], "frames": frames, "gpu_avg_ms": None, "passes": {},
               "pass_total_ms": None, "bench_json": None}
     offset = LOG.stat().st_size if LOG.exists() else 0
     reply = ctl("bench", bench_secs, timeout=bench_secs + 60)
@@ -397,43 +480,53 @@ def judge(entry, args):
     if gpu is None and not entry.get("error"):
         reasons.append("нет GPU-таймингов (bench)")
     fl = entry.get("flicker")
-    if fl and fl["pct"] > args.max_flicker:
-        reasons.append(f"мерцание {fl['pct']:.2f}% > {args.max_flicker:g}%")
+    if fl and args.max_flicker is not None and fl["pct"] > args.max_flicker:
+        reasons.append(f"мерцание статичных пикселей {fl['pct']:.2f}% > {args.max_flicker:g}%")
     base = entry.get("vs_baseline")
     if base:
         if base.get("error"):
             reasons.append(base["error"])
         else:
             if base["mean"] > args.max_mean:
-                reasons.append(f"разница с базой {base['mean']:.2f} > {args.max_mean:g}")
+                reasons.append(f"разница с базой (статика) {base['mean']:.2f} > {args.max_mean:g}")
             if base["pct"] > args.max_pct:
-                reasons.append(f"пикселей >20/255 {base['pct']:.2f}% > {args.max_pct:g}%")
+                reasons.append(f"статичных пикселей >20/255 {base['pct']:.2f}% > {args.max_pct:g}%")
     return reasons
 
 
-def write_report(out, entries, args, env_extra, size, baseline):
+def write_report(out, entries, args, env_extra, size, baseline, meta):
     lines = []
     add = lines.append
     add(f"# HD-полигон: {out.name}")
     add("")
-    add(f"- коммит: `{git_rev()}`, дата: {datetime.datetime.now():%Y-%m-%d %H:%M}")
+    add(f"- движок: `{meta['game']}`, sha256 `{meta['game_sha256'][:16]}`; коммит мода (не движка): `{git_rev()}`")
+    add(f"- ресурсы: `{meta['resources']}`")
+    add(f"- дата: {datetime.datetime.now():%Y-%m-%d %H:%M}")
     add(f"- разрешение кадра: {size[0]}x{size[1]}" if size else "- разрешение кадра: ?")
-    add(f"- окружение игры: " + (", ".join(f"`{k}={v}`" for k, v in sorted(env_extra.items())) or "по умолчанию"))
-    add(f"- бюджет GPU: {args.budget_ms:g} мс (bench {args.bench_secs:g} с), мерцание <= {args.max_flicker:g}%")
+    add("- время и погода: " + ("заморожены (`gamerule advance_time/advance_weather false`)" if meta["freeze"]
+                              else "идут (`--no-freeze`, живой замер)"))
+    add(f"- кадров на сцену: {meta['stills']} через {meta['still_gap']:g} с; прогрев {meta['warmup_secs']:g} с")
+    add(f"- движение: размах между кадрами > {meta['motion_level']}/255 (вода, облака, листва) не сравнивается с базой; "
+        f"мерцание: статичные пиксели с размахом > {meta['flicker_level']}/255")
+    add("- окружение игры: " + (", ".join(f"`{k}={v}`" for k, v in sorted(env_extra.items())) or "по умолчанию"))
+    add(f"- бюджет GPU: {args.budget_ms:g} мс (bench {args.bench_secs:g} с), мерцание: "
+        + (f"<= {args.max_flicker:g}%" if args.max_flicker is not None else "только в отчёте (порог не задан)"))
     if baseline:
-        add(f"- сравнение с: `{baseline}` (средняя разница <= {args.max_mean:g}, пикселей >20/255 <= {args.max_pct:g}%)")
+        add(f"- сравнение с: `{baseline}` (статичные пиксели: средняя разница <= {args.max_mean:g}, "
+            f"пикселей >20/255 <= {args.max_pct:g}%)")
     add("")
-    add("| сцена | мир | время | GPU avg, мс | бюджет | мерцание %>20 | к базе: mean | к базе: %>20 | итог |")
-    add("|---|---|---|---|---|---|---|---|---|")
+    add("| сцена | мир | время | GPU avg, мс | бюджет | мерцание % | движение % | к базе (статика): mean | %>20 | итог |")
+    add("|---|---|---|---|---|---|---|---|---|---|")
     for e in entries:
         gpu = f"{e['gpu_avg_ms']:.2f}" if e.get("gpu_avg_ms") is not None else "-"
         fl = f"{e['flicker']['pct']:.2f}" if e.get("flicker") else "-"
+        mv = f"{e['flicker']['animated_pct']:.2f}" if e.get("flicker") else "-"
         b = e.get("vs_baseline") or {}
         bm = f"{b['mean']:.2f}" if "mean" in b else "-"
         bp = f"{b['pct']:.2f}" if "pct" in b else "-"
         status = "OK" if not e["fail"] else "FAIL: " + "; ".join(e["fail"])
         budget = "да" if e.get("gpu_avg_ms") is not None and e["gpu_avg_ms"] <= args.budget_ms else ("нет" if e.get("gpu_avg_ms") is not None else "-")
-        add(f"| {e['name']} | {e['world']} | {e['time']} | {gpu} | {budget} | {fl} | {bm} | {bp} | {status} |")
+        add(f"| {e['name']} | {e['world']} | {e['time']} | {gpu} | {budget} | {fl} | {mv} | {bm} | {bp} | {status} |")
     passes = []
     for e in entries:
         for p in e.get("passes", {}):
@@ -458,7 +551,10 @@ def write_report(out, entries, args, env_extra, size, baseline):
         add(f"![{e['name']}]({e['frame']})")
         if e.get("diff_image"):
             add("")
-            add(f"Разница с базой (x{DIFF_GAIN}): ![diff]({e['diff_image']})")
+            add(f"Разница с базой (x{DIFF_GAIN}, синим — движущиеся пиксели, не сравниваются): ![diff]({e['diff_image']})")
+        if e.get("motion_image"):
+            add("")
+            add(f"Движущиеся пиксели (белым): ![motion]({e['motion_image']})")
         if e.get("warning"):
             add("")
             add(f"> {e['warning']}")
@@ -477,14 +573,26 @@ def parse_args(argv):
     p.add_argument("--env", action="append", default=[], metavar="КЛЮЧ=ЗНАЧЕНИЕ", help="переменная для игры, например HORIZON_HD_TAA=0")
     p.add_argument("--budget-ms", type=float, default=18.0, help="бюджет GPU на кадр, мс (по умолчанию 18)")
     p.add_argument("--bench-secs", type=float, default=4.0, help="сколько секунд bench (по умолчанию 4)")
-    p.add_argument("--settle", type=float, default=4.0, help="пауза после телепорта, с (по умолчанию 4)")
-    p.add_argument("--max-mean", type=float, default=3.0, help="порог средней разницы с базой, 0..255")
-    p.add_argument("--max-pct", type=float, default=5.0, help="порог пикселей >20/255 с базой, %%")
-    p.add_argument("--max-flicker", type=float, default=5.0, help="порог мерцания (два кадра подряд), %%")
+    p.add_argument("--settle", type=float, default=12.0, help="пауза после телепорта, с (по умолчанию 12: за 4 с TAA и экспозиция ещё сходятся, мерцание 20%% -> 6%%)")
+    p.add_argument("--stills", type=int, default=3, help="кадров подряд на сцену, не меньше 2 (по умолчанию 3)")
+    p.add_argument("--still-gap", type=float, default=0.5, help="пауза между кадрами, с (по умолчанию 0.5)")
+    p.add_argument("--warmup-secs", type=float, default=1.0, help="прогрев перед замером GPU, с; не в отчёте (по умолчанию 1)")
+    p.add_argument("--motion-level", type=int, default=MOTION_LEVEL,
+                   help=f"размах между кадрами выше этого (из 255) — движение, не сравнивается с базой (по умолчанию {MOTION_LEVEL})")
+    p.add_argument("--flicker-level", type=int, default=FLICKER_LEVEL,
+                   help=f"размах статичного пикселя выше этого (из 255) — мерцание (по умолчанию {FLICKER_LEVEL})")
+    p.add_argument("--max-mean", type=float, default=3.0, help="порог средней разницы статичных пикселей с базой, 0..255")
+    p.add_argument("--max-pct", type=float, default=5.0, help="порог статичных пикселей >20/255 с базой, %%")
+    p.add_argument("--max-flicker", type=float, default=None, help="порог мерцания статичных пикселей, %%; без него мерцание только в отчёте (порог пока не откалиброван двумя одинаковыми прогонами)")
+    p.add_argument("--no-freeze", action="store_true",
+                   help="не замораживать игровое время и погоду (живой замер производительности, не снимки)")
     p.add_argument("--no-pass-timing", action="store_true", help="не включать HORIZON_SHADER_PACK_TIMING")
     p.add_argument("--game", help="horizon-client (по умолчанию как в tools/airdef.py)")
     p.add_argument("--resources", help="подготовленные ресурсы Minecraft 26.3")
-    return p.parse_args(argv)
+    args = p.parse_args(argv)
+    if args.stills < 2:
+        p.error("--stills: нужно не меньше 2 кадров, иначе нет ни мерцания, ни движения")
+    return args
 
 
 def main(argv=None):
@@ -518,6 +626,14 @@ def main(argv=None):
 
     game = Path(args.game) if args.game else airdef.built_game()
     resources = Path(args.resources) if args.resources else airdef.resources()
+    try:
+        game_sha = file_sha256(game)
+    except OSError:
+        game_sha = "?" * 64
+    meta = {"game": str(game), "game_sha256": game_sha, "resources": str(resources),
+            "freeze": not args.no_freeze, "stills": args.stills, "still_gap": args.still_gap,
+            "warmup_secs": args.warmup_secs, "motion_level": args.motion_level,
+            "flicker_level": args.flicker_level}
     timing = not args.no_pass_timing
     env = game_env(env_extra, timing)
     prepare_home()
@@ -537,23 +653,28 @@ def main(argv=None):
             for s in group:
                 entry = {**asdict(s), "frame": f"{s.name}.png"}
                 try:
-                    entry.update(run_shot(s, out, args.settle, args.bench_secs, timing))
-                    fl = compare_frames(out / f"{s.name}.png", out / f"{s.name}_still2.png")
-                    entry["flicker"] = fl
+                    entry.update(run_shot(s, out, args.settle, args.bench_secs, timing, args.stills,
+                                          args.still_gap, args.warmup_secs, not args.no_freeze))
+                    w, h, rgbs = load_frames(shot_frames(out, s.name, args.stills))
+                    rng = motion_range(rgbs)
+                    entry["flicker"] = flicker_stats(rng, w, h, len(rgbs), args.motion_level, args.flicker_level)
+                    if baseline and not entry.get("error"):
+                        base_paths = shot_frames(baseline, s.name)  # все кадры базы, сколько есть
+                        if not base_paths:
+                            entry["vs_baseline"] = {"error": f"в базе нет {s.name}.png"}
+                        else:
+                            bw, bh, brgbs = load_frames(base_paths)
+                            if (bw, bh) != (w, h):
+                                raise BenchError(f"размеры кадров разные: база {bw}x{bh}, прогон {w}x{h}")
+                            brng = motion_range(brgbs)
+                            diff_name, motion_name = f"{s.name}_diff.png", f"{s.name}_motion.png"
+                            entry["vs_baseline"] = compare_runs(rgbs, rng, brgbs, brng, w, h, args.motion_level,
+                                                                out / diff_name, out / motion_name)
+                            entry["vs_baseline"]["base_frames"] = len(brgbs)
+                            entry["diff_image"] = diff_name
+                            entry["motion_image"] = motion_name
                 except BenchError as e:
                     entry["error"] = str(e)
-                if baseline and not entry.get("error"):
-                    base_png = baseline / f"{s.name}.png"
-                    if base_png.exists():
-                        try:
-                            diff_name = f"{s.name}_diff.png"
-                            m = compare_frames(base_png, out / f"{s.name}.png", out / diff_name)
-                            entry["vs_baseline"] = m
-                            entry["diff_image"] = diff_name
-                        except BenchError as e:
-                            entry["vs_baseline"] = {"error": str(e)}
-                    else:
-                        entry["vs_baseline"] = {"error": f"в базе нет {base_png.name}"}
                 entry["fail"] = judge(entry, args)
                 entries.append(entry)
             stop_game()
@@ -567,15 +688,16 @@ def main(argv=None):
             break
     if size is None and entries and entries[0].get("flicker"):
         size = entries[0]["flicker"]["size"]
-    results = {"out": str(out), "env": env_extra, "budget_ms": args.budget_ms,
+    results = {"out": str(out), "env": env_extra, "budget_ms": args.budget_ms, "meta": meta,
                "baseline": str(baseline) if baseline else None, "shots": entries}
     (out / "results.json").write_text(json.dumps(results, ensure_ascii=False, indent=2) + "\n")
-    write_report(out, entries, args, env_extra, size, str(baseline) if baseline else None)
+    write_report(out, entries, args, env_extra, size, str(baseline) if baseline else None, meta)
 
     failed = [e for e in entries if e["fail"]]
     for e in entries:
         print(f"{e['name']:22} GPU {e.get('gpu_avg_ms') if e.get('gpu_avg_ms') is None else round(e['gpu_avg_ms'], 2)} мс  "
-              f"мерцание {e['flicker']['pct']:.2f}%" if e.get("flicker") else f"{e['name']:22} {e.get('error', '')}")
+              f"мерцание {e['flicker']['pct']:.2f}%  движение {e['flicker']['animated_pct']:.2f}%" if e.get("flicker")
+              else f"{e['name']:22} {e.get('error', '')}")
         for r in e["fail"]:
             print(f"    FAIL: {r}")
     print(f"отчёт: {out / 'report.md'}")