Files
airdef/airdef-mod/src/sim/world.rs
T

400 lines
14 KiB
Rust

//! What the game's blocks are to the simulation (issues #42, #43): a cache of
//! 16-block sections answered by `render.sections` (a bit per block that
//! stops a projectile), a swept segment through it, and the bookkeeping that
//! keeps the questions few: the sections along a flight asked for ahead of
//! time, at most 64 a tick, nearest need first; changes of the world marking
//! sections stale; a bounded cache. A chunk the game doesn't have answers
//! `Unknown`, which is never the same as air: the callers fall back to the
//! height of the land there and the counters say how often.
use glam::DVec3;
use std::collections::{HashMap, HashSet};
/// A section: block coordinates divided by 16.
pub type Sec = (i32, i32, i32);
/// Sections asked in one tick (the game's budget).
pub const PER_TICK: usize = 64;
/// Sections kept; the least recently used go first beyond it.
const MAX_SECTIONS: usize = 12_000;
/// Ticks before an unanswered or unknown section is asked again.
const RETRY: u64 = 60;
/// 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).
const QUEUE_MAX: usize = 512;
/// What a section holds, as the game answered.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Fill {
/// The game has no such chunk.
Unknown,
Empty,
Full,
/// 512 bytes, one bit per block, index `(y & 15) * 256 + (z & 15) * 16 + (x & 15)`.
Mixed(Box<[u8; 512]>),
}
/// An answer for a section, as the game gives it.
pub struct SectionAnswer {
pub sec: Sec,
pub fill: Fill,
}
struct Entry {
fill: Fill,
/// A block changed (or may have) since it was read: asked again when next used.
stale: bool,
/// The tick it was last used in a sweep.
used: u64,
/// The tick it was answered.
since: u64,
}
/// How a swept segment ended.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Sweep {
/// Every block along it is known and none stops it.
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 },
}
impl Sweep {
pub fn hit(&self) -> Option<(f64, DVec3)> {
match *self {
Sweep::Hit { t, point, .. } => Some((t, point)),
_ => None,
}
}
}
/// Counters for the report: questions, unknowns, memory, cost.
#[derive(Clone, Copy, Default, Debug)]
pub struct WorldStats {
pub sweeps: u64,
pub cells: u64,
pub hits: u64,
pub unknown_sweeps: u64,
pub sections_asked: u64,
pub sections_answered: u64,
pub sections_unknown: u64,
pub invalidated: u64,
pub evicted: u64,
pub world_changes: u64,
}
#[derive(Default)]
pub struct WorldCache {
secs: HashMap<Sec, Entry>,
urgent: Vec<Sec>,
ahead: Vec<Sec>,
queued: HashSet<Sec>,
/// Sections asked, and when.
asked: HashMap<Sec, u64>,
epoch: u32,
pub stats: WorldStats,
}
fn sec_of(x: i32, y: i32, z: i32) -> Sec {
(x >> 4, y >> 4, z >> 4)
}
impl WorldCache {
/// Memory the cached sections hold, about.
pub fn bytes(&self) -> usize {
self.secs
.values()
.map(|e| 48 + if matches!(e.fill, Fill::Mixed(_)) { 512 } else { 0 })
.sum()
}
pub fn len(&self) -> usize {
self.secs.len()
}
pub fn is_empty(&self) -> bool {
self.secs.is_empty()
}
/// One line for the report.
pub fn text(&self) -> String {
let s = &self.stats;
format!(
"мир: {} секций ({} КБ), запросов {}, неизвестно {}, лучей {} (ударов {}, неизв. {}), клеток {}",
self.len(),
self.bytes() / 1024,
s.sections_asked,
s.sections_unknown,
s.sweeps,
s.hits,
s.unknown_sweeps,
s.cells
)
}
/// 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]) {
if epoch != self.epoch {
if self.epoch != 0 {
self.secs.clear();
self.urgent.clear();
self.ahead.clear();
self.queued.clear();
self.asked.clear();
}
self.epoch = epoch;
}
if overflow {
for e in self.secs.values_mut() {
e.stale = true;
}
self.stats.invalidated += self.secs.len() as u64;
}
for s in sections {
if let Some(e) = self.secs.get_mut(s) {
e.stale = true;
self.stats.invalidated += 1;
}
}
self.stats.world_changes += sections.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);
let hi = sec_of((at.x + radius).floor() as i32, (at.y + radius).floor() as i32, (at.z + radius).floor() as i32);
for x in lo.0..=hi.0 {
for y in lo.1..=hi.1 {
for z in lo.2..=hi.2 {
if let Some(e) = self.secs.get_mut(&(x, y, z)) {
e.stale = true;
}
}
}
}
}
pub fn answer(&mut self, answers: Vec<SectionAnswer>, now: u64) {
for a in answers {
self.asked.remove(&a.sec);
self.stats.sections_answered += 1;
if a.fill == Fill::Unknown {
self.stats.sections_unknown += 1;
}
self.secs.insert(a.sec, Entry { fill: a.fill, stale: false, used: now, since: now });
}
if self.secs.len() > MAX_SECTIONS {
// Whatever wasn't used for a minute goes; if that's not enough, the older half.
self.secs.retain(|_, e| now.saturating_sub(e.used) < 1200);
if self.secs.len() > MAX_SECTIONS {
let mut used: Vec<u64> = self.secs.values().map(|e| e.used).collect();
used.sort_unstable();
let cut = used[used.len() / 2];
self.secs.retain(|_, e| e.used >= cut);
}
self.stats.evicted += 1;
}
// Forget questions the game never answered, so they can be asked again.
if now % 64 == 0 {
self.asked.retain(|_, t| now.saturating_sub(*t) < RETRY);
}
}
/// The sections to ask this tick (at most [`PER_TICK`]): the ones a sweep
/// needed first, then those along flights.
pub fn take_wanted(&mut self, now: u64) -> Vec<Sec> {
let mut out = Vec::new();
for list in [&mut self.urgent, &mut self.ahead] {
let room = PER_TICK - out.len();
let n = room.min(list.len());
out.extend(list.drain(..n));
}
for s in &out {
self.queued.remove(s);
self.asked.insert(*s, now);
}
self.stats.sections_asked += out.len() as u64;
out
}
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) {
return;
}
if self.urgent.len() + self.ahead.len() >= QUEUE_MAX {
return;
}
if urgent {
self.urgent.push(s);
} else {
self.ahead.push(s);
}
self.queued.insert(s);
}
/// Asks for the sections along a flight from `pos` at `vel` a tick, `ticks` ahead.
pub fn look_ahead(&mut self, pos: DVec3, vel: DVec3, ticks: f64, now: u64) {
let mut d = vel * ticks;
let len = d.length();
if len < 1e-6 {
return;
}
if len > AHEAD_MAX {
d *= AHEAD_MAX / len;
}
// A section at a time along the segment (a section is 16 wide: half-section steps meet each).
let steps = (d.length() / 8.0).ceil().max(1.0) as i32;
let mut last = None;
for i in 0..=steps {
let p = pos + d * (i as f64 / steps as f64);
let s = sec_of(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
if last == Some(s) {
continue;
}
last = Some(s);
self.touch(s, false, now);
}
}
/// Touches a section the way a sweep or a look needs it: used now, and
/// asked again when stale or (after a while) unknown.
fn touch(&mut self, s: Sec, urgent: bool, now: u64) -> bool {
let Some(e) = self.secs.get_mut(&s) else {
self.want(s, urgent, now);
return false;
};
e.used = now;
let refresh = e.stale || (e.fill == Fill::Unknown && now.saturating_sub(e.since) >= RETRY);
if refresh {
self.want(s, urgent, now);
}
true
}
/// Whether the block at `(x, y, z)` stops a projectile: `None` where the
/// game hasn't said. `last` is the section just touched.
fn solid(&mut self, last: &mut Option<Sec>, x: i32, y: i32, z: i32, now: u64) -> Option<bool> {
let s = sec_of(x, y, z);
if *last != Some(s) {
*last = Some(s);
self.touch(s, true, now);
}
match &self.secs.get(&s)?.fill {
Fill::Unknown => None,
Fill::Empty => Some(false),
Fill::Full => Some(true),
Fill::Mixed(bits) => {
let i = ((y & 15) << 8 | (z & 15) << 4 | (x & 15)) as usize;
Some(bits[i >> 3] >> (i & 7) & 1 != 0)
}
}
}
/// Whether the block is known to hold no solid block, with the sky above it
/// in view: used to tell a fluid surface from a roof.
pub fn is_known_open(&mut self, x: i32, y: i32, z: i32, now: u64) -> bool {
self.solid(&mut None, x, y, z, now) == Some(false)
}
/// Whether the block is known to be solid.
pub fn is_known_solid(&mut self, x: i32, y: i32, z: i32, now: u64) -> bool {
self.solid(&mut None, x, y, z, now) == Some(true)
}
/// 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).
pub fn sweep(&mut self, a: DVec3, b: DVec3, skip_start: bool, now: u64) -> Sweep {
self.stats.sweeps += 1;
let d = b - a;
let mut pos = [a.x.floor() as i32, a.y.floor() as i32, a.z.floor() as i32];
let dv = [d.x, d.y, d.z];
let av = [a.x, a.y, a.z];
let step: [i32; 3] = dv.map(|v| if v > 0.0 { 1 } else { -1 });
let mut t_max = [f64::INFINITY; 3];
let mut t_delta = [f64::INFINITY; 3];
for i in 0..3 {
if dv[i] != 0.0 {
let edge = f64::from(pos[i]) + if dv[i] > 0.0 { 1.0 } else { 0.0 };
t_max[i] = (edge - av[i]) / dv[i];
t_delta[i] = (1.0 / dv[i]).abs();
}
}
let mut last: Option<Sec> = None;
let mut face = [0i32; 3];
let mut t = 0.0f64;
let mut first = true;
for _ in 0..4096 {
self.stats.cells += 1;
match self.solid(&mut last, pos[0], pos[1], pos[2], now) {
None => {
self.stats.unknown_sweeps += 1;
return Sweep::Unknown { t };
}
Some(true) if !(first && skip_start) => {
self.stats.hits += 1;
return Sweep::Hit { t, point: a + d * t, normal: face, block: pos };
}
_ => {}
}
first = false;
let axis = if t_max[0] < t_max[1] {
if t_max[0] < t_max[2] { 0 } else { 2 }
} else if t_max[1] < t_max[2] {
1
} else {
2
};
t = t_max[axis];
if t > 1.0 {
return Sweep::Clear;
}
t_max[axis] += t_delta[axis];
pos[axis] += step[axis];
face = [0; 3];
face[axis] = -step[axis];
}
self.stats.unknown_sweeps += 1;
Sweep::Unknown { t }
}
}
/// Where the game's blocks come from in tests and the native runner: any
/// world that can say what a block is.
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>;
}
/// A [`WorldSource`] as the game would answer `render.query-sections` with it.
pub fn section_of(source: &dyn WorldSource, s: Sec) -> Fill {
let mut bits = Box::new([0u8; 512]);
let (mut set, mut known) = (0u32, 0u32);
for i in 0..4096usize {
let (x, y, z) = (s.0 * 16 + (i & 15) as i32, s.1 * 16 + (i >> 8) as i32, s.2 * 16 + ((i >> 4) & 15) as i32);
match source.solid(x, y, z) {
Some(true) => {
bits[i >> 3] |= 1 << (i & 7);
set += 1;
known += 1;
}
Some(false) => known += 1,
None => {}
}
}
match (known, set) {
(0, _) => Fill::Unknown,
(_, 0) if known == 4096 => Fill::Empty,
(_, 4096) => Fill::Full,
_ => Fill::Mixed(bits),
}
}
impl WorldCache {
/// 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);
}
}