//! Air defence can be hit too: a blast near a system damages it (it turns //! slower, sees less, hits worse, smokes, then burns), a destroyed one leaves //! a burning wreck and its magazine cooks off — the more missiles or shells //! were left in it, the bigger the blast and the longer the secondary ones. //! Marked objects take the same blasts. use super::*; /// By blast power (as `explode` grades it): how far it reaches a vehicle, and how hard it hits one at the centre. const REACH: [f64; 5] = [4.0, 7.0, 12.0, 18.0, 26.0]; const HIT: [f64; 5] = [0.2, 0.45, 0.85, 1.25, 1.7]; /// A unit's working parts, each 1 (whole) to 0 (failed); the hull is `Sam::health` (0 destroys it). #[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum Part { /// The radar (or optics): its reach and its scan. Sensor, /// The aiming drive of the launcher or turret. Mount, /// The launcher: cells, reload. Launcher, /// The gun: it jams. Gun, /// The running gear: it can't march when it fails. Tracks, /// The data link: no network when it fails. Comms, } #[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum PartState { Ok, Damaged, Failed, } impl Part { pub const ALL: [Part; 6] = [Part::Sensor, Part::Mount, Part::Launcher, Part::Gun, Part::Tracks, Part::Comms]; pub fn name(self) -> &'static str { match self { Part::Sensor => "РЛС", Part::Mount => "привод наведения", Part::Launcher => "пусковая", Part::Gun => "орудие", Part::Tracks => "ходовая", Part::Comms => "связь", } } pub fn short(self) -> &'static str { match self { Part::Sensor => "РЛС", Part::Mount => "Прив", Part::Launcher => "ПУ", Part::Gun => "Ор", Part::Tracks => "Ход", Part::Comms => "Св", } } fn index(self) -> usize { self as usize } /// Whether this kind of unit has the part at all. pub fn on(self, kind: SamKind) -> bool { let spec = kind.spec(); match self { Part::Sensor => spec.sensor > 0.0, Part::Mount => kind.armed() && kind != SamKind::Light && (spec.missile.is_some() || spec.gun.is_some()), Part::Launcher => spec.missile.is_some(), Part::Gun => spec.gun.is_some(), Part::Tracks => kind.mobile(), Part::Comms => true, } } /// Where the part is on the vehicle: right, up, back, blocks at scale 1 (the nose points to -back). fn place(self, spec: &super::units::SamSpec) -> (f64, f64, f64) { match self { Part::Sensor => (0.0, spec.mast / spec.scale, 1.0), Part::Mount => (0.0, spec.mount.0, -spec.mount.1), Part::Launcher => (0.0, spec.mount.0, -spec.mount.1 + 0.4), Part::Gun => (0.0, spec.mount.0, -spec.mount.1 - 1.0), Part::Tracks => (0.0, 0.3, 0.0), Part::Comms => (0.0, 1.6, 1.8), } } } /// Below this a part is damaged (works worse), at 0 it has failed. pub const WORN: f64 = 0.6; /// The state of every part: `Part::ALL`'s order. #[derive(Clone, Copy, PartialEq, Debug)] pub struct Comps(pub [f64; 6]); impl Default for Comps { fn default() -> Self { Self([1.0; 6]) } } impl Comps { pub fn get(&self, p: Part) -> f64 { self.0[p.index()] } pub fn state(&self, p: Part) -> PartState { let v = self.get(p); if v <= 0.0 { PartState::Failed } else if v < WORN { PartState::Damaged } else { PartState::Ok } } pub fn whole(&self) -> bool { self.0.iter().all(|&v| v >= 1.0) } /// Parts of this kind that are not whole, as "РЛС 40%, ходовая отказ". pub fn describe(&self, kind: SamKind) -> String { Part::ALL .iter() .filter(|p| p.on(kind) && self.get(**p) < 1.0) .map(|p| match self.state(*p) { PartState::Failed => format!("{} отказ", p.short()), _ => format!("{} {:.0}%", p.short(), self.get(*p) * 100.0), }) .collect::>() .join(", ") } /// The weakest part alone, for a one-line status (the full list is on the monitor). pub fn worst(&self, kind: SamKind) -> String { Part::ALL .iter() .filter(|p| p.on(kind) && self.get(**p) < 1.0) .min_by(|a, b| self.get(**a).total_cmp(&self.get(**b))) .map(|p| match self.state(*p) { PartState::Failed => format!("{} отказ", p.short()), _ => format!("{} {:.0}%", p.short(), self.get(*p) * 100.0), }) .unwrap_or_default() } } /// Health points an object loses at the centre of a blast. const OBJECT_HIT: [f64; 5] = [2.0, 6.0, 14.0, 26.0, 40.0]; /// Three cheap game samples across a hull. Known cover leaves residual splash; /// unknown geometry keeps the previous unattenuated damage (not a claim of air). /// Zero async wait freezes the pre-destruction cache and avoids late double damage. fn blast_exposure(ground: &Ground, from: DVec3, centre: DVec3, size: f64, now: u64) -> f64 { let across = horizontal(centre - from).cross(DVec3::Y).normalize_or(DVec3::X) * size; [centre, centre - across, centre + across].into_iter().map(|to| { if ground.world.blast_cover(from, to, now) == Some(true) { 0.15 } else { 1.0 } }).sum::() / 3.0 } impl MissileKind { /// The explosive a missile left in a burning launcher adds (TNT). fn charge(self) -> f64 { match self { MissileKind::Pac3 => 0.8, MissileKind::M57e6 => 0.45, MissileKind::M48n6 => 1.8, MissileKind::M77n6 => 2.2, MissileKind::IrisT => 0.6, MissileKind::Amraam => 0.5, MissileKind::M9m317 => 1.2, MissileKind::M9m338 => 0.4, MissileKind::P1sun => 0.1, } } } /// A strike that ends farther than this from its aim point misses (the lethal radius of a point target). pub(super) const MISS_RADIUS: f64 = 3.0; /// A system's hull, as a cylinder: its radius (× scale) and how far above the ground it reaches (× scale). const HULL_RADIUS: f64 = 2.2; const HULL_TOP: f64 = 3.0; impl DroneKind { /// Strike accuracy: the CEP (blocks; half the strikes land within it, the scatter is Rayleigh) /// and the share of strikes with a rare gross navigation fault, which lands beyond `MISS_RADIUS`. pub(super) fn accuracy(self) -> (f64, f64) { match self { DroneKind::Shahed => (1.2, 0.03), DroneKind::Geran3 => (1.0, 0.03), DroneKind::Lancet => (0.8, 0.02), DroneKind::Gerbera => (1.5, 0.04), DroneKind::Kh101 => (1.3, 0.05), DroneKind::Kalibr => (1.3, 0.05), DroneKind::Kh22 => (1.6, 0.06), DroneKind::Zircon => (1.5, 0.06), DroneKind::Iskander => (1.4, 0.06), DroneKind::Kinzhal => (1.5, 0.06), // The bus and its blocks: the blocks are aimed by the split, so only the bus's own error applies. DroneKind::Oreshnik | DroneKind::OreshnikBlock | DroneKind::OreshnikSub => (1.6, 0.08), } } } impl Sim { /// Apply combat consequences first, independently of whether a recorder is active. pub(super) fn emit_combat_event(&mut self, pos: DVec3, kind: record::EventKind) { match kind { record::EventKind::Crash { power, .. } => self.ignite(pos, power, None), record::EventKind::Hit { power, sam, .. } => { let host = sam.and_then(|(_, i)| self.sams.get(i)).map(|s| s.id); self.ignite(pos, power.max(1), host) } record::EventKind::SamLost { sam, .. } => self.ignite(pos, 2, Some(sam)), record::EventKind::Strike { result, .. } if record::strike_power(result) > 0 => self.ignite(pos, record::strike_power(result), None), _ => {} } self.record_event(pos, kind); } /// The aim error of a new strike: drawn once from the seed, the drone keeps it for its whole flight. pub(super) fn aim_error(&mut self, kind: DroneKind) -> DVec3 { let (cep, gross) = kind.accuracy(); let angle = self.rng.f() * std::f64::consts::TAU; let r = if self.rng.chance(gross) { MISS_RADIUS + cep * (0.5 + 2.5 * self.rng.f()) } else { // Rayleigh with its median at the CEP. let u = 1.0 - self.rng.f(); cep * (-2.0 * u.ln() / (2.0 * std::f64::consts::LN_2)).sqrt() }; DVec3::new(angle.cos() * r, 0.0, angle.sin() * r) } /// An armed warhead reached `pos` (its last step was `vel`): a system whose hull it swept through is /// destroyed at once, whatever the blast would have done to it. A near miss is only splash. pub(super) fn direct_hit(&mut self, pos: DVec3, vel: DVec3, tnt: u32, out: &mut Out) { if !self.damage || tnt == 0 { return; } let from = pos - vel; for i in 0..self.sams.len() { let sam = &self.sams[i]; if !sam.alive() { continue; } let s = sam.kind.spec().scale; let hit = (0..=8).any(|k| { let p = from.lerp(pos, k as f64 / 8.0); let across = DVec3::new(p.x - sam.pos.x, 0.0, p.z - sam.pos.z).length(); across <= HULL_RADIUS * s && p.y >= sam.pos.y - 1.0 && p.y <= sam.pos.y + HULL_TOP * s }); if hit { self.destroy(i, out); } } } /// A blast of `power` (0 to 4) at `pos`: the systems and objects round it take damage. pub(super) fn blast_damage(&mut self, pos: DVec3, power: usize, ground: &Ground, out: &mut Out) { let (reach, hit) = (REACH[power], HIT[power]); let mut destroyed = Vec::new(); for (i, sam) in self.sams.iter_mut().enumerate() { if !sam.alive() { continue; } // The vehicle is a few blocks long: measured from its hull. let d = (sam.pos.distance(pos) - 2.5).max(0.0); if d >= reach { continue; } let k = 1.0 - d / reach; let cover = blast_exposure(ground, pos, sam.pos + DVec3::Y * (1.5 * sam.kind.spec().scale), sam.kind.spec().scale, self.tick); let before = sam.health; sam.health -= cover * hit * k * k * if d < 1.0 { 1.5 } else { 1.0 }; if sam.health <= 0.0 { destroyed.push(i); continue; } if before >= 0.5 && sam.health < 0.5 { out.messages.push(format!("{} №{} повреждён", sam.kind.name(), i + 1)); } // The parts take the blast by their own distance from it: the side it came from decides which. let spec = sam.kind.spec(); let rot = DQuat::from_rotation_y(sam.heading); for part in Part::ALL { if !part.on(sam.kind) { continue; } let (x, y, back) = part.place(spec); let at = sam.pos + rot * DVec3::new(x, y, back) * spec.scale; let size = if part == Part::Tracks { 2.5 } else { 1.0 }; let dp = (at.distance(pos) - size).max(0.0); if dp >= reach { continue; } let kp = 1.0 - dp / reach; let roll = dice(self.seed, self.tick, sam.id as u64, part as u64); // The parts are softer than the hull: a blast the hull survives can still put one out. let dmg = cover * hit * kp * kp * (0.7 + roll) * 1.5 * if dp < 1.0 { 1.4 } else { 1.0 }; let was = sam.comps.state(part); let v = &mut sam.comps.0[part as usize]; *v = (*v - dmg).max(0.0); let now = sam.comps.state(part); if now != was && now != PartState::Ok { let word = if now == PartState::Failed { "отказал(а)" } else { "повреждён(а)" }; out.messages.push(format!("{} №{}: {} {word}", sam.kind.name(), i + 1, part.name())); } } sam.fit_cells(); } for i in destroyed { self.destroy(i, out); } for (i, t) in self.targets.iter().enumerate() { let d = t.distance(pos); let r = reach * 1.6; if d < r { if let Some(h) = self.target_health.get_mut(i) { let before = *h; let cover = blast_exposure(ground, pos, *t + DVec3::Y * 0.8, 0.75, self.tick); *h = (*h - cover * OBJECT_HIT[power] * (1.0 - d / r)).max(0.0); if before > 0.0 && *h <= 0.0 { out.messages.push(format!("ОБЪЕКТ №{} УНИЧТОЖЕН", i + 1)); } } } } } /// System `i` destroyed: its magazine goes up, the wreck burns. fn destroy(&mut self, i: usize, out: &mut Out) { let now = self.tick; let sam = &mut self.sams[i]; sam.health = 0.0; sam.burn = 900; sam.state = SamState::Destroyed; sam.target = None; sam.gun_target = None; sam.reloading = 0; sam.tracks.clear(); sam.seen.clear(); sam.own.clear(); let spec = sam.kind.spec(); let missiles = sam.missiles; let bursts = sam.bursts; sam.missiles = 0; sam.bursts = 0; let pos = sam.pos + DVec3::Y; out.messages.push(format!("{} №{} УНИЧТОЖЕН", sam.kind.name(), i + 1)); let (id, kind) = (sam.id, sam.kind); // A depot's stock (or a truck's load) goes up with it. let stock = if matches!(self.sams[i].kind, SamKind::Depot | SamKind::Tzm) { self.sams[i].cargo } else { 0 }; self.sams[i].cargo = 0; let typed = self.sams[i].ground_stock + self.sams[i].air_48n6_stock; self.sams[i].ground_stock = 0; self.sams[i].air_48n6_stock = 0; self.sams[i].ground_rounds = 0; self.sams[i].ground_request = false; self.sams[i].ground_return = false; self.sams[i].return_cargo = false; let missiles = missiles + stock * 2 + typed; let charge = spec.missile.as_ref().map_or(0.0, |m| m.kind.charge() * missiles as f64) + bursts as f64 / 60.0 + stock as f64 * 1.5; // The vehicle's own fuel and the first of its load at once, then the rest cooking off. let first = (1.0 + charge * 0.6).round().clamp(1.0, 8.0) as u32; self.later.push((now + 2, pos, first, false)); for k in 0..missiles.min(40) { let when = now + 15 + (k as u64) * 12 + (self.rng.f() * 25.0) as u64; let at = pos + DVec3::new(self.rng.s() * 3.0, self.rng.f() * 2.0, self.rng.s() * 3.0); let tnt = if charge > 4.0 && self.rng.chance(0.4) { 2 } else { 1 }; self.later.push((when, at, tnt, true)); } self.emit_combat_event(pos, record::EventKind::SamLost { sam: id, kind, index: i }); // Shells pop in strings. for k in 0..(bursts / 12).min(14) { let when = now + 10 + (k as u64) * 6 + (self.rng.f() * 8.0) as u64; let at = pos + DVec3::new(self.rng.s() * 2.0, self.rng.f() * 1.5, self.rng.s() * 2.0); self.later.push((when, at, 0, true)); } } /// The blasts whose time has come. pub(super) fn step_later(&mut self, ground: &mut Ground, player: Option, out: &mut Out) { let now = self.tick; let due: Vec<_> = self.later.iter().filter(|l| l.0 <= now).copied().collect(); self.later.retain(|l| l.0 > now); for (_, pos, tnt, small) in due { self.explode(pos, tnt, small, ground, player, out); if small { // Something flies out of a burning launcher. out.particles("minecraft:lava", pos, 0.8, DVec3::new(0.0, 0.3, 0.0), 0.3, 12); out.particles("minecraft:firework", pos, 0.5, DVec3::new(0.0, 0.2, 0.0), 0.25, 10); } } } /// Damaged systems smoke, wrecks burn. pub(super) fn step_wrecks(&mut self, out: &mut Out) { let tick = self.tick; for sam in &mut self.sams { let top = sam.pos + DVec3::Y * (1.5 * sam.kind.spec().scale); if !sam.alive() { if sam.burn > 0 { sam.burn -= 1; out.particles("minecraft:flame", top, 1.0, DVec3::new(0.0, 0.05, 0.0), 0.03, 3); out.particles("minecraft:large_smoke", top, 0.8, DVec3::new(0.0, 0.12, 0.0), 0.03, 2); if tick % 8 == 0 { out.particles("minecraft:campfire_cosy_smoke", top, 1.0, DVec3::new(0.0, 0.07, 0.0), 0.01, 1); } if tick % 40 == 0 { out.sound("minecraft:block.fire.ambient", top, 3.0, 0.7); } } else if tick % 12 == 0 { out.particles("minecraft:campfire_signal_smoke", top, 0.6, DVec3::new(0.0, 0.05, 0.0), 0.01, 1); } } else if sam.health < 0.7 { let every = if sam.health < 0.35 { 2 } else { 5 }; if tick % every == 0 { out.particles("minecraft:large_smoke", top, 0.4, DVec3::new(0.0, 0.08, 0.0), 0.02, 1); } if sam.health < 0.35 && tick % 3 == 0 { out.particles("minecraft:flame", top, 0.3, DVec3::ZERO, 0.01, 1); } } } } } /// A roll from 0 to 1 fixed by the seed and three numbers: the same events roll the same in every run, /// and the simulation's own random sequence is left alone. pub(super) fn dice(seed: u64, a: u64, b: u64, c: u64) -> f64 { let mut x = seed ^ a.wrapping_mul(0x9E37_79B9_7F4A_7C15) ^ b.wrapping_mul(0xBF58_476D_1CE4_E5B9) ^ c.wrapping_mul(0x94D0_49BB_1331_11EB); x = (x ^ (x >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); x = (x ^ (x >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); x ^= x >> 31; (x >> 11) as f64 / (1u64 << 53) as f64 } impl Sam { /// Its wreck still burns. pub fn burning(&self) -> bool { self.burn > 0 } /// A part's state, `Ok` for one this unit does not have. pub fn part(&self, p: Part) -> f64 { if p.on(self.kind) { self.comps.get(p) } else { 1.0 } } pub fn part_state(&self, p: Part) -> PartState { if p.on(self.kind) { self.comps.state(p) } else { PartState::Ok } } pub fn parts_text(&self) -> String { self.comps.describe(self.kind) } /// The aiming drive's share of its speed: a failed one doesn't turn at all. pub(super) fn drive_fit(&self) -> f64 { let h = self.part(Part::Mount); if h <= 0.0 { 0.0 } else { 0.3 + 0.7 * h } } /// The radar's share of its reach; the scan is slower by the same. pub(super) fn radar_fit(&self) -> f64 { let h = self.part(Part::Sensor); if h <= 0.0 { 0.0 } else { 0.4 + 0.6 * h } } /// The gun's share of its hit chance. pub(super) fn gun_fit(&self) -> f64 { 0.5 + 0.5 * self.part(Part::Gun) } /// Its launcher's cells still good: a damaged one holds fewer missiles. pub(super) fn cells(&self) -> u32 { let Some(load) = &self.kind.spec().missile else { return 0 }; let h = self.part(Part::Launcher); if h <= 0.0 { 0 } else { ((load.magazine as f64 * (0.4 + 0.6 * h)).ceil() as u32).clamp(1, load.magazine) } } /// Missiles above what the cells hold are lost with them. pub fn fit_cells(&mut self) { if self.kind.spec().missile.is_some() { self.ground_rounds = self.ground_rounds.min(self.cells()); self.missiles = self.missiles.min(self.cells().saturating_sub(self.ground_rounds)); } } /// Ticks a reload takes: longer with a damaged launcher. pub(super) fn reload_time(&self) -> u32 { let r = self.kind.spec().reload.max(1); (r as f64 * (1.0 + 1.5 * (1.0 - self.part(Part::Launcher)))).round() as u32 } /// The gun fires (not jammed for good, not jammed now). pub(super) fn gun_up(&self) -> bool { self.part(Part::Gun) > 0.0 && self.jam == 0 } /// How far it can march: the running gear's share of the speed (0 can't). pub(super) fn drive_speed(&self) -> f64 { let h = self.part(Part::Tracks); if h <= 0.0 { 0.0 } else { 0.35 + 0.65 * h } } /// The data link's reach, 0 when the link has failed. pub(super) fn link_range(&self) -> f64 { let h = self.part(Part::Comms); if h <= 0.0 { 0.0 } else { super::sight::LINK * (0.3 + 0.7 * h) } } } impl Sim { /// Repairs every system (wrecks rebuilt, magazines full) and object. pub fn repair(&mut self) -> u32 { let mut n = 0; for sam in &mut self.sams { if sam.health < 1.0 || !sam.comps.whole() { n += 1; } sam.comps = Comps::default(); sam.jam = 0; let spec = sam.kind.spec(); sam.health = 1.0; sam.burn = 0; sam.state = SamState::Search; sam.reloading = 0; sam.empty = false; // Rebuilt where it stands: a march under way is called off. sam.dest = None; sam.march = 0; sam.missiles = spec.missile.as_ref().map_or(0, |m| m.magazine.saturating_sub(sam.ground_rounds)); sam.bursts = spec.gun.as_ref().map_or(0, |g| g.bursts); } for h in &mut self.target_health { *h = 100.0; } // The wrecks' ammunition still to cook off goes with them. self.later.clear(); self.fires.extinguish(); n } } /// A wreck: the hull sunk and turned, the launcher or turret thrown down beside it (a live system's, or a replay's ghost). pub(super) fn draw_wreck_of(sam: &Sam, out: &mut Out) { { let s = sam.kind.spec().scale; let tilt = DQuat::from_rotation_y(sam.heading) * DQuat::from_rotation_z(0.12) * DQuat::from_rotation_x(-0.06); let hull = sam.pos + DVec3::Y * (0.5 * s - 0.35); let side = DQuat::from_rotation_y(sam.heading) * DVec3::new(1.8 * s, 0.0, 0.6 * s); let thrown = DQuat::from_rotation_y(sam.heading + 1.1) * DQuat::from_rotation_z(1.2); let parts = &sam.kind.spec().parts; let (body, part) = (parts.body, parts.launcher.or(parts.pack)); out.model(sam.id, super::units::wreck(body), hull, tilt, s, false); if let Some(part) = part { out.model(sam.id + 1, super::units::wreck(part), sam.pos + side + DVec3::Y * 0.4 * s, thrown, s, false); } } } #[cfg(test)] mod cover_tests { use super::*; struct CoverWorld { wall: bool, opening: bool } impl world::WorldSource for CoverWorld { fn solid(&self, x: i32, _y: i32, z: i32) -> Option { Some(self.wall && x == 8 && !(self.opening && z == 8)) } } fn cache(src: &CoverWorld) -> Ground { let mut ground = Ground::default(); let mut answers = Vec::new(); for x in -1..=1 { for z in -1..=1 { let sec = (x, 4, z); answers.push(world::SectionAnswer { sec, fill: world::section_of(src, sec) }); }} ground.world.answer(answers, 10); ground } fn victim() -> Sim { let mut sim = Sim::new(7); sim.tick = 10; let id = sim.id(); sim.sams.push(Sam::new(id, SamKind::S400, DVec3::new(10.5, 70.0, 8.5), 0.0)); sim.targets.push(DVec3::new(10.5, 71.0, 8.5)); sim.target_health.push(100.0); sim } #[test] fn known_wall_and_opening_attenuate_hull_parts_and_objects() { let from = DVec3::new(0.5, 71.5, 8.5); let mut results = Vec::new(); for src in [CoverWorld { wall: false, opening: false }, CoverWorld { wall: true, opening: false }, CoverWorld { wall: true, opening: true }] { let mut sim = victim(); sim.blast_damage(from, 2, &cache(&src), &mut Out::default()); results.push((1.0 - sim.sams[0].health, 1.0 - sim.sams[0].comps.get(Part::Tracks), 100.0 - sim.target_health[0])); } for i in 0..3 { let open = [results[0].0, results[0].1, results[0].2][i]; let wall = [results[1].0, results[1].1, results[1].2][i]; let gap = [results[2].0, results[2].1, results[2].2][i]; assert!(open > 0.0); assert!((wall / open - 0.15).abs() < 1e-9); assert!(wall < gap && gap < open, "sample {i}: wall {wall}, gap {gap}, open {open}"); } } #[test] fn unresolved_cover_has_bounded_zero_wait_and_no_late_damage() { let from = DVec3::new(0.5, 71.5, 8.5); let mut unknown = Ground::default(); assert_eq!(unknown.world.blast_cover(from, DVec3::new(10.5, 71.5, 8.5), 10), None); let mut sim = victim(); let mut open = victim(); sim.blast_damage(from, 2, &unknown, &mut Out::default()); open.blast_damage(from, 2, &cache(&CoverWorld { wall: false, opening: false }), &mut Out::default()); assert_eq!(sim.sams[0].health, open.sams[0].health); let health = sim.sams[0].health; let hit_points = sim.target_health[0]; assert!(unknown.world.take_wanted(10).is_empty()); assert!(unknown.world.take_rays(10).is_empty()); // A reply, even one proving cover, is not a second combat event. unknown.world.answer(vec![world::SectionAnswer { sec: (0, 4, 0), fill: world::Fill::Full }], 11); assert_eq!(sim.sams[0].health, health); assert_eq!(sim.target_health[0], hit_points); } #[test] fn direct_contact_is_not_weakened_by_cover_and_blast_does_not_mutate_world() { let mut sim = victim(); let ground = cache(&CoverWorld { wall: true, opening: false }); let from = DVec3::new(0.5, 71.5, 8.5); let end = DVec3::new(10.5, 71.5, 8.5); assert_eq!(ground.world.blast_cover(from, end, 10), Some(true)); sim.blast_damage(from, 2, &ground, &mut Out::default()); assert_eq!(ground.world.blast_cover(from, end, 10), Some(true)); let at = sim.sams[0].pos + DVec3::Y; sim.direct_hit(at, DVec3::X * 2.0, 1, &mut Out::default()); assert!(!sim.sams[0].alive()); } #[test] fn stale_cover_is_unresolved_and_source_voxel_does_not_shield_everything() { let ground = cache(&CoverWorld { wall: true, opening: false }); let from = DVec3::new(0.5, 71.5, 8.5); let end = DVec3::new(10.5, 71.5, 8.5); assert_eq!(ground.world.blast_cover(from, end, 1210), None); let source = DVec3::new(8.5, 71.5, 8.5); assert_eq!(ground.world.blast_cover(source, end, 10), Some(false)); } }