Preserve acoustic resets and bound worker jobs across chunk changes

AirDef #110 #111 #116. Establish canonical standalone fork metadata.

Co-Authored-By: Codex GPT-6.1 Terra <noreply@openai.com>
This commit is contained in:
2026-11-02 01:04:43 +03:00
parent b717c30924
commit eae00eafc5
3 changed files with 183 additions and 9 deletions
+17
View File
@@ -0,0 +1,17 @@
# AirDef Horizon fork
Canonical repository: https://gitea.maoniao.team/chexit/horizon-airdef
Upstream: https://github.com/horizon-rust/horizon
The initial import preserves upstream history and the 44 AirDef engine commits previously
reconstructed from airdef/horizon-patches. Its upstream baseline is
b6c936f82b08798057161bdfa577e3aac53fb91e (v0.2.93).
Updating the baseline is a separate change (AirDef issue #72).
AirDef pins this repository with the horizon/ git submodule. Push engine commits here first,
then update the gitlink in AirDef after verification. New upstream commits never move an
existing AirDef checkout automatically. Engine source and SDK/WIT live here; gameplay and
content remain in the AirDef repository. Keep upstream licensing and attribution intact.
Do not commit prepared Minecraft resources, game jars, run homes or build outputs.
Run tools/check_public_tree.py before publication (including history on initial import).
+147 -8
View File
@@ -445,7 +445,7 @@ impl Acoustics {
// A job in flight returns into a world that is gone: its sequence number is stale.
self.seq += 1;
self.floor = self.seq;
self.in_flight = None;
// The stale job still occupies the worker until its completion is received.
}
fn forget_rooms(&mut self) {
@@ -501,15 +501,12 @@ impl Acoustics {
self.stats.invalidated += self.cache.len() as u64;
self.cache.clear();
self.echo_cache.clear();
self.echo_applied.clear();
self.echo_pending.clear();
self.forget_rooms();
// Keep mixer bookkeeping until scope reconciliation can recall effects.
self.room_cache.clear();
self.room_now = None;
self.log.clear();
self.seq += 1;
self.floor = self.seq;
self.in_flight = None;
self.applied.clear();
self.scoped.clear();
return;
}
for &s in &changes.sections {
@@ -570,6 +567,7 @@ impl Acoustics {
changes: &Changes,
) -> Vec<Applied> {
self.clock += 1;
let new_epoch = changes.epoch != self.epoch;
self.invalidate(changes);
// The resident chunks changed: a job traced from the snapshot before them applies to
// chunks that may be gone, so its answers are dropped with the old residency's answers.
@@ -577,7 +575,6 @@ impl Acoustics {
self.residency = Some(changes.residency);
self.seq += 1;
self.floor = self.seq;
self.in_flight = None;
}
// The worker's results; one that began before a change in its box is not kept.
if let Some((_, rx)) = &self.worker {
@@ -640,6 +637,14 @@ impl Acoustics {
let Some(geometry) = geometry else {
return told;
};
if new_epoch {
// Reannounce live voices in the new world after reconciling those that left.
for s in &live {
self.applied.remove(&s.id);
self.echo_applied.remove(&s.id);
self.sends_applied.remove(&s.id);
}
}
// The loudest first; ties by id, so the order never depends on a hash.
let mut order: Vec<usize> = (0..live.len()).collect();
order.sort_by(|&a, &b| live[b].loud.total_cmp(&live[a].loud).then(live[a].id.cmp(&live[b].id)));
@@ -1281,6 +1286,140 @@ mod tests {
assert!(gone[0].cutoff > 0.5, "{gone:?}");
}
#[test]
fn reload_and_unload_invalidate_known_geometry_below_zero() {
let mut a = Acoustics::new(true);
let open = Wall::new(0..0, 1.0);
let wall = Wall::new(40..42, 1.0);
let listener = [0.5, -30.5, 0.5];
let sources = [Source {
at: [90.5, -30.5, 0.5],
..src(1, 90.5)
}];
assert!(a.step(Some(&open), listener, &sources, &Changes::default())[0].cutoff > 0.5);
let mut columns = crate::world::ModChanges::default();
columns.column(2, 0);
let (sections, overflow) = columns.take();
let changed = Changes {
sections,
overflow,
residency: 1,
..Default::default()
};
assert!(a.step(Some(&wall), listener, &sources, &changed)[0].cutoff < 0.01);
columns.column(2, 0);
let (sections, overflow) = columns.take();
let changed = Changes {
sections,
overflow,
residency: 2,
..Default::default()
};
assert!(a.step(Some(&open), listener, &sources, &changed)[0].cutoff > 0.5);
}
#[test]
fn overflow_preserves_mixer_resets_for_scope_exit_and_missing_geometry() {
for missing in [false, true] {
let mut a = Acoustics::new(true);
let wall = Wall::new(100..103, 1.0);
let listener = [0.5, 70.5, 0.5];
let near = [src(1, 200.5)];
assert!(a.step(Some(&wall), listener, &near, &Changes::default())[0].gain < 1.0);
a.echo_applied.insert(
1,
vec![Tap {
delay: 0.1,
path: 1.0,
level: 0.5,
cut: 1.0,
dir: [1.0, 0.0, 0.0],
}],
);
a.sends_applied.insert(1, [0.5, 0.0, 0.0, 0.0]);
a.take_echoes();
a.take_sends();
let sources = if missing { near } else { [src(1, 600.5)] };
let geometry = if missing { None } else { Some(&wall) };
let out = a.step(
geometry,
listener,
&sources,
&Changes {
overflow: true,
..Default::default()
},
);
assert_eq!(out.len(), 1);
assert_eq!(out[0].gain, 1.0);
assert_eq!(a.take_echoes(), vec![(1, vec![])]);
assert_eq!(a.take_sends(), vec![(1, [0.0; 4])]);
assert!(a.step(Some(&wall), listener, &near, &Changes::default())[0].gain < 1.0);
}
}
#[test]
fn invalidation_does_not_enqueue_behind_a_busy_worker() {
struct Gate {
ready: std::sync::Mutex<bool>,
wake: std::sync::Condvar,
}
impl Geometry for Gate {
fn walker(&self) -> Box<dyn FnMut(i32, i32, i32) -> Option<f32> + '_> {
if std::thread::current().name() == Some("acoustics") {
let mut ready = self.ready.lock().unwrap();
while !*ready {
ready = self.wake.wait(ready).unwrap();
}
}
Box::new(|_, _, _| Some(0.0))
}
}
let gate = Arc::new(Gate {
ready: false.into(),
wake: Default::default(),
});
let geometry: Arc<dyn Geometry> = gate.clone();
let mut a = Acoustics::new(false);
let listener = [0.5, 70.5, 0.5];
let sources = [src(1, 90.5)];
for residency in 0..200 {
if residency % 25 == 24 {
a.reset();
}
a.step(
Some(&geometry),
listener,
&sources,
&Changes {
residency,
overflow: residency % 11 == 10,
..Default::default()
},
);
}
let retained = Arc::strong_count(&geometry) - 2;
*gate.ready.lock().unwrap() = true;
gate.wake.notify_all();
assert!(retained <= 1, "retained jobs: {retained}");
assert!(a.stats.skipped_busy > 0);
let changes = Changes {
residency: 199,
..Default::default()
};
for _ in 0..400 {
a.step(Some(&geometry), listener, &sources, &changes);
if a.stats.dropped_late > 0 && a.stats.jobs >= 2 {
return;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
panic!(
"worker did not discard stale work and process the new snapshot: {:?}",
a.stats
);
}
/// (AirDef fork #111.) A sound (or a listener) that walks out of the acoustic range gives
/// up its old wall and takes the plain numbers of its new distance until it comes back.
#[test]
+19 -1
View File
@@ -140,7 +140,7 @@ impl ModChanges {
/// keyed to sections. Bounded like `note` is.
pub fn column(&mut self, x: i32, z: i32) {
if self.sections.len() < Self::MAX {
for sy in 0..SECTIONS as i32 {
for sy in (MIN_Y >> 4)..(MIN_Y >> 4) + SECTIONS as i32 {
self.sections.insert((x, sy, z));
}
}
@@ -629,6 +629,24 @@ mod tests {
use horizon_world::registry::BlockStateId;
use std::sync::Arc;
#[test]
fn changed_column_uses_world_section_coordinates_and_stays_bounded() {
let mut changes = super::ModChanges::default();
changes.column(2, -3);
let (sections, overflow) = changes.take();
assert!(!overflow);
assert_eq!(sections.len(), crate::chunk::SECTIONS);
for sy in
(crate::chunk::MIN_Y >> 4)..(crate::chunk::MIN_Y >> 4) + crate::chunk::SECTIONS as i32
{
assert!(sections.contains(&(2, sy, -3)));
}
for x in 0..12 {
changes.column(x, 0);
}
assert!(changes.take().1);
}
/// A box misses a state only where no section it reaches lists it, and
/// unloaded columns or heights past the world count as their air.
#[test]