Flights over unknown land hold a safe height, air starts wait for the land, systems and aims settle on the surface; map labels, filters, coverage by terrain and scenes
build / mod (push) Successful in 8m34s
build / mod (push) Successful in 8m34s
Far raids over mountains with a 300-block known disc: crashes from 19 to 2 of 368 (mixed), 22 to about 9 (smart). Balance tests gain hilly land. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -2110,6 +2110,8 @@ impl Mod for AirDef {
|
|||||||
sam.roles = *r;
|
sam.roles = *r;
|
||||||
}
|
}
|
||||||
self.sim.sams.push(sam);
|
self.sim.sams.push(sam);
|
||||||
|
// Standing in the ground (a chunk that had not loaded as the player fell): it comes up to the surface.
|
||||||
|
self.sim.settle(sid);
|
||||||
self.dirty = true;
|
self.dirty = true;
|
||||||
Some(format!("{} развёрнут", kind.name()))
|
Some(format!("{} развёрнут", kind.name()))
|
||||||
}
|
}
|
||||||
|
|||||||
+1027
-182
File diff suppressed because it is too large
Load Diff
+227
-14
@@ -1,7 +1,6 @@
|
|||||||
//! Balance measurements: a whole raid on flat land, flown headlessly against a cluster of systems.
|
//! Balance measurements: a whole raid on flat land, flown headlessly against a cluster of systems.
|
||||||
//! The `#[ignore]`d tests print tables (`cargo test --release balance -- --ignored --nocapture`);
|
//! The `#[ignore]`d tests print tables (`cargo test --release balance -- --ignored --nocapture`);
|
||||||
//! the others assert the cheap invariants. The tables are what the air defence's tuning is judged by.
|
//! the others assert the cheap invariants. The tables are what the air defence's tuning is judged by.
|
||||||
use super::sites::testland::{Land, serve};
|
|
||||||
use super::*;
|
use super::*;
|
||||||
|
|
||||||
/// The ten armed kinds in the order a cluster takes them (long-range heavy ones spread evenly).
|
/// The ten armed kinds in the order a cluster takes them (long-range heavy ones spread evenly).
|
||||||
@@ -48,12 +47,19 @@ pub(super) struct Result {
|
|||||||
pub untracked: u32,
|
pub untracked: u32,
|
||||||
pub hits: u32,
|
pub hits: u32,
|
||||||
pub crashes: u32,
|
pub crashes: u32,
|
||||||
|
/// Interceptors lost against the land, and ones that blew up short of a ridge.
|
||||||
|
pub blocked: u32,
|
||||||
|
pub scrubbed: u32,
|
||||||
pub unshot: u32,
|
pub unshot: u32,
|
||||||
pub missed: u32,
|
pub missed: u32,
|
||||||
/// Missiles fired by the heavy systems (S-400, S-500, Patriot).
|
/// Missiles fired by the heavy systems (S-400, S-500, Patriot).
|
||||||
pub heavy: u32,
|
pub heavy: u32,
|
||||||
pub by_kind: Vec<(DroneKind, u32, u32)>,
|
pub by_kind: Vec<(DroneKind, u32, u32)>,
|
||||||
pub tally: String,
|
pub tally: String,
|
||||||
|
/// Drones that vanished short of their aim without being shot down: kind, where, how far from the aim.
|
||||||
|
pub crashed: Vec<(DroneKind, DVec3, f64)>,
|
||||||
|
/// Chunk tickets the sim asked for.
|
||||||
|
pub tickets: usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(super) struct Setup {
|
pub(super) struct Setup {
|
||||||
@@ -65,20 +71,121 @@ pub(super) struct Setup {
|
|||||||
pub objects: usize,
|
pub objects: usize,
|
||||||
/// Called on the sim before the raid (a test sets its switches).
|
/// Called on the sim before the raid (a test sets its switches).
|
||||||
pub tweak: fn(&mut Sim),
|
pub tweak: fn(&mut Sim),
|
||||||
|
/// Hilly land instead of flat (`hills`).
|
||||||
|
pub hilly: bool,
|
||||||
|
/// Only a disc of this radius round the player (the origin) is loaded, as in the game; beyond it the land is not
|
||||||
|
/// there (`Void`) unless a chunk ticket was asked for (loaded after a delay, for a while).
|
||||||
|
pub disc: Option<f64>,
|
||||||
|
/// Mountains on top of the hills (ridges of up to 150 blocks, 600-900 blocks apart).
|
||||||
|
pub mountains: bool,
|
||||||
|
/// How far out the raid launches (the order's distance).
|
||||||
|
pub dist: f64,
|
||||||
|
/// Systems and objects sunk this far into the land (a player who stood inside it).
|
||||||
|
pub bury: f64,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Rolling hills: ridges of 20-35 blocks over a plain at 64, wavelengths of 90-250 blocks.
|
||||||
|
pub(super) fn hills(x: i32, z: i32) -> i32 {
|
||||||
|
let (x, z) = (f64::from(x), f64::from(z));
|
||||||
|
let n = (x / 53.0 + (z / 91.0).sin() * 1.7).sin() * 0.5 + (z / 41.0 - (x / 77.0).cos()).sin() * 0.35 + ((x + z) / 130.0).sin() * 0.4 + ((x - 2.0 * z) / 29.0).sin() * 0.12;
|
||||||
|
64 + (n * 28.0 + 14.0).max(-4.0) as i32
|
||||||
|
}
|
||||||
|
|
||||||
|
fn ground_at(hilly: bool, x: f64, z: f64) -> f64 {
|
||||||
|
if hilly { f64::from(hills(x as i32, z as i32)) } else { 64.0 }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Mountains: broad ridges over the hills, nothing within about 300 blocks of the origin.
|
||||||
|
pub(super) fn mountains(x: i32, z: i32) -> i32 {
|
||||||
|
let (x, z) = (f64::from(x), f64::from(z));
|
||||||
|
let r = (x * x + z * z).sqrt();
|
||||||
|
let ridge = ((x / 410.0 + 0.7).sin() * (z / 530.0 - 0.4).sin() + (x / 700.0 - z / 610.0).sin() * 0.6).max(0.0);
|
||||||
|
(ridge * 150.0 * ((r - 300.0) / 400.0).clamp(0.0, 1.0)) as i32
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The game's view of the land: all of it, or a disc round the player and the chunks asked for.
|
||||||
|
pub(super) struct Loader {
|
||||||
|
pub hilly: bool,
|
||||||
|
pub mountains: bool,
|
||||||
|
pub disc: Option<f64>,
|
||||||
|
asked: std::cell::RefCell<HashMap<(i32, i32), (u64, u64)>>,
|
||||||
|
pub tickets: usize,
|
||||||
|
}
|
||||||
|
const TICKET_DELAY: u64 = 40;
|
||||||
|
const TICKET_LIFE: u64 = 400;
|
||||||
|
|
||||||
|
impl Loader {
|
||||||
|
pub fn new(s: &Setup) -> Self {
|
||||||
|
Loader { hilly: s.hilly, mountains: s.mountains, disc: s.disc, asked: Default::default(), tickets: 0 }
|
||||||
|
}
|
||||||
|
pub fn height(&self, x: i32, z: i32) -> i32 {
|
||||||
|
if self.hilly { hills(x, z) + if self.mountains { mountains(x, z) } else { 0 } } else { 64 }
|
||||||
|
}
|
||||||
|
fn loaded(&self, c: (i32, i32), now: u64) -> Option<bool> {
|
||||||
|
let Some(r) = self.disc else { return Some(true) };
|
||||||
|
let (x, z) = (f64::from(c.0 * 16 + 8), f64::from(c.1 * 16 + 8));
|
||||||
|
if (x * x + z * z).sqrt() <= r {
|
||||||
|
return Some(true);
|
||||||
|
}
|
||||||
|
match self.asked.borrow().get(&c) {
|
||||||
|
Some(&(since, until)) if now < until => Some(now >= since + TICKET_DELAY),
|
||||||
|
_ => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn serve(&mut self, ground: &mut Ground, now: u64) {
|
||||||
|
for c in ground.take_chunks() {
|
||||||
|
self.tickets += 1;
|
||||||
|
if std::env::var("NOTICKETS").is_err() {
|
||||||
|
let mut asked = self.asked.borrow_mut();
|
||||||
|
let e = asked.entry(c).or_insert((now, now));
|
||||||
|
if now >= e.1 {
|
||||||
|
*e = (now, now);
|
||||||
|
}
|
||||||
|
e.1 = now + TICKET_DELAY + TICKET_LIFE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let cols = ground
|
||||||
|
.take_wanted()
|
||||||
|
.into_iter()
|
||||||
|
.map(|(x, z)| {
|
||||||
|
let y = match self.loaded((x >> 4, z >> 4), now) {
|
||||||
|
Some(true) => self.height(x, z),
|
||||||
|
Some(false) => PENDING,
|
||||||
|
None => -64,
|
||||||
|
};
|
||||||
|
(x, z, y)
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
ground.answer(cols, now);
|
||||||
|
let secs = ground.world.take_wanted(now);
|
||||||
|
let view = Seen { l: self, now };
|
||||||
|
ground.world.serve(&view, secs, now);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
struct Seen<'a> {
|
||||||
|
l: &'a Loader,
|
||||||
|
now: u64,
|
||||||
|
}
|
||||||
|
impl world::WorldSource for Seen<'_> {
|
||||||
|
fn solid(&self, x: i32, y: i32, z: i32) -> Option<bool> {
|
||||||
|
self.l.loaded((x >> 4, z >> 4), self.now).filter(|&l| l).map(|_| y < self.l.height(x, z))
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Setup {
|
impl Setup {
|
||||||
pub fn new(systems: usize, smart: bool, seed: u64) -> Self {
|
pub fn new(systems: usize, smart: bool, seed: u64) -> Self {
|
||||||
Setup { systems, smart, seed, size: 36, radars: (systems / 10).max(1), objects: 36, tweak: |_| {} }
|
Setup { systems, smart, seed, size: 36, radars: (systems / 10).max(1), objects: 36, tweak: |_| {}, hilly: false, bury: 0.0, disc: None, mountains: false, dist: 500.0 }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The cluster: `objects` in a grid, systems of the mix scattered round them, radars among them.
|
/// The cluster: `objects` in a grid, systems of the mix scattered round them, radars among them.
|
||||||
pub(super) fn cluster(sim: &mut Sim, s: &Setup) {
|
pub(super) fn cluster(sim: &mut Sim, s: &Setup) {
|
||||||
|
let y = |x: f64, z: f64| if s.hilly { ground_at(true, x, z) - s.bury } else { 70.0 };
|
||||||
let mut rng = Rng::new(s.seed.wrapping_mul(977) + 5);
|
let mut rng = Rng::new(s.seed.wrapping_mul(977) + 5);
|
||||||
let side = (s.objects as f64).sqrt().ceil() as usize;
|
let side = (s.objects as f64).sqrt().ceil() as usize;
|
||||||
for k in 0..s.objects {
|
for k in 0..s.objects {
|
||||||
let p = DVec3::new(((k % side) as f64 - side as f64 / 2.0) * 70.0, 70.0, ((k / side) as f64 - side as f64 / 2.0) * 70.0);
|
let (px, pz) = (((k % side) as f64 - side as f64 / 2.0) * 70.0, ((k / side) as f64 - side as f64 / 2.0) * 70.0);
|
||||||
|
let p = DVec3::new(px, if s.hilly { y(px, pz) + 6.0 + s.bury } else { 70.0 }, pz);
|
||||||
sim.targets.push(p);
|
sim.targets.push(p);
|
||||||
sim.target_health.push(100.0);
|
sim.target_health.push(100.0);
|
||||||
}
|
}
|
||||||
@@ -88,13 +195,15 @@ pub(super) fn cluster(sim: &mut Sim, s: &Setup) {
|
|||||||
let a = rng.f() * TAU;
|
let a = rng.f() * TAU;
|
||||||
let r = 30.0 + rng.f() * 110.0;
|
let r = 30.0 + rng.f() * 110.0;
|
||||||
let id = sim.id();
|
let id = sim.id();
|
||||||
sim.sams.push(Sam::new(id, MIX[i % MIX.len()], at + DVec3::new(a.sin() * r, 0.0, a.cos() * r), rng.f() * TAU));
|
let (px, pz) = (at.x + a.sin() * r, at.z + a.cos() * r);
|
||||||
|
sim.sams.push(Sam::new(id, MIX[i % MIX.len()], DVec3::new(px, y(px, pz), pz), rng.f() * TAU));
|
||||||
}
|
}
|
||||||
for _ in 0..s.radars {
|
for _ in 0..s.radars {
|
||||||
let a = rng.f() * TAU;
|
let a = rng.f() * TAU;
|
||||||
let r = rng.f() * 220.0;
|
let r = rng.f() * 220.0;
|
||||||
let id = sim.id();
|
let id = sim.id();
|
||||||
sim.sams.push(Sam::new(id, SamKind::Radar, DVec3::new(a.sin() * r, 70.0, a.cos() * r), 0.0));
|
let (px, pz) = (a.sin() * r, a.cos() * r);
|
||||||
|
sim.sams.push(Sam::new(id, SamKind::Radar, DVec3::new(px, if s.hilly { y(px, pz) } else { 70.0 }, pz), 0.0));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -104,13 +213,13 @@ pub(super) fn fly(s: &Setup) -> Result {
|
|||||||
cluster(&mut sim, s);
|
cluster(&mut sim, s);
|
||||||
(s.tweak)(&mut sim);
|
(s.tweak)(&mut sim);
|
||||||
let mut ground = Ground::default();
|
let mut ground = Ground::default();
|
||||||
let land = Land(|_, _| 64);
|
let mut land = Loader::new(s);
|
||||||
let mut out = Out::default();
|
let mut out = Out::default();
|
||||||
for _ in 0..200 {
|
for _ in 0..200 {
|
||||||
serve(&mut ground, &land, sim.tick);
|
land.serve(&mut ground, sim.tick);
|
||||||
sim.step(&mut ground, None, &mut out);
|
sim.step(&mut ground, None, &mut out);
|
||||||
}
|
}
|
||||||
let mut order = crate::wave::WaveConfig::mix(s.size, 500.0);
|
let mut order = crate::wave::WaveConfig::mix(s.size, s.dist);
|
||||||
// The Oreshnik's blocks are a raid of their own; this measures the ordinary mass raid.
|
// The Oreshnik's blocks are a raid of their own; this measures the ordinary mass raid.
|
||||||
order.kinds.retain(|k| k.0 != DroneKind::Oreshnik);
|
order.kinds.retain(|k| k.0 != DroneKind::Oreshnik);
|
||||||
if s.smart {
|
if s.smart {
|
||||||
@@ -125,7 +234,7 @@ pub(super) fn fly(s: &Setup) -> Result {
|
|||||||
let start = sim.tick;
|
let start = sim.tick;
|
||||||
let mut gone_unkilled: Vec<Hist> = Vec::new();
|
let mut gone_unkilled: Vec<Hist> = Vec::new();
|
||||||
for _ in 0..9000 {
|
for _ in 0..9000 {
|
||||||
serve(&mut ground, &land, sim.tick);
|
land.serve(&mut ground, sim.tick);
|
||||||
out = Out::default();
|
out = Out::default();
|
||||||
sim.step(&mut ground, None, &mut out);
|
sim.step(&mut ground, None, &mut out);
|
||||||
let now = sim.tick;
|
let now = sim.tick;
|
||||||
@@ -184,6 +293,8 @@ pub(super) fn fly(s: &Setup) -> Result {
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
result.tickets = land.tickets;
|
||||||
|
result.crashed = sim.crashed.iter().map(|c| (c.0, c.1, c.1.distance(c.2))).collect();
|
||||||
result.ticks = sim.tick - start;
|
result.ticks = sim.tick - start;
|
||||||
result.launched = sim.launched;
|
result.launched = sim.launched;
|
||||||
result.kills = sim.kills;
|
result.kills = sim.kills;
|
||||||
@@ -191,6 +302,8 @@ pub(super) fn fly(s: &Setup) -> Result {
|
|||||||
result.heavy = sim.sams.iter().filter(|m| matches!(m.kind, SamKind::S400 | SamKind::S500 | SamKind::Patriot)).map(|m| m.fired).sum();
|
result.heavy = sim.sams.iter().filter(|m| matches!(m.kind, SamKind::S400 | SamKind::S500 | SamKind::Patriot)).map(|m| m.fired).sum();
|
||||||
result.hits = sim.hits;
|
result.hits = sim.hits;
|
||||||
result.crashes = sim.crashes;
|
result.crashes = sim.crashes;
|
||||||
|
result.blocked = sim.tally.blocked;
|
||||||
|
result.scrubbed = sim.tally.scrubbed;
|
||||||
result.leaked = sim.hits;
|
result.leaked = sim.hits;
|
||||||
let mut kinds: HashMap<DroneKind, (u32, u32)> = HashMap::new();
|
let mut kinds: HashMap<DroneKind, (u32, u32)> = HashMap::new();
|
||||||
for h in &gone_unkilled {
|
for h in &gone_unkilled {
|
||||||
@@ -215,33 +328,60 @@ pub(super) fn fly(s: &Setup) -> Result {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub(super) fn table(title: &str, smart: bool, size: u32, systems: &[usize], seeds: &[u64], tweak: fn(&mut Sim)) -> Vec<(usize, f64)> {
|
pub(super) fn table(title: &str, smart: bool, size: u32, systems: &[usize], seeds: &[u64], tweak: fn(&mut Sim)) -> Vec<(usize, f64)> {
|
||||||
|
table_on(title, smart, size, systems, seeds, tweak, std::env::var("HILLS").is_ok())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn table_on(title: &str, smart: bool, size: u32, systems: &[usize], seeds: &[u64], tweak: fn(&mut Sim), hilly: bool) -> Vec<(usize, f64)> {
|
||||||
let mut means = Vec::new();
|
let mut means = Vec::new();
|
||||||
eprintln!("== {title} ({} raid)", if smart { "smart" } else { "mix" });
|
eprintln!("== {title} ({} raid{})", if smart { "smart" } else { "mix" }, if hilly { ", hills" } else { "" });
|
||||||
eprintln!("{:>4} {:>4} {:>5} {:>5} {:>5} {:>6} {:>6} | leaks: unseen nocover untrk unshot missed hits crash", "sams", "seed", "sent", "kills", "leak", "missil", "heavy");
|
eprintln!("{:>4} {:>4} {:>5} {:>5} {:>5} {:>6} {:>6} | leaks: unseen nocover untrk unshot missed hits crash blkd scrub", "sams", "seed", "sent", "kills", "leak", "missil", "heavy");
|
||||||
for &n in systems {
|
for &n in systems {
|
||||||
let (mut total, mut missiles, mut heavy, mut clean) = (0, 0, 0, 0);
|
let (mut total, mut missiles, mut heavy, mut clean, mut crashes, mut blocked) = (0, 0, 0, 0, 0, 0);
|
||||||
for &seed in seeds {
|
for &seed in seeds {
|
||||||
let mut s = Setup::new(n, smart, seed);
|
let mut s = Setup::new(n, smart, seed);
|
||||||
s.tweak = tweak;
|
s.tweak = tweak;
|
||||||
s.size = size;
|
s.size = size;
|
||||||
|
s.hilly = hilly;
|
||||||
let r = fly(&s);
|
let r = fly(&s);
|
||||||
total += r.leaked;
|
total += r.leaked;
|
||||||
clean += u32::from(r.leaked == 0);
|
clean += u32::from(r.leaked == 0);
|
||||||
|
crashes += r.crashes;
|
||||||
|
blocked += r.blocked + r.scrubbed;
|
||||||
missiles += r.missiles;
|
missiles += r.missiles;
|
||||||
heavy += r.heavy;
|
heavy += r.heavy;
|
||||||
if std::env::var("ROWS").is_ok() { eprintln!("{n:>4} {seed:>4} {:>5} {:>5} {:>5} {:>6} {:>6} | {:>12} {:>7} {:>5} {:>6} {:>6} {:>4} {:>5} {:?}", r.launched, r.kills, r.leaked, r.missiles, r.heavy, r.unseen, r.no_cover, r.untracked, r.unshot, r.missed, r.hits, r.crashes, r.by_kind.iter().map(|k| format!("{:?}:{}", k.0, k.1)).collect::<Vec<_>>()); }
|
if std::env::var("ROWS").is_ok() { eprintln!("{n:>4} {seed:>4} {:>5} {:>5} {:>5} {:>6} {:>6} | {:>12} {:>7} {:>5} {:>6} {:>6} {:>4} {:>5} {:>4} {:>5} {:?}", r.launched, r.kills, r.leaked, r.missiles, r.heavy, r.unseen, r.no_cover, r.untracked, r.unshot, r.missed, r.hits, r.crashes, r.blocked, r.scrubbed, r.by_kind.iter().map(|k| format!("{:?}:{}", k.0, k.1)).collect::<Vec<_>>()); }
|
||||||
if seed == seeds[0] && std::env::var("ROWS").is_ok() {
|
if seed == seeds[0] && std::env::var("ROWS").is_ok() {
|
||||||
eprintln!(" tally: {}", r.tally);
|
eprintln!(" tally: {}", r.tally);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
let mean = total as f64 / seeds.len() as f64;
|
let mean = total as f64 / seeds.len() as f64;
|
||||||
let k = seeds.len() as f64;
|
let k = seeds.len() as f64;
|
||||||
eprintln!("{n:>4} mean leaks {mean:.1} (clean seeds {clean}/{}), missiles {:.0}, of them heavy {:.0}", seeds.len(), missiles as f64 / k, heavy as f64 / k);
|
eprintln!("{n:>4} mean leaks {mean:.1} (clean seeds {clean}/{}), missiles {:.0}, of them heavy {:.0}, drone crashes {:.1}, interceptors lost to land {:.1}", seeds.len(), missiles as f64 / k, heavy as f64 / k, crashes as f64 / k, blocked as f64 / k);
|
||||||
means.push((n, mean));
|
means.push((n, mean));
|
||||||
}
|
}
|
||||||
means
|
means
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[ignore]
|
||||||
|
fn buried_table() {
|
||||||
|
for n in [20usize, 150] {
|
||||||
|
for seed in 1..=4u64 {
|
||||||
|
let mut s = Setup::new(n, false, seed);
|
||||||
|
s.hilly = true;
|
||||||
|
s.bury = 7.0;
|
||||||
|
let r = fly(&s);
|
||||||
|
eprintln!("buried {n} seed {seed}: sent {} kills {} leaked {} crashes {} blocked {} missiles {}", r.launched, r.kills, r.leaked, r.crashes, r.blocked, r.missiles);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[ignore]
|
||||||
|
fn hills_table() {
|
||||||
|
table_on("hills", false, 36, &[20, 50, 150], &[1, 2, 3, 4, 5, 6], |_| {}, true);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
#[ignore]
|
#[ignore]
|
||||||
fn raid_table() {
|
fn raid_table() {
|
||||||
@@ -265,6 +405,46 @@ fn a_small_cluster_loses_and_a_big_one_holds() {
|
|||||||
assert!(big.leaked <= 5, "150 systems leaked {}", big.leaked);
|
assert!(big.leaked <= 5, "150 systems leaked {}", big.leaked);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// The same on rolling hills: 150 systems still hold about as on flat land, drones do not fly into the land on
|
||||||
|
/// their own, and the interceptors do not routinely strike it (a few that blow up short of a ridge are allowed).
|
||||||
|
#[test]
|
||||||
|
fn on_hills_a_big_cluster_holds_and_nothing_routinely_hits_the_land() {
|
||||||
|
let mut s = Setup::new(150, false, 2);
|
||||||
|
s.size = 80;
|
||||||
|
s.hilly = true;
|
||||||
|
let big = fly(&s);
|
||||||
|
let mut s = Setup::new(20, false, 2);
|
||||||
|
s.size = 80;
|
||||||
|
s.hilly = true;
|
||||||
|
let small = fly(&s);
|
||||||
|
eprintln!("hills, 20 systems: {small:?}\nhills, 150 systems: {big:?}");
|
||||||
|
assert!(small.leaked >= 10, "20 systems should clearly lose on hills too, leaked {}", small.leaked);
|
||||||
|
assert!(big.leaked <= 6, "150 systems on hills leaked {}", big.leaked);
|
||||||
|
assert!(big.crashes <= 2, "drones flew into the hills: {}", big.crashes);
|
||||||
|
assert!(big.blocked * 20 <= big.missiles, "interceptors struck the land: {} of {}", big.blocked, big.missiles);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A raid from 2500 blocks over mountains, with only a disc round the player known (and chunks that load on request):
|
||||||
|
/// the flights do not fly into the land by themselves (a rare one that cannot climb a ridge in time is allowed).
|
||||||
|
#[test]
|
||||||
|
fn far_raids_over_mountains_do_not_crash_into_them() {
|
||||||
|
let (mut flown, mut crashed) = (0, 0);
|
||||||
|
for seed in [3u64, 4, 8] {
|
||||||
|
for smart in [false, true] {
|
||||||
|
let mut s = Setup::new(50, smart, seed);
|
||||||
|
s.hilly = true;
|
||||||
|
s.mountains = true;
|
||||||
|
s.dist = 2500.0;
|
||||||
|
s.disc = Some(300.0);
|
||||||
|
let r = fly(&s);
|
||||||
|
eprintln!("seed {seed} smart {smart}: {} crashed of {}: {:?}", r.crashed.len(), r.launched, r.crashed.iter().map(|c| c.0).collect::<Vec<_>>());
|
||||||
|
flown += r.launched;
|
||||||
|
crashed += r.crashed.len() as u32;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert!(crashed * 40 <= flown, "{crashed} of {flown} flew into the land");
|
||||||
|
}
|
||||||
|
|
||||||
/// What each of the new rules adds, one at a time (the raid of 36 and a heavier one of 80).
|
/// What each of the new rules adds, one at a time (the raid of 36 and a heavier one of 80).
|
||||||
#[test]
|
#[test]
|
||||||
#[ignore]
|
#[ignore]
|
||||||
@@ -295,3 +475,36 @@ fn one_raid() {
|
|||||||
eprintln!("seed {seed}: sent {} kills {} leaked {} missiles {} ticks {}", r.launched, r.kills, r.leaked, r.missiles, r.ticks);
|
eprintln!("seed {seed}: sent {} kills {} leaked {} missiles {} ticks {}", r.launched, r.kills, r.leaked, r.missiles, r.ticks);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Far launches over mountains where only a disc round the player is known: who crashes, where and how often.
|
||||||
|
/// `cargo test --release far_table -- --ignored --nocapture` (DISC=300 sets the radius, 0 for all known).
|
||||||
|
#[test]
|
||||||
|
#[ignore]
|
||||||
|
fn far_table() {
|
||||||
|
let disc: f64 = std::env::var("DISC").ok().and_then(|v| v.parse().ok()).unwrap_or(300.0);
|
||||||
|
let dist: f64 = std::env::var("DIST").ok().and_then(|v| v.parse().ok()).unwrap_or(2500.0);
|
||||||
|
let mut by_kind: HashMap<DroneKind, (u32, u32)> = HashMap::new();
|
||||||
|
let (mut launched, mut kills, mut leaked, mut tickets) = (0, 0, 0, 0);
|
||||||
|
for seed in 1..=8u64 {
|
||||||
|
let mut s = Setup::new(50, std::env::var("SMART").is_ok(), seed);
|
||||||
|
s.hilly = true;
|
||||||
|
s.mountains = true;
|
||||||
|
s.dist = dist;
|
||||||
|
s.disc = (disc > 0.0).then_some(disc);
|
||||||
|
let r = fly(&s);
|
||||||
|
launched += r.launched;
|
||||||
|
kills += r.kills;
|
||||||
|
leaked += r.leaked;
|
||||||
|
tickets += r.tickets;
|
||||||
|
for c in &r.crashed {
|
||||||
|
by_kind.entry(c.0).or_default().0 += 1;
|
||||||
|
if std::env::var("ROWS").is_ok() {
|
||||||
|
let (x, z) = (c.1.x as i32, c.1.z as i32);
|
||||||
|
eprintln!(" seed {seed} {:?} crashed at {:.0},{:.0},{:.0} ({:.0} from origin, land {}), {:.0} from its aim", c.0, c.1.x, c.1.y, c.1.z, c.1.x.hypot(c.1.z), Loader::new(&s).height(x, z), c.2);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let mut v: Vec<_> = by_kind.into_iter().collect();
|
||||||
|
v.sort_by_key(|k| k.0 as u8);
|
||||||
|
eprintln!("disc {disc} dist {dist}: launched {launched} kills {kills} leaked {leaked} chunk tickets {tickets}; crashed by kind {:?}", v.iter().map(|k| (k.0, k.1.0)).collect::<Vec<_>>());
|
||||||
|
}
|
||||||
|
|||||||
@@ -36,7 +36,7 @@ mod regress;
|
|||||||
mod sensor_tests;
|
mod sensor_tests;
|
||||||
pub use ew::EW_RADIUS;
|
pub use ew::EW_RADIUS;
|
||||||
pub use damage::{Comps, Part, PartState};
|
pub use damage::{Comps, Part, PartState};
|
||||||
pub use sight::{Ident, Track};
|
pub use sight::{Ident, LowSensor, Track, RIM_RAYS};
|
||||||
use damage::dice;
|
use damage::dice;
|
||||||
use outcome::{Impact, Outcome};
|
use outcome::{Impact, Outcome};
|
||||||
pub use units::{Family, SamKind};
|
pub use units::{Family, SamKind};
|
||||||
@@ -356,6 +356,21 @@ impl Ground {
|
|||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
self.chunks.push(c);
|
self.chunks.push(c);
|
||||||
|
// What was answered as "no chunk" there is asked again: the chunk is being loaded now.
|
||||||
|
for x in c.0 * 16..c.0 * 16 + 16 {
|
||||||
|
for z in c.1 * 16..c.1 * 16 + 16 {
|
||||||
|
if self.known.get(&(x, z)).is_some_and(|v| v.0 <= -64) {
|
||||||
|
self.known.remove(&(x, z));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for x in (c.0 * 16..c.0 * 16 + 16).step_by(8) {
|
||||||
|
for z in (c.1 * 16..c.1 * 16 + 16).step_by(8) {
|
||||||
|
if self.known.get(&(x + 4, z + 4)).is_some_and(|v| v.0 <= -64) {
|
||||||
|
self.known.remove(&(x + 4, z + 4));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
true
|
true
|
||||||
}
|
}
|
||||||
/// How many chunks are wanted so far this tick.
|
/// How many chunks are wanted so far this tick.
|
||||||
@@ -920,11 +935,14 @@ struct Nav {
|
|||||||
need: f64,
|
need: f64,
|
||||||
/// The height from which a straight dive on its target clears the land (unknown: -inf).
|
/// The height from which a straight dive on its target clears the land (unknown: -inf).
|
||||||
dive: f64,
|
dive: f64,
|
||||||
|
/// The land ahead is not known (a chunk the game does not have, or not yet): it keeps a transit height
|
||||||
|
/// above anything it could meet and comes down only once the land ahead is told of.
|
||||||
|
blind: bool,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Default for Nav {
|
impl Default for Nav {
|
||||||
fn default() -> Self {
|
fn default() -> Self {
|
||||||
Nav { need: f64::NEG_INFINITY, dive: f64::NEG_INFINITY }
|
Nav { need: f64::NEG_INFINITY, dive: f64::NEG_INFINITY, blind: false }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1492,6 +1510,11 @@ pub struct Sim {
|
|||||||
pub hits: u32,
|
pub hits: u32,
|
||||||
/// Drones that struck the land or a building short of their aim.
|
/// Drones that struck the land or a building short of their aim.
|
||||||
pub crashes: u32,
|
pub crashes: u32,
|
||||||
|
/// Systems just deployed by hand and not yet checked for standing in the land: (id, until tick).
|
||||||
|
settling: Vec<(u32, u64)>,
|
||||||
|
/// What crashed, where, and its aim (balance measurements only).
|
||||||
|
#[cfg(test)]
|
||||||
|
pub crashed: Vec<(DroneKind, DVec3, DVec3)>,
|
||||||
pub launched: u32,
|
pub launched: u32,
|
||||||
/// Explosions damage the land (primed TNT through commands).
|
/// Explosions damage the land (primed TNT through commands).
|
||||||
pub damage: bool,
|
pub damage: bool,
|
||||||
@@ -1578,6 +1601,9 @@ impl Sim {
|
|||||||
kills: 0,
|
kills: 0,
|
||||||
hits: 0,
|
hits: 0,
|
||||||
crashes: 0,
|
crashes: 0,
|
||||||
|
settling: Vec::new(),
|
||||||
|
#[cfg(test)]
|
||||||
|
crashed: Vec::new(),
|
||||||
launched: 0,
|
launched: 0,
|
||||||
damage: true,
|
damage: true,
|
||||||
seed: seed.wrapping_mul(0x2545_F491_4F6C_DD1D) | 1,
|
seed: seed.wrapping_mul(0x2545_F491_4F6C_DD1D) | 1,
|
||||||
@@ -1707,12 +1733,43 @@ impl Sim {
|
|||||||
self.fires.extinguish();
|
self.fires.extinguish();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// A system just put down by the player is looked at for a few seconds: one standing inside the land (a player
|
||||||
|
/// who fell into a chunk that had not loaded) is brought up to the surface. Buried, its interceptors would
|
||||||
|
/// strike the dirt above it and the raid's aim at it would lie under the land. Only a spot whose block is known
|
||||||
|
/// solid and whose land height is known is moved, to that height.
|
||||||
|
pub fn settle(&mut self, id: u32) {
|
||||||
|
self.settling.push((id, self.tick + 100));
|
||||||
|
}
|
||||||
|
|
||||||
|
fn step_settling(&mut self, ground: &mut Ground) {
|
||||||
|
let now = self.tick;
|
||||||
|
let sams = &mut self.sams;
|
||||||
|
self.settling.retain(|&(id, until)| {
|
||||||
|
let Some(sam) = sams.iter_mut().find(|s| s.id == id) else { return false };
|
||||||
|
let p = sam.pos;
|
||||||
|
let (x, y, z) = (p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
|
||||||
|
if ground.world.is_known_open(x, y, z, now) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if ground.world.is_known_solid(x, y, z, now) {
|
||||||
|
if let Some(g) = ground.at(p, now) {
|
||||||
|
if g > p.y + 1.5 && g < p.y + 96.0 {
|
||||||
|
sam.pos.y = g;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
now < until
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
/// One game tick.
|
/// One game tick.
|
||||||
pub fn step(&mut self, ground: &mut Ground, player: Option<DVec3>, out: &mut Out) {
|
pub fn step(&mut self, ground: &mut Ground, player: Option<DVec3>, out: &mut Out) {
|
||||||
self.tick += 1;
|
self.tick += 1;
|
||||||
self.plan_step(Some(&mut *ground), out);
|
self.plan_step(Some(&mut *ground), out);
|
||||||
self.adapt();
|
self.adapt();
|
||||||
self.release_queue(out);
|
self.step_settling(ground);
|
||||||
|
self.release_queue(ground, out);
|
||||||
self.step_drones(ground, player, out);
|
self.step_drones(ground, player, out);
|
||||||
self.step_later(ground, player, out);
|
self.step_later(ground, player, out);
|
||||||
self.step_moves(ground, out);
|
self.step_moves(ground, out);
|
||||||
@@ -1754,11 +1811,12 @@ impl Sim {
|
|||||||
let from = d.pos;
|
let from = d.pos;
|
||||||
ground.ahead(d.pos, d.vel, (120.0 / d.vel.length().max(0.05)).max(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
|
// 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.
|
// meanwhile, it goes for what is left below, not for the air where it stood; an aim inside the land (a mark
|
||||||
|
// set from a spot the player stood in the ground) is the surface over it, else the strike counts as a crash.
|
||||||
if d.flight != Flight::Falling
|
if d.flight != Flight::Falling
|
||||||
&& horizontal(d.target - d.pos).length() < 250.0
|
&& horizontal(d.target - d.pos).length() < 250.0
|
||||||
&& let Some(g) = ground.at(d.target, now)
|
&& let Some(g) = ground.at(d.target, now)
|
||||||
&& g < d.target.y - 1.5
|
&& (g < d.target.y - 1.5 || (g > d.target.y + 1.5 && !spec.decoy && spec.ballistic.is_none() && g < d.target.y + 96.0))
|
||||||
{
|
{
|
||||||
d.target.y = g;
|
d.target.y = g;
|
||||||
}
|
}
|
||||||
@@ -1820,6 +1878,10 @@ impl Sim {
|
|||||||
// Into the land or a building short of its aim: a crash, not a hit.
|
// Into the land or a building short of its aim: a crash, not a hit.
|
||||||
if landed && d.pos.distance(d.target) >= speed.max(2.0) + 6.0 {
|
if landed && d.pos.distance(d.target) >= speed.max(2.0) + 6.0 {
|
||||||
crashes.push((d.id, d.kind, d.pos, spec.warhead));
|
crashes.push((d.id, d.kind, d.pos, spec.warhead));
|
||||||
|
#[cfg(test)]
|
||||||
|
{
|
||||||
|
self.crashed.push((d.kind, d.pos, d.target));
|
||||||
|
}
|
||||||
removed.push(d.id);
|
removed.push(d.id);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
@@ -1921,7 +1983,9 @@ impl Sim {
|
|||||||
lines.push(((heading + towards).normalize_or_zero(), reach));
|
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);
|
let (need, blind) = terrain::required_height(ground, d.pos, &lines, spec.clearance, &climb);
|
||||||
|
d.nav.need = need.unwrap_or(f64::NEG_INFINITY);
|
||||||
|
d.nav.blind = blind;
|
||||||
d.nav.dive = if to_target < dive_at * 3.0 {
|
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)
|
terrain::dive_height(ground, d.pos, d.target, terrain::DIVE_MARGIN).unwrap_or(f64::NEG_INFINITY)
|
||||||
} else {
|
} else {
|
||||||
@@ -1954,13 +2018,14 @@ impl Sim {
|
|||||||
} else {
|
} else {
|
||||||
let heading = horizontal(way - d.pos).normalize_or(horizontal(old).normalize_or(DVec3::NEG_Z));
|
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.
|
// 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 base = if d.low && !d.nav.blind { d.target.y + 4.0 } else { d.target.y + spec.cruise };
|
||||||
let own = below.map_or(f64::NEG_INFINITY, |g| g + spec.clearance);
|
let own = below.map_or(f64::NEG_INFINITY, |g| g + spec.clearance);
|
||||||
let need = d.nav.need.max(own);
|
let need = d.nav.need.max(own);
|
||||||
let safe = if need.is_finite() { need + 2.0 } else { d.target.y + spec.clearance };
|
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 height = base.max(safe).max(d.nav.dive + 1.0);
|
||||||
let full = climb.pitch.tan();
|
let full = climb.pitch.tan();
|
||||||
let urgent = need.is_finite() && d.pos.y < need;
|
// Blind (land ahead unknown): to the transit height at once, not at the gentle slope of a descent plan.
|
||||||
|
let urgent = (need.is_finite() && d.pos.y < need) || (d.nav.blind && d.pos.y < base - 2.0);
|
||||||
let slope = if urgent {
|
let slope = if urgent {
|
||||||
full
|
full
|
||||||
} else {
|
} else {
|
||||||
@@ -1997,6 +2062,10 @@ impl Sim {
|
|||||||
if in_ground && d.pos.distance(d.target) >= speed.max(1.5) + 3.0 {
|
if in_ground && d.pos.distance(d.target) >= speed.max(1.5) + 3.0 {
|
||||||
if !spec.decoy {
|
if !spec.decoy {
|
||||||
crashes.push((d.id, d.kind, d.pos, spec.warhead));
|
crashes.push((d.id, d.kind, d.pos, spec.warhead));
|
||||||
|
#[cfg(test)]
|
||||||
|
{
|
||||||
|
self.crashed.push((d.kind, d.pos, d.target));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
removed.push(d.id);
|
removed.push(d.id);
|
||||||
continue;
|
continue;
|
||||||
|
|||||||
@@ -237,6 +237,9 @@ impl PartialOrd for Open {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Ticks an air start waits for the land under it to be told of.
|
||||||
|
const AIR_START_WAIT: u32 = 120;
|
||||||
|
|
||||||
impl Sim {
|
impl Sim {
|
||||||
/// Orders a raid on `objects` (at least one point). A smart raid is planned over the next ticks
|
/// Orders a raid on `objects` (at least one point). A smart raid is planned over the next ticks
|
||||||
/// (each route found in full, a few a tick) and launched when its plan is ready.
|
/// (each route found in full, a few a tick) and launched when its plan is ready.
|
||||||
@@ -649,8 +652,11 @@ impl Sim {
|
|||||||
(prices, cost)
|
(prices, cost)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// A planned raid's drones take off when their time comes.
|
/// Ticks an air start waits for the land under it to be told of.
|
||||||
pub(super) fn release_queue(&mut self, out: &mut Out) {
|
const AIR_START_WAIT: u32 = 120;
|
||||||
|
|
||||||
|
/// A planned raid's drones take off when their time comes.
|
||||||
|
pub(super) fn release_queue(&mut self, ground: &mut Ground, out: &mut Out) {
|
||||||
let now = self.tick;
|
let now = self.tick;
|
||||||
if self.queue.iter().all(|q| q.0 > now) {
|
if self.queue.iter().all(|q| q.0 > now) {
|
||||||
return;
|
return;
|
||||||
@@ -658,16 +664,41 @@ impl Sim {
|
|||||||
let (go, wait): (Vec<_>, Vec<_>) = std::mem::take(&mut self.queue).into_iter().partition(|q| q.0 <= now);
|
let (go, wait): (Vec<_>, Vec<_>) = std::mem::take(&mut self.queue).into_iter().partition(|q| q.0 <= now);
|
||||||
self.queue = wait;
|
self.queue = wait;
|
||||||
let mut cancelled = 0;
|
let mut cancelled = 0;
|
||||||
for (t, d) in go {
|
for (t, mut d) in go {
|
||||||
// A site's job leaves its site one at a time, from its stock; a destroyed or empty site cancels it.
|
// A site's job leaves its site one at a time, from its stock; a destroyed or empty site cancels it.
|
||||||
let from_site = self.sites.site_of(d.id);
|
let from_site = self.sites.site_of(d.id);
|
||||||
|
// An air start (an off-map site's drone) was planned over land nobody had read. It waits (a second or
|
||||||
|
// two) for the land under it to be known, and begins above it if that is higher than the start: else it
|
||||||
|
// is born inside a hill and crashes at once.
|
||||||
|
let air = from_site.is_some_and(|id| self.sites.list.iter().any(|s| s.id == id && s.offmap));
|
||||||
|
if air {
|
||||||
|
let clear = if d.kind.spec().ballistic.is_some() { 10.0 } else { d.kind.spec().clearance };
|
||||||
|
match ground.at(d.pos, now) {
|
||||||
|
None if d.age < AIR_START_WAIT => {
|
||||||
|
// The game has no chunk there: it is asked to load the ones round the start (and kept a while).
|
||||||
|
let c = ((d.pos.x.floor() as i32) >> 4, (d.pos.z.floor() as i32) >> 4);
|
||||||
|
for (dx, dz) in [(0, 0), (1, 0), (-1, 0), (0, 1), (0, -1)] {
|
||||||
|
ground.want_chunk((c.0 + dx, c.1 + dz));
|
||||||
|
}
|
||||||
|
d.age += 1;
|
||||||
|
self.queue.push((t, d));
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
Some(g) if d.pos.y < g + clear => d.pos.y = g + clear,
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
d.age = 0;
|
||||||
|
}
|
||||||
let slot = self.site_slot(d.id);
|
let slot = self.site_slot(d.id);
|
||||||
if let (Some(site), sites::Slot::Go | sites::Slot::Air) = (from_site, &slot) {
|
if let (Some(site), sites::Slot::Go | sites::Slot::Air) = (from_site, &slot) {
|
||||||
self.scout_launch(d.id, site, d.kind, d.pos);
|
self.scout_launch(d.id, site, d.kind, d.pos);
|
||||||
}
|
}
|
||||||
match slot {
|
match slot {
|
||||||
// Free: not a site's job. Air: an off-map site's drone, already in flight position.
|
// Free: not a site's job. Air: an off-map site's drone, already in flight position.
|
||||||
sites::Slot::Free | sites::Slot::Air => {}
|
sites::Slot::Free => {}
|
||||||
|
// The air start was planned over land nobody had read; if it is read by now and the land there is
|
||||||
|
// higher than the start, it begins above it (else it is born inside a hill and crashes at once).
|
||||||
|
sites::Slot::Air => {}
|
||||||
sites::Slot::Busy => {
|
sites::Slot::Busy => {
|
||||||
self.queue.push((t, d));
|
self.queue.push((t, d));
|
||||||
continue;
|
continue;
|
||||||
@@ -677,6 +708,14 @@ impl Sim {
|
|||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
sites::Slot::Go => {
|
sites::Slot::Go => {
|
||||||
|
// On a slope the pad's side or the muzzle's far end can stand in the land that rises there: the
|
||||||
|
// drone leaves from above the land at its own column, not from inside the hill.
|
||||||
|
if let Some(g) = ground.at(d.pos, now)
|
||||||
|
&& d.pos.y < g + 1.5
|
||||||
|
&& g < d.pos.y + 40.0
|
||||||
|
{
|
||||||
|
d.pos.y = g + 1.5;
|
||||||
|
}
|
||||||
let dir = d.vel.normalize_or_zero();
|
let dir = d.vel.normalize_or_zero();
|
||||||
out.sound(d.kind.launch_sound(), d.pos, 1.0, 1.0);
|
out.sound(d.kind.launch_sound(), d.pos, 1.0, 1.0);
|
||||||
out.particles("minecraft:flame", d.pos - dir * 1.5, 0.15, -dir * 0.1, 0.02, 4);
|
out.particles("minecraft:flame", d.pos - dir * 1.5, 0.15, -dir * 0.1, 0.02, 4);
|
||||||
|
|||||||
@@ -1594,3 +1594,78 @@ fn mass_strikes_keep_fires_effects_and_lights_bounded() {
|
|||||||
assert!(sim.fires.is_empty(), "fires burn for ever");
|
assert!(sim.fires.is_empty(), "fires burn for ever");
|
||||||
let _ = commands;
|
let _ = commands;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// A system put down inside the land (the player stood in the ground) is brought up to the surface, and its
|
||||||
|
/// interceptors then leave the launcher; one on the surface or in the open air is left where it is.
|
||||||
|
#[test]
|
||||||
|
fn a_system_deployed_inside_the_land_comes_up() {
|
||||||
|
let land = sites::testland::Land(|_, _| 63);
|
||||||
|
let mut sim = Sim::new(1);
|
||||||
|
let mut ground = Ground::default();
|
||||||
|
let mut out = Out::default();
|
||||||
|
let buried = sim.id();
|
||||||
|
sim.sams.push(Sam::new(buried, SamKind::Patriot, DVec3::new(20.0, 56.0, 17.0), 0.0));
|
||||||
|
sim.settle(buried);
|
||||||
|
let open = sim.id();
|
||||||
|
sim.sams.push(Sam::new(open, SamKind::S400, DVec3::new(60.0, 63.0, 17.0), 0.0));
|
||||||
|
sim.settle(open);
|
||||||
|
let air = sim.id();
|
||||||
|
sim.sams.push(Sam::new(air, SamKind::Tor, DVec3::new(90.0, 70.0, 17.0), 0.0));
|
||||||
|
sim.settle(air);
|
||||||
|
for _ in 0..60 {
|
||||||
|
sites::testland::step(&mut sim, &mut ground, &land, &mut out);
|
||||||
|
}
|
||||||
|
let y = |id| sim.sams.iter().find(|s| s.id == id).unwrap().pos.y;
|
||||||
|
assert_eq!(y(buried), 63.0, "a buried system comes up to the surface");
|
||||||
|
assert_eq!(y(open), 63.0);
|
||||||
|
assert_eq!(y(air), 70.0, "one in the open air is not moved");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An aim point inside the land (an object marked where the player stood in the ground) is the surface over it:
|
||||||
|
/// a drone that arrives is a hit, not a crash into the land short of its aim.
|
||||||
|
#[test]
|
||||||
|
fn a_drone_at_an_aim_under_the_land_hits() {
|
||||||
|
let (mut ground, land) = (Ground::default(), sites::testland::Land(|_, _| 63));
|
||||||
|
let mut sim = Sim::new(5);
|
||||||
|
sim.targets.push(DVec3::new(0.0, 56.0, 0.0));
|
||||||
|
sim.target_health.push(100.0);
|
||||||
|
let d = sim.make_drone(DroneKind::Geran3, DVec3::new(-400.0, 100.0, 0.0), DVec3::X, DVec3::new(0.0, 56.0, 0.0));
|
||||||
|
sim.drones.push(d);
|
||||||
|
let mut out = Out::default();
|
||||||
|
for _ in 0..1200 {
|
||||||
|
sites::testland::step(&mut sim, &mut ground, &land, &mut out);
|
||||||
|
if sim.drones.is_empty() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert_eq!((sim.hits, sim.crashes), (1, 0), "hits {} crashes {}", sim.hits, sim.crashes);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Over land the game has not told of, a low-flying drone does not hug the height of its aim: it holds the transit
|
||||||
|
/// height (the cruise height over the aim) and comes down only once the land ahead is known.
|
||||||
|
#[test]
|
||||||
|
fn over_unknown_land_a_low_flight_holds_its_transit_height() {
|
||||||
|
let aim = DVec3::new(0.0, 64.0, 3000.0);
|
||||||
|
let fly = |known: bool| {
|
||||||
|
let mut sim = Sim::new(4);
|
||||||
|
let mut d = sim.make_drone(DroneKind::Kh101, DVec3::new(0.0, 70.0, 0.0), DVec3::Z, aim);
|
||||||
|
d.low = true;
|
||||||
|
d.route = vec![aim];
|
||||||
|
sim.drones.push(d);
|
||||||
|
let (mut ground, land) = (Ground::default(), sites::testland::Land(|_, _| 64));
|
||||||
|
let mut out = Out::default();
|
||||||
|
for _ in 0..300 {
|
||||||
|
if known {
|
||||||
|
sites::testland::step(&mut sim, &mut ground, &land, &mut out);
|
||||||
|
} else {
|
||||||
|
sim.step(&mut ground, None, &mut out);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
sim.drones[0].pos.y
|
||||||
|
};
|
||||||
|
let spec = DroneKind::Kh101.spec();
|
||||||
|
let blind = fly(false);
|
||||||
|
let seen = fly(true);
|
||||||
|
assert!(blind > aim.y + spec.cruise - 8.0, "blind and low: {blind}");
|
||||||
|
assert!(seen < aim.y + 20.0, "over land it knows it keeps hugging it: {seen}");
|
||||||
|
}
|
||||||
|
|||||||
@@ -93,6 +93,97 @@ pub(super) fn reach(sam: &Sam, kind: DroneKind, height: f64) -> f64 {
|
|||||||
radar.min(horizon).max(NEAR)
|
radar.min(horizon).max(NEAR)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// The low flyer the command map shows the radars' coverage for: a Shahed over the land.
|
||||||
|
const LOW_KIND: DroneKind = DroneKind::Shahed;
|
||||||
|
|
||||||
|
/// A radar as the command map sees it: where its antenna is and how far it reaches a low flyer.
|
||||||
|
#[derive(Clone, Copy)]
|
||||||
|
pub struct LowSensor {
|
||||||
|
pub id: u32,
|
||||||
|
pub ant: DVec3,
|
||||||
|
/// The ground under the unit (a place whose land is unknown is taken as level with it).
|
||||||
|
pub base: f64,
|
||||||
|
pub reach: f64,
|
||||||
|
/// Its horizon is known: the land hides what it hides.
|
||||||
|
pub terrain: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Rays of `Sim::low_rim`.
|
||||||
|
pub const RIM_RAYS: usize = RAYS;
|
||||||
|
|
||||||
|
impl Ground {
|
||||||
|
/// The land's height at `p` from what the game has already answered; asks for nothing.
|
||||||
|
pub fn peek(&self, p: DVec3) -> Option<f64> {
|
||||||
|
const LAT: i32 = super::terrain::LATTICE;
|
||||||
|
let k = (p.x.floor() as i32, p.z.floor() as i32);
|
||||||
|
let hit = self.known.get(&k).or_else(|| {
|
||||||
|
self.known.get(&(k.0.div_euclid(LAT) * LAT + LAT / 2, k.1.div_euclid(LAT) * LAT + LAT / 2))
|
||||||
|
});
|
||||||
|
hit.and_then(|&(y, _)| (y > -64).then_some(f64::from(y)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Sim {
|
||||||
|
/// A radar for a unit of `kind` at `pos` as the map draws it; `id`: the unit it is (its parts and horizon), None for a ghost.
|
||||||
|
pub fn low_sensor(&self, kind: SamKind, pos: DVec3, id: Option<u32>) -> Option<LowSensor> {
|
||||||
|
let spec = kind.spec();
|
||||||
|
if spec.sensor <= 0.0 {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
let fit = id.and_then(|i| self.sams.iter().find(|s| s.id == i)).map_or(1.0, |s| s.radar_fit());
|
||||||
|
let height = LOW_KIND.spec().clearance;
|
||||||
|
let radar = spec.sensor * fit * LOW_KIND.rcs().powf(0.25);
|
||||||
|
let reach = radar.min(HORIZON * (spec.mast.sqrt() + height.sqrt())).max(NEAR);
|
||||||
|
let terrain = id.is_some_and(|i| self.horizons.contains_key(&i));
|
||||||
|
Some(LowSensor { id: id.unwrap_or(u32::MAX), ant: pos + DVec3::Y * spec.mast, base: pos.y, reach, terrain })
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The radars that are up now.
|
||||||
|
pub fn low_sensors(&self) -> Vec<LowSensor> {
|
||||||
|
self.sams.iter().filter(|s| s.radar_up()).filter_map(|s| self.low_sensor(s.kind, s.pos, Some(s.id))).collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether the radar sees a low flyer (over the land) at the column (`x`, `z`): in its reach and not behind the land.
|
||||||
|
pub fn low_sees(&self, ground: &Ground, s: &LowSensor, x: f64, z: f64) -> bool {
|
||||||
|
let (dx, dz) = (x - s.ant.x, z - s.ant.z);
|
||||||
|
let d2 = dx * dx + dz * dz;
|
||||||
|
if d2 > s.reach * s.reach {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if !s.terrain || d2 <= NEAR * NEAR {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
let Some(h) = self.horizons.get(&s.id) else { return true };
|
||||||
|
let g = ground.peek(DVec3::new(x, 0.0, z)).unwrap_or(s.base);
|
||||||
|
!h.hides(s.ant, DVec3::new(x, g + LOW_KIND.spec().clearance, z))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Per ray round the radar, how far a low flyer is seen before the land first hides it (at most the reach).
|
||||||
|
pub fn low_rim(&self, ground: &Ground, s: &LowSensor) -> Vec<f32> {
|
||||||
|
let mut out = vec![s.reach as f32; RAYS];
|
||||||
|
let Some(h) = self.horizons.get(&s.id).filter(|_| s.terrain) else { return out };
|
||||||
|
let steps = ((s.reach / STEP) as usize).min(h.rays[0].len());
|
||||||
|
let height = LOW_KIND.spec().clearance;
|
||||||
|
for (r, o) in out.iter_mut().enumerate() {
|
||||||
|
let a = r as f64 / RAYS as f64 * TAU;
|
||||||
|
let (sx, sz) = (a.sin(), a.cos());
|
||||||
|
for k in 1..=steps {
|
||||||
|
let d = k as f64 * STEP;
|
||||||
|
if d <= NEAR {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
let p = DVec3::new(s.ant.x + sx * d, 0.0, s.ant.z + sz * d);
|
||||||
|
let y = ground.peek(p).unwrap_or(s.base) + height - s.ant.y;
|
||||||
|
if ((y / d) as f32) < h.rays[r][k - 1] {
|
||||||
|
*o = (d - STEP).max(NEAR) as f32;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// How a kind's radar looks round.
|
/// How a kind's radar looks round.
|
||||||
pub(super) struct Scan {
|
pub(super) struct Scan {
|
||||||
/// Ticks for the beam to go round.
|
/// Ticks for the beam to go round.
|
||||||
@@ -367,3 +458,74 @@ impl Sim {
|
|||||||
best
|
best
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod low_view_tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
/// A radar on level land (70) with a hill east of it (140 high, x 128..160): the east ray is cut at the hill, the others are not.
|
||||||
|
fn world() -> (Sim, Ground, u32) {
|
||||||
|
let mut sim = Sim::new(3);
|
||||||
|
let id = sim.id();
|
||||||
|
sim.sams.push(Sam::new(id, SamKind::Buk, DVec3::new(0.0, 70.0, 0.0), 0.0));
|
||||||
|
let mut ground = Ground::default();
|
||||||
|
let cols: Vec<(i32, i32, i32)> = (-60..60).map(|k| (k * 16, 0, if (128..160).contains(&(k * 16)) { 140 } else { 70 })).collect();
|
||||||
|
ground.answer(cols, 0);
|
||||||
|
let h = Horizon::build(antenna(&sim.sams[0]), sim.sams[0].kind.spec().sensor, &mut ground, 0);
|
||||||
|
sim.horizons.insert(id, h);
|
||||||
|
(sim, ground, id)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn the_land_cuts_the_coverage_edge_behind_a_hill() {
|
||||||
|
let (sim, ground, id) = world();
|
||||||
|
let ls = sim.low_sensor(SamKind::Buk, DVec3::new(0.0, 70.0, 0.0), Some(id)).unwrap();
|
||||||
|
assert!(ls.terrain && ls.reach > 200.0, "{}", ls.reach);
|
||||||
|
let rim = sim.low_rim(&ground, &ls);
|
||||||
|
let east = rim[RIM_RAYS / 4];
|
||||||
|
assert!((128.0..=176.0).contains(&east), "east edge {east}");
|
||||||
|
// Rays whose land is unknown hide nothing: the whole reach.
|
||||||
|
assert_eq!(rim[0], ls.reach as f32);
|
||||||
|
assert_eq!(rim[RIM_RAYS * 3 / 4], ls.reach as f32);
|
||||||
|
assert!(sim.low_sees(&ground, &ls, -200.0, 0.0));
|
||||||
|
assert!(sim.low_sees(&ground, &ls, 100.0, 0.0));
|
||||||
|
assert!(!sim.low_sees(&ground, &ls, 200.0, 0.0), "behind the hill");
|
||||||
|
assert!(!sim.low_sees(&ground, &ls, ls.reach + 50.0, 0.0), "out of reach");
|
||||||
|
// A ghost (no horizon) sees the whole circle.
|
||||||
|
let ghost = sim.low_sensor(SamKind::Buk, DVec3::new(0.0, 70.0, 0.0), None).unwrap();
|
||||||
|
assert!(sim.low_sees(&ground, &ghost, 200.0, 0.0));
|
||||||
|
}
|
||||||
|
|
||||||
|
// The map's tint asks `low_sees` for a cell of a coarse grid at every radar that reaches it, and the edges
|
||||||
|
// ask `low_rim`: with a Polygon's worth of systems both stay cheap (native time, a few ms; wasm is a few times that).
|
||||||
|
#[test]
|
||||||
|
fn coverage_of_128_systems_is_cheap() {
|
||||||
|
let (mut sim, mut ground, _) = world();
|
||||||
|
for i in 0..127 {
|
||||||
|
let id = sim.id();
|
||||||
|
let pos = DVec3::new((i % 16) as f64 * 40.0 - 300.0, 70.0, (i / 16) as f64 * 40.0 - 150.0);
|
||||||
|
sim.sams.push(Sam::new(id, SamKind::Buk, pos, 0.0));
|
||||||
|
let k = sim.sams.len() - 1;
|
||||||
|
let h = Horizon::build(antenna(&sim.sams[k]), sim.sams[k].kind.spec().sensor, &mut ground, 0);
|
||||||
|
sim.horizons.insert(id, h);
|
||||||
|
}
|
||||||
|
let sensors = sim.low_sensors();
|
||||||
|
assert_eq!(sensors.len(), 128);
|
||||||
|
let t = std::time::Instant::now();
|
||||||
|
let mut seen = 0;
|
||||||
|
for cy in 0..28 {
|
||||||
|
for cx in 0..36 {
|
||||||
|
let (x, z) = (cx as f64 * 30.0 - 500.0, cy as f64 * 30.0 - 400.0);
|
||||||
|
// Worst case for the early exit: a cell no radar sees is tested against all that reach it.
|
||||||
|
if sensors.iter().any(|s| sim.low_sees(&ground, s, x, z)) {
|
||||||
|
seen += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let tint = t.elapsed();
|
||||||
|
let t = std::time::Instant::now();
|
||||||
|
let rims: usize = sensors.iter().take(3).map(|s| sim.low_rim(&ground, s).len()).sum();
|
||||||
|
eprintln!("tint of 1008 cells: {tint:?} ({seen} seen); 3 rims: {:?} ({rims})", t.elapsed());
|
||||||
|
assert!(seen > 0 && tint.as_millis() < 100, "{tint:?}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
@@ -805,6 +805,25 @@ mod tests {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// An off-map site's drones start in the air at the height planned over land nobody had read; if the land
|
||||||
|
/// turns out higher there by the time they leave, they start above it instead of being born inside the hill.
|
||||||
|
#[test]
|
||||||
|
fn an_off_map_start_over_a_hill_begins_above_it() {
|
||||||
|
let (mut ground, mut out) = (Ground::default(), Out::default());
|
||||||
|
let mut sim = Sim::new(3);
|
||||||
|
sim.order_raid(&order(Approach::TwoSectors, 300.0), &[DVec3::new(0.0, 70.0, 0.0)], &mut out);
|
||||||
|
while sim.planning() {
|
||||||
|
sim.step(&mut ground, None, &mut out);
|
||||||
|
}
|
||||||
|
assert!(sim.sites.list.iter().all(|s| s.offmap));
|
||||||
|
let land = Land(|x, z| if x * x + z * z > 200 * 200 { 150 } else { 64 });
|
||||||
|
for _ in 0..500 {
|
||||||
|
step(&mut sim, &mut ground, &land, &mut out);
|
||||||
|
assert!(sim.drones.iter().all(|d| d.age > 3 || d.pos.y > 148.0 || d.flight == Flight::Ballistic), "a drone started inside the hill");
|
||||||
|
}
|
||||||
|
assert!(sim.launched > 0);
|
||||||
|
}
|
||||||
|
|
||||||
/// Chunks that load on request: a column of a chunk asked for answers `PENDING` until `delay` ticks
|
/// Chunks that load on request: a column of a chunk asked for answers `PENDING` until `delay` ticks
|
||||||
/// after the first request, and a chunk never asked for is not there (-64).
|
/// after the first request, and a chunk never asked for is not there (-64).
|
||||||
struct Lazy {
|
struct Lazy {
|
||||||
|
|||||||
@@ -10,7 +10,7 @@
|
|||||||
use super::*;
|
use super::*;
|
||||||
|
|
||||||
/// Land heights are sampled at the centres of cells this wide.
|
/// Land heights are sampled at the centres of cells this wide.
|
||||||
const LATTICE: i32 = 8;
|
pub(super) const LATTICE: i32 = 8;
|
||||||
/// Land questions waiting at once: flights ask for more than a tick can send, and wait.
|
/// Land questions waiting at once: flights ask for more than a tick can send, and wait.
|
||||||
const ASK_MAX: usize = 192;
|
const ASK_MAX: usize = 192;
|
||||||
|
|
||||||
@@ -168,6 +168,9 @@ pub(super) fn clamp_pitch(v: DVec3, lo: f64, hi: f64, level: DVec3) -> DVec3 {
|
|||||||
horizontal(v).normalize_or(level) * pitch.cos() + DVec3::Y * pitch.sin()
|
horizontal(v).normalize_or(level) * pitch.cos() + DVec3::Y * pitch.sin()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Chunks a tick the flights' look-ahead may ask the game to load (the rest of the budget is the launch-site search's).
|
||||||
|
const CHUNK_BUDGET: usize = 46;
|
||||||
|
|
||||||
/// Distances ahead where the land is sampled.
|
/// Distances ahead where the land is sampled.
|
||||||
const REACH: [f64; 21] = [
|
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,
|
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,
|
||||||
@@ -177,8 +180,10 @@ const REACH: [f64; 21] = [
|
|||||||
/// The height a flight must be at *now* to clear the land along each of `lines` (a unit horizontal direction and
|
/// 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
|
/// 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.
|
/// 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> {
|
pub(super) fn required_height(ground: &mut Ground, pos: DVec3, lines: &[(DVec3, f64)], clear: f64, climb: &Climb) -> (Option<f64>, bool) {
|
||||||
let mut need: Option<f64> = None;
|
let mut need: Option<f64> = None;
|
||||||
|
// Land nobody has told of within the first half of the look-ahead: the flight is blind there.
|
||||||
|
let mut blind = false;
|
||||||
for &(dir, len) in lines {
|
for &(dir, len) in lines {
|
||||||
for &s in REACH.iter().chain(&[900.0]) {
|
for &s in REACH.iter().chain(&[900.0]) {
|
||||||
if s > len {
|
if s > len {
|
||||||
@@ -187,10 +192,20 @@ pub(super) fn required_height(ground: &mut Ground, pos: DVec3, lines: &[(DVec3,
|
|||||||
if let Some(g) = ground.land(pos + dir * s) {
|
if let Some(g) = ground.land(pos + dir * s) {
|
||||||
let h = g + clear - climb.gain(s);
|
let h = g + clear - climb.gain(s);
|
||||||
need = Some(need.map_or(h, |n: f64| n.max(h)));
|
need = Some(need.map_or(h, |n: f64| n.max(h)));
|
||||||
|
} else {
|
||||||
|
if s <= len * 0.5 {
|
||||||
|
blind = true;
|
||||||
|
}
|
||||||
|
// Land the game has not told of ahead: its chunk is asked for (it loads in a couple of seconds, a flight
|
||||||
|
// is that far from it), so the pull-up starts from the first known column and not at the ridge.
|
||||||
|
if ground.chunks_wanted() < CHUNK_BUDGET {
|
||||||
|
let p = pos + dir * s;
|
||||||
|
ground.want_chunk(((p.x.floor() as i32) >> 4, (p.z.floor() as i32) >> 4));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
need
|
(need, blind)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The least height to start from, over here, so that the straight line down to `target` stays `margin` over the
|
/// The least height to start from, over here, so that the straight line down to `target` stays `margin` over the
|
||||||
|
|||||||
Reference in New Issue
Block a user