From 9d58d6f525babf5a1478d98cab34cb9cc73f268a Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 13:31:27 +0200 Subject: [PATCH 1/2] Random ticks: a section ticks while it holds a randomly ticking block, as in vanilla Vanilla random-ticks a section while its count of randomly ticking blocks and fluids is above zero (LevelChunkSection.isRandomlyTicking), and asks as it reaches each section. Horizon ticked every section whose palette listed such a state, even after the last one was gone, and decided before the tick's scheduled ticks, which drew positions vanilla doesn't and shifted its position sequence. RandomTickSections now reads each section's blocks (PalettedContainer::has), again only for the sections that changed, and tick_chunk_random asks for each section when it reaches it; the game reads a chunk's sections again only after a block changed. New harness random_tick_sections compares the sections and positions with vanilla's real section counts. Co-Authored-By: Claude Opus 5.5 --- .../examples/random_tick_sections_probe.rs | 132 ++++++++++++++++ crates/horizon-client/src/game.rs | 48 +++--- .../src/random_tick_sections.rs | 149 +++++++++++------- crates/horizon-core/src/paletted.rs | 57 +++++++ crates/horizon-world/src/level/mod.rs | 8 +- crates/horizon-world/src/level/tick.rs | 17 +- .../VanillaRandomTickSectionsOracle.java | 102 ++++++++++++ tools/test_random_tick_sections_parity.py | 73 +++++++++ 8 files changed, 504 insertions(+), 82 deletions(-) create mode 100644 crates/horizon-client/examples/random_tick_sections_probe.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRandomTickSectionsOracle.java create mode 100644 tools/test_random_tick_sections_parity.py diff --git a/crates/horizon-client/examples/random_tick_sections_probe.rs b/crates/horizon-client/examples/random_tick_sections_probe.rs new file mode 100644 index 000000000..cb8a8b742 --- /dev/null +++ b/crates/horizon-client/examples/random_tick_sections_probe.rs @@ -0,0 +1,132 @@ +//! Random-tick sections companion for tools/test_random_tick_sections_parity.py: +//! the game's `RandomTickSections` choosing the sections of a chunk that +//! `Behaviours::tick_chunk_random` ticks, after the case's edits (see +//! VanillaRandomTickSectionsOracle for the format; the `#resources` line names +//! the prepared resources). The level the ticks run against reads as air +//! everywhere, so nothing ticks for real: its reads are the drawn positions. +use horizon_client::{ + blocks::BlockFacts, + chunk::{Chunk, MIN_Y, Section}, + random_tick_sections::RandomTickSections, +}; +use horizon_core::{ + position::{BlockPos, ChunkPos}, + random::LegacyRandom, +}; +use horizon_world::{ + fluid::FluidKind, + level::{GameRules, LevelAccess, LevelEvent, Ticks, data}, + registry::BlockStateId, +}; +use std::{cell::RefCell, error::Error, fmt::Write, path::PathBuf, sync::Arc}; + +struct Air { + reads: RefCell>, + random: LegacyRandom, + speed: i32, +} +impl LevelAccess for Air { + fn block_state(&self, pos: BlockPos) -> BlockStateId { + self.reads.borrow_mut().push(pos); + BlockStateId(0) + } + fn set_raw(&mut self, _: BlockPos, _: BlockStateId) -> Option { + None + } + fn is_loaded(&self, _: BlockPos) -> bool { + true + } + fn random(&mut self) -> &mut LegacyRandom { + &mut self.random + } + fn game_time(&self) -> i64 { + 0 + } + fn game_rules(&self) -> GameRules { + GameRules { + random_tick_speed: self.speed, + ..Default::default() + } + } + fn emit(&mut self, _: LevelEvent) {} +} + +fn main() -> Result<(), Box> { + let args: Vec = std::env::args().collect(); + let input = std::fs::read_to_string(&args[1])?; + let root = input + .lines() + .find_map(|l| l.strip_prefix("#resources ")) + .map(PathBuf::from) + .ok_or("no #resources line")?; + let registry = data::load_registry(&root)?; + let (facts, behaviours) = BlockFacts::load_pair(&root, ®istry)?; + let mut output = String::new(); + for line in input.lines().filter(|l| !l.starts_with('#')) { + let mut words = line.split(' '); + let mut ticks = Ticks::new(0); + ticks.random_tick_value = words.next().ok_or("no randValue")?.parse()?; + let mut level = Air { + reads: RefCell::default(), + random: LegacyRandom::new(0), + speed: words.next().ok_or("no speed")?.parse()?, + }; + let mut chunk = Arc::new(Chunk::empty(0, 0)); + let mut cache = RandomTickSections::default(); + for word in words { + let op: Vec<&str> = word.split(':').collect(); + let int = |i: usize| -> Result> { Ok(op[i].parse()?) }; + match op[0] { + "s" => { + let (section, index) = (int(1)?, int(2)?); + Arc::make_mut(&mut chunk).set( + index & 15, + MIN_Y + section * 16 + (index >> 8), + index >> 4 & 15, + int(3)? as u32, + ); + } + "f" => { + let (a, b, m) = (int(2)? as u32, int(3)? as u32, int(4)? as usize); + let values = std::array::from_fn(|i| if i % m == m - 1 { b } else { a }); + Arc::make_mut(&mut Arc::make_mut(&mut chunk).sections[int(1)? as usize]) + .blocks = Section::from_blocks(&values); + } + "t" => { + output.push('|'); + level.reads.borrow_mut().clear(); + behaviours.tick_chunk_random( + &mut level, + &mut ticks, + ChunkPos::new(0, 0), + |_, min_y| cache.get((0, 0), &chunk, &facts).contains(min_y), + ); + for pos in level.reads.borrow().iter() { + let state = chunk.block(pos.x, pos.y, pos.z); + let fluid = matches!( + behaviours.fluid(state).kind(), + FluidKind::Lava | FluidKind::FlowingLava + ); + write!( + output, + " {},{},{},{}{}", + pos.x, + pos.y, + pos.z, + if behaviours.is_randomly_ticking(state) { + 'B' + } else { + '-' + }, + if fluid { 'F' } else { '-' }, + )?; + } + } + other => return Err(format!("unknown op {other}").into()), + } + } + writeln!(output, " | {}", ticks.random_tick_value)?; + } + std::fs::write(&args[2], output)?; + Ok(()) +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index bad635c5c..afdb2ee37 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -515,6 +515,7 @@ struct GameLevel<'w> { spill: &'w mut spill::Spill, /// Where the chunk tickets let blocks tick. tickets: horizon_client::ticket_levels::Levels, + random_tick_sections: &'w mut horizon_client::random_tick_sections::RandomTickSections, } struct PlayerCollision { y: f64, @@ -2276,6 +2277,7 @@ impl Game<'_> { pending: &mut self.pending, spill: &mut self.spill, tickets: self.tickets.levels(), + random_tick_sections: &mut self.random_tick_sections, }; let result = f(self.res.behaviours(), &mut level, &mut self.block_ticks); self.flush_spill(); @@ -2370,18 +2372,15 @@ impl Game<'_> { self.sync_tick_chunks(); self.start_ticking_chunks(); let levels = self.tickets.levels(); - let mut ticking = Vec::new(); - let facts = self.res.facts(); - for (&(x, z), chunk) in &self.world.chunks { - if !levels.random_ticking(x, z) || !ticking_chunk(&self.world, x, z) { - continue; - } - // Capture eligibility before inside-block and scheduled updates, as - // before. Keep the world map's chunk order, including empty chunks - // (tick_chunk_random still draws for precipitation in those). - let sections = self.random_tick_sections.get((x, z), chunk, facts); - ticking.push((x, z, sections)); - } + // Keep the world map's chunk order, including empty chunks + // (tick_chunk_random still draws for precipitation in those). + let ticking: Vec<_> = self + .world + .chunks + .keys() + .copied() + .filter(|&(x, z)| levels.random_ticking(x, z) && ticking_chunk(&self.world, x, z)) + .collect(); // Entity.checkInsideBlocks for the plates, tripwires and detector rails // under the players (the host and the LAN guests) and the minecarts. let mut inside = Vec::new(); @@ -2423,13 +2422,24 @@ impl Game<'_> { self.process_level_events()?; self.tick_scheduled()?; self.with_level(|b, level, ticks| { - for (x, z, sections) in ticking { - b.tick_chunk_random( - level, - ticks, - horizon_core::position::ChunkPos::new(x, z), - sections, - ); + for (x, z) in ticking { + // The sections are read again only after a block changed. + let mut read = None; + let mut sections = Default::default(); + let pos = horizon_core::position::ChunkPos::new(x, z); + b.tick_chunk_random(level, ticks, pos, |level, min_y| { + if read != Some(level.world.revision) { + read = Some(level.world.revision); + sections = level + .world + .chunks + .get(&(x, z)) + .map_or_else(Default::default, |chunk| { + level.random_tick_sections.get((x, z), chunk, level.facts) + }); + } + sections.contains(min_y) + }); } b.run_block_events(level, ticks); b.tick_block_entities(level, ticks); diff --git a/crates/horizon-client/src/random_tick_sections.rs b/crates/horizon-client/src/random_tick_sections.rs index ce5da051b..23d6a3dbe 100644 --- a/crates/horizon-client/src/random_tick_sections.rs +++ b/crates/horizon-client/src/random_tick_sections.rs @@ -1,7 +1,8 @@ -//! Memoized palette eligibility for the game thread's random-tick snapshot. +//! Which sections of the game thread's chunks random-tick +//! (`LevelChunkSection.isRandomlyTicking`), memoized per section. use crate::{ blocks::BlockFacts, - chunk::{Chunk, MIN_Y, SECTIONS}, + chunk::{Chunk, MIN_Y, SECTIONS, Section}, fast_hash::FxHashMap, }; use horizon_world::registry::BlockStateId; @@ -10,6 +11,13 @@ use std::sync::{Arc, Weak}; /// A value snapshot, in ascending section order, with no per-chunk allocation. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct Sections(u32); +impl Sections { + /// Whether the section starting at block `min_y` is in the set. + pub fn contains(self, min_y: i32) -> bool { + let index = (min_y - MIN_Y) >> 4; + (0..SECTIONS as i32).contains(&index) && self.0 >> index & 1 != 0 + } +} impl Iterator for Sections { type Item = i32; fn next(&mut self) -> Option { @@ -29,12 +37,20 @@ impl ExactSizeIterator for Sections {} struct Cached { chunk: Weak, + /// The section each bit of `sections` was read from. + read: [Weak
; SECTIONS], sections: Sections, } -/// Resident chunks are immutable behind `Arc`; edits use `Arc::make_mut`. -/// A weak reference detects both edits and replacement, without retaining block -/// data or forcing a deep copy on the next edit. It also prevents address reuse. -/// Clear this cache whenever the gameplay facts change (including resource reload). +/// Vanilla keeps a count of randomly ticking blocks and fluids per section, +/// updated by every `setBlockState`, and ticks the sections where it is above +/// zero. Here a section's answer is read from its blocks after any edit: +/// resident chunks and sections are immutable behind `Arc` and edited through +/// `Arc::make_mut`, so a weak reference tells an edited or replaced one from +/// the one read, without retaining block data or forcing a deep copy on the +/// next edit, and prevents address reuse. An unchanged chunk costs one +/// pointer comparison; a changed one, a comparison per section and a read of +/// the sections that changed. Clear this cache whenever the gameplay facts +/// change (including resource reload). #[derive(Default)] pub struct RandomTickSections { chunks: FxHashMap<(i32, i32), Cached>, @@ -46,6 +62,7 @@ impl RandomTickSections { pub fn remove(&mut self, key: &(i32, i32)) { self.chunks.remove(key); } + /// The sections of `chunk` holding a randomly ticking block or fluid. pub fn get(&mut self, key: (i32, i32), chunk: &Arc, facts: &BlockFacts) -> Sections { self.get_with(key, chunk, |id| facts.get(BlockStateId(id)).random_ticks) } @@ -60,17 +77,23 @@ impl RandomTickSections { } let cached = self.chunks.entry(key).or_insert_with(|| Cached { chunk: Weak::new(), + read: std::array::from_fn(|_| Weak::new()), sections: Sections::default(), }); if cached.chunk.as_ptr() != Arc::as_ptr(chunk) { - let mut mask = 0; - for (i, section) in chunk.sections.iter().enumerate() { - // Preserve maybe_has, including unused entries and global palettes. - if section.blocks.maybe_has(&mut random) { - mask |= 1 << i; + for (i, (section, read)) in chunk.sections.iter().zip(&mut cached.read).enumerate() { + if read.as_ptr() == Arc::as_ptr(section) { + continue; } + // `isRandomlyTicking`: the blocks themselves, not the palette, + // which keeps the states no block uses any more. + if section.blocks.has(&mut random) { + cached.sections.0 |= 1 << i; + } else { + cached.sections.0 &= !(1 << i); + } + *read = Arc::downgrade(section); } - cached.sections = Sections(mask); cached.chunk = Arc::downgrade(chunk); } cached.sections @@ -97,10 +120,24 @@ mod tests { [MIN_Y] ); assert_eq!(worker.get(0, MIN_Y, 0), 0); - // Even after the last ticking block is removed, its unused palette entry counts. + // Once the last ticking block is gone the section stops ticking, as + // vanilla's count drops to zero, though its palette still lists it. Arc::make_mut(&mut chunk).set(0, MIN_Y, 0, 0); - assert_eq!(cache.get_with((0, 0), &chunk, |id| id == 1).len(), 1); - Arc::make_mut(&mut Arc::make_mut(&mut chunk).sections[0]).compact(); + assert!(chunk.sections[0].blocks.maybe_has(|id| id == 1)); + assert_eq!(cache.get_with((0, 0), &chunk, |id| id == 1).len(), 0); + // Only the edited section is read again (its palette: air, then 1). + Arc::make_mut(&mut chunk).set(0, MIN_Y + 16, 0, 1); + let mut asked = Vec::new(); + let sections = cache.get_with((0, 0), &chunk, |id| { + asked.push(id); + id == 1 + }); + assert_eq!( + (sections.collect::>(), asked), + (vec![MIN_Y + 16], vec![0, 1]) + ); + Arc::make_mut(&mut chunk).set(0, MIN_Y + 16, 0, 0); + Arc::make_mut(&mut Arc::make_mut(&mut chunk).sections[1]).compact(); assert_eq!(cache.get_with((0, 0), &chunk, |id| id == 1).len(), 0); Arc::make_mut(&mut chunk).sections[SECTIONS - 1] = Arc::new(Section::default()); cache.clear(); // resource reload, with changed facts for the same state IDs @@ -138,10 +175,12 @@ mod tests { } let chunk = Arc::new(chunk); let mut cache = RandomTickSections::default(); - // Global maybe_has considers the entire ID range, including absent states. + // Global palettes: the states the blocks hold, not the whole ID range. + assert_eq!(cache.get_with((0, 0), &chunk, |id| id == 40000).len(), 0); + cache.clear(); assert_eq!( cache - .get_with((0, 0), &chunk, |id| id == 40000) + .get_with((0, 0), &chunk, |id| id == 299) .collect::>(), [MIN_Y, MIN_Y + 9 * 16, MIN_Y + (SECTIONS as i32 - 1) * 16] ); @@ -201,7 +240,7 @@ mod tick_parity { } #[test] - fn actual_random_ticks_match_original_scan() { + fn actual_random_ticks_match_a_block_scan() { let root = std::env::var_os("HORIZON_RESOURCES") .map(PathBuf::from) .unwrap_or_else(|| { @@ -228,6 +267,7 @@ mod tick_parity { let registry = data::load_registry(&root).unwrap(); let (mut facts, behaviours) = BlockFacts::load_pair(&root, ®istry).unwrap(); let grass = registry.default_state("minecraft:grass_block").unwrap(); + let stone = registry.default_state("minecraft:stone").unwrap(); let chunk = |x| { let mut c = Chunk::empty(x, 0); c.lit = true; @@ -280,6 +320,15 @@ mod tick_parity { 40 | 41 => { Arc::make_mut(level.chunks.get_mut(&(0, 0)).unwrap()).lit = step == 41; } + 70 => { + // Every block of a ticking section replaced: its + // palette still lists grass, but nothing ticks there. + let c = Arc::make_mut(level.chunks.get_mut(&(-1, 0)).unwrap()); + for i in 0..4096 { + c.set(i & 15, MIN_Y + 4 * 16 + (i >> 8), i >> 4 & 15, stone.0); + } + assert!(c.sections[4].blocks.maybe_has(|id| id == grass.0)); + } _ => {} } } @@ -290,47 +339,41 @@ mod tick_parity { facts.states[grass.0 as usize].random_ticks = step == 60; cache.clear(); } - let old: Vec<_> = original - .chunks - .iter() - .filter(|(_, c)| c.lit) - .map(|(&key, c)| { - let sections: Vec<_> = c - .sections - .iter() - .enumerate() - .filter(|(_, s)| { - s.blocks - .maybe_has(|id| facts.get(BlockStateId(id)).random_ticks) - }) - .map(|(i, _)| MIN_Y + i as i32 * 16) - .collect(); - (key, sections) - }) - .collect(); - let new: Vec<_> = cached - .chunks - .iter() - .filter(|(_, c)| c.lit) - .map(|(&key, c)| (key, cache.get(key, c, &facts))) - .collect(); - assert_eq!( - old, - new.iter() - .map(|(k, s)| (*k, s.collect::>())) - .collect::>() - ); - // Stand in for an inside-block/scheduled write AFTER eligibility capture. + // A write between ticks. if step == 20 { for level in [&mut original, &mut cached] { level.set_raw(BlockPos::new(0, MIN_Y + 16, 0), grass); } } - for ((x, z), sections) in old { - behaviours.tick_chunk_random(&mut original, &mut a, ChunkPos::new(x, z), sections); + let lit = |level: &Level| { + let mut keys: Vec<_> = level + .chunks + .iter() + .filter(|(_, c)| c.lit) + .map(|(&key, _)| key) + .collect(); + keys.sort(); + keys + }; + let random = |id| facts.get(BlockStateId(id)).random_ticks; + for (x, z) in lit(&original) { + // Vanilla's rule, asked as each section is reached: any of its + // 4,096 blocks ticks randomly. + let reference = |level: &mut Level, min_y: i32| { + let chunk = &level.chunks[&(x, z)]; + (0..16).any(|y| { + (0..16).any(|z| (0..16).any(|x| random(chunk.get(x, min_y + y, z)))) + }) + }; + behaviours.tick_chunk_random(&mut original, &mut a, ChunkPos::new(x, z), reference); } - for ((x, z), sections) in new { - behaviours.tick_chunk_random(&mut cached, &mut b, ChunkPos::new(x, z), sections); + for (x, z) in lit(&cached) { + let memoized = |level: &mut Level, min_y| { + cache + .get((x, z), &level.chunks[&(x, z)], &facts) + .contains(min_y) + }; + behaviours.tick_chunk_random(&mut cached, &mut b, ChunkPos::new(x, z), memoized); } assert_eq!(original.reads, cached.reads, "ordered reads at tick {step}"); assert_eq!(original.events, cached.events, "events at tick {step}"); diff --git a/crates/horizon-core/src/paletted.rs b/crates/horizon-core/src/paletted.rs index 3d56bb987..dad7f76a0 100644 --- a/crates/horizon-core/src/paletted.rs +++ b/crates/horizon-core/src/paletted.rs @@ -674,6 +674,41 @@ impl PalettedContainer { Palette::Global => (0..1u32 << self.bits.min(31)).any(predicate), } } + /// Whether any entry satisfies `predicate`. Unlike [`Self::maybe_has`], + /// palette entries no entry uses any more don't count. + pub fn has(&self, mut predicate: impl FnMut(u32) -> bool) -> bool { + let matching: Vec = match &self.palette { + Palette::Single(value) => return predicate(*value), + Palette::List(list) => list.iter().map(|&v| predicate(v)).collect(), + Palette::Global => Vec::new(), + }; + if matches!(self.palette, Palette::List(_)) { + if !matching.contains(&true) { + return false; + } + if !matching.contains(&false) { + return true; + } + } + let bits = usize::from(self.bits); + let per = 64 / bits; + let m = mask(self.bits); + let mut left = self.strategy.entries(); + for &word in &self.words { + for slot in 0..per.min(left) { + let id = ((word >> (slot * bits)) & m) as usize; + let hit = match self.palette { + Palette::Global => predicate(id as u32), + _ => matching[id], + }; + if hit { + return true; + } + } + left = left.saturating_sub(per); + } + false + } /// Heap bytes held by the palette and the storage. pub fn heap_bytes(&self) -> usize { self.words.capacity() * 8 @@ -771,9 +806,31 @@ mod tests { let wire = PalettedContainer::from_wire(strategy, bits, palette, words.to_vec()).unwrap(); assert_eq!(wire, c); + for wanted in [0, 7, 14, 35, 7 * 699, 5] { + assert_eq!( + c.has(|v| v == wanted || v == wanted + 7), + plain.iter().any(|&v| v == wanted || v == wanted + 7), + "has {wanted} in {distinct} values" + ); + } } } #[test] + fn has_ignores_stale_palette_entries() { + let mut c = PalettedContainer::new(BLOCKS, 0); + assert!(c.has(|v| v == 0) && !c.has(|v| v == 3)); + c.set(4095, 3); + assert!(c.has(|v| v == 3)); + c.set(4095, 0); + assert!(c.maybe_has(|v| v == 3) && !c.has(|v| v == 3)); + for v in 1..=300 { + c.set(v as usize, v); + } + assert!(c.is_global() && c.has(|v| v == 300)); + c.set(300, 0); + assert!(c.maybe_has(|v| v == 300) && !c.has(|v| v == 300)); + } + #[test] fn uniform_detection_ignores_stale_palette_entries() { let mut c = PalettedContainer::new(BLOCKS, 0); c.set(10, 3); diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index de7312cb1..1c338f2ed 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -19,9 +19,9 @@ //! `ServerLevel.tickChunk`'s random ticks: for each non-empty section, //! `randomTickSpeed` (game rule, default 3) positions are drawn with //! `Level.getBlockRandomPos` and randomly-ticking block and fluid states are -//! ticked. The caller decides which sections are randomly ticking (vanilla -//! counts randomly-ticking states per section); [`Behaviours::random_tick`] -//! ticks a single position. +//! ticked. The caller says which sections are randomly ticking when each is +//! reached (vanilla counts randomly-ticking states per section); +//! [`Behaviours::random_tick`] ticks a single position. //! 3. [`Behaviours::run_block_events`] runs queued block events (pistons), //! then (after entities) [`Behaviours::tick_block_entities`] advances //! moving pistons ([`Ticks::moving_pistons`]). @@ -69,7 +69,7 @@ //! level.time += 1; //! behaviours.tick_scheduled(&mut level, &mut ticks); //! for chunk in ticking_chunks { -//! behaviours.tick_chunk_random(&mut level, &mut ticks, chunk, randomly_ticking_section_min_ys(chunk)); +//! behaviours.tick_chunk_random(&mut level, &mut ticks, chunk, |level, min_y| level.randomly_ticking(chunk, min_y)); //! } //! behaviours.run_block_events(&mut level, &mut ticks); //! /* tick entities */ diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index 1c45990a0..e9e4f6791 100644 --- a/crates/horizon-world/src/level/tick.rs +++ b/crates/horizon-world/src/level/tick.rs @@ -1615,16 +1615,18 @@ impl Behaviours { }; ticks.handling_tick = false; } - /// Random-tick one chunk (`ServerLevel.tickChunk` block part). `sections` - /// yields the minimum block Y of every section the caller considers - /// randomly ticking (vanilla: sections containing randomly-ticking states), - /// in ascending order. Draws `randomTickSpeed` positions per section. + /// Random-tick one chunk (`ServerLevel.tickChunk` block part). Visits the + /// sections from the bottom up and draws `randomTickSpeed` positions in + /// each one `ticking(level, min_y)` reports randomly ticking + /// (`LevelChunkSection.isRandomlyTicking`: it holds a randomly ticking + /// block or fluid). Vanilla asks as it reaches each section, so the ticks + /// of the sections below count. pub fn tick_chunk_random( &self, level: &mut L, ticks: &mut Ticks, chunk: ChunkPos, - sections: impl IntoIterator, + mut ticking: impl FnMut(&mut L, i32) -> bool, ) { let speed = level.game_rules().random_tick_speed; if speed <= 0 { @@ -1639,7 +1641,10 @@ impl Behaviours { } } } - for min_y in sections { + for min_y in (level.min_y()..level.max_y()).step_by(16) { + if !ticking(level, min_y) { + continue; + } for _ in 0..speed { let pos = ticks.block_random_pos(min_x, min_y, min_z, 15); self.sim(level, ticks).random_tick_at(pos); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRandomTickSectionsOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRandomTickSectionsOracle.java new file mode 100644 index 000000000..a0dc5d914 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRandomTickSectionsOracle.java @@ -0,0 +1,102 @@ +package dev.horizonlab.parity; + +import java.io.*; +import java.lang.reflect.Field; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import net.minecraft.core.BlockPos; +import net.minecraft.util.RandomSource; +import net.minecraft.world.level.Level; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.chunk.LevelChunkSection; +import net.minecraft.world.level.chunk.PalettedContainerFactory; + +/** + * Original oracle for which sections of a chunk random-tick and where: the + * real LevelChunkSection block counts (setBlockState, and recalcBlockCounts + * for a section built from a filled container, as a loaded one is) and + * isRandomlyTicking, with the block part of ServerLevel.tickChunk's section + * loop around them (the precipitation draws included, on a level random + * seeded 0) and the real Level.getBlockRandomPos drawing the positions. + * + * Each case line is "randValue speed op...", ops being "s:section:index:state" + * (setBlockState, index y << 8 | z << 4 | x), "f:section:a:b:m" (a section + * loaded from a container holding b where index % m == m - 1, a elsewhere) and + * "t" (one tick). Prints, per tick, every drawn position with whether its + * block and its fluid tick randomly, then the final randValue. + */ +public final class VanillaRandomTickSectionsOracle { + static final int SECTIONS = 24; + static final int MIN_Y = -64; + + public static void main(String[] args) throws Exception { + ParityData.init(); + var factory = PalettedContainerFactory.create(ParityData.access); + Level level = ParityData.level; + Field randValue = Level.class.getDeclaredField("randValue"); + randValue.setAccessible(true); + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8)); + var lines = Files.lines(Path.of(args[0]))) { + for (var line : (Iterable) lines::iterator) { + if (line.startsWith("#")) continue; + String[] words = line.trim().split(" "); + randValue.setInt(level, Integer.parseInt(words[0])); + int speed = Integer.parseInt(words[1]); + RandomSource random = RandomSource.create(0); + LevelChunkSection[] sections = new LevelChunkSection[SECTIONS]; + for (int i = 0; i < SECTIONS; i++) sections[i] = new LevelChunkSection(factory); + StringBuilder result = new StringBuilder(); + for (int w = 2; w < words.length; w++) { + String[] op = words[w].split(":"); + switch (op[0]) { + case "s" -> { + int index = Integer.parseInt(op[2]); + sections[Integer.parseInt(op[1])].setBlockState(index & 15, index >> 8, index >> 4 & 15, + state(op[3])); + } + case "f" -> { + BlockState a = state(op[2]), b = state(op[3]); + int m = Integer.parseInt(op[4]); + var states = factory.createForBlockStates(); + for (int index = 0; index < 4096; index++) { + states.getAndSetUnchecked(index & 15, index >> 8, index >> 4 & 15, + index % m == m - 1 ? b : a); + } + sections[Integer.parseInt(op[1])] = new LevelChunkSection(states, factory.createForBiomes()); + } + case "t" -> { + result.append('|'); + // ServerLevel.tickChunk, for a chunk at 0, 0. Its + // precipitation positions use randValue too. + for (int i = 0; i < speed; i++) { + if (random.nextInt(48) == 0) level.getBlockRandomPos(0, 0, 0, 15); + } + if (speed <= 0) continue; + for (int s = 0; s < SECTIONS; s++) { + LevelChunkSection section = sections[s]; + if (!section.isRandomlyTicking()) continue; + int minY = MIN_Y + s * 16; + for (int i = 0; i < speed; i++) { + BlockPos pos = level.getBlockRandomPos(0, minY, 0, 15); + BlockState state = section.getBlockState(pos.getX(), pos.getY() - minY, pos.getZ()); + result.append(' ').append(pos.getX()).append(',').append(pos.getY()).append(',') + .append(pos.getZ()).append(',') + .append(state.isRandomlyTicking() ? 'B' : '-') + .append(state.getFluidState().isRandomlyTicking() ? 'F' : '-'); + } + } + } + default -> throw new IllegalArgumentException(words[w]); + } + } + out.println(result.append(" | ").append(randValue.getInt(level))); + } + } + System.exit(0); + } + + static BlockState state(String id) { + return Block.BLOCK_STATE_REGISTRY.byId(Integer.parseInt(id)); + } +} diff --git a/tools/test_random_tick_sections_parity.py b/tools/test_random_tick_sections_parity.py new file mode 100644 index 000000000..632808523 --- /dev/null +++ b/tools/test_random_tick_sections_parity.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +"""Compare which sections of a chunk random-tick, and the positions drawn in them, with the pinned client. + +Vanilla random-ticks a section while its count of randomly ticking blocks and fluids is above zero +(LevelChunkSection.isRandomlyTicking, counted by setBlockState and recalcBlockCounts), whatever its palette still lists. +Each case loads sections (every block state fills one, alone, so each state's own answer is compared; others mix a +ticking and a non-ticking state), ticks, sets and removes randomly ticking blocks (leaving them in the palette), and +ticks again. Vanilla runs ServerLevel.tickChunk's section loop on real sections with the real getBlockRandomPos +(VanillaRandomTickSectionsOracle); Horizon runs Behaviours::tick_chunk_random with the game's RandomTickSections +(examples/random_tick_sections_probe). Both print every drawn position, whether its block and its fluid tick +randomly, and the final randValue. +""" +import itertools +import json +import random + +try: + from . import lab, oracle_harness as harness +except ImportError: + import lab, oracle_harness as harness + +COUNT = 3000 +SECTIONS = 24 + + +def make_cases(build): + resources = lab.LOCAL / 'horizon-client' / '26.3' + states = json.loads((resources / 'gameplay-facts.json').read_text())['states'] + ticking = [s['id'] for s in states if s['random_ticks']] + still = [s['id'] for s in states if not s['random_ticks']] + sweep = itertools.cycle(range(len(states))) + rng = random.Random(0x5449434B) + lines = [f'#resources {resources}'] + for _ in range(COUNT): + ops = [] + loaded = rng.sample(range(SECTIONS), 14) + for section in loaded[:12]: + state = next(sweep) + ops.append(f'f:{section}:{state}:{state}:1') + mixed = loaded[12:] + for section in mixed: + ops.append(f'f:{section}:{rng.choice(still)}:{rng.choice(ticking)}:{rng.choice([1, 2, 7, 64, 4096])}') + ops.append('t') + placed = [] + for _ in range(rng.randrange(1, 6)): + section, index = rng.randrange(SECTIONS), rng.randrange(4096) + ops.append(f's:{section}:{index}:{rng.choice(ticking)}') + placed.append((section, index)) + ops.append('t') + # Take them away again, and the lone ticking block of the mixed sections: + # their palettes keep the states. + for section, index in placed + [(section, 4095) for section in mixed]: + ops.append(f's:{section}:{index}:{rng.choice([0, 0, rng.choice(still)])}') + ops.append('t') + ops.append('t') + lines.append(f'{rng.randrange(-2**31, 2**31)} {rng.choice([0, 1, 2, 3, 3, 3, 4])} {" ".join(ops)}') + path = build / 'cases.txt' + path.write_text('\n'.join(lines) + '\n') + return path, COUNT + + +if __name__ == '__main__': + harness.differential( + 'random-tick-sections-parity', 'VanillaRandomTickSectionsOracle', 'random_tick_sections_probe', make_cases, + 'Which sections of a chunk random-tick (block and fluid counts over loads, sets and removals, not the palette) ' + 'and the positions tickChunk draws in them, with each position\'s block and fluid random-tick flags. The ' + 'blocks\' random-tick behaviour itself is test_random_tick_parity\'s.', + sources=[lab.ROOT / 'crates/horizon-client/src/random_tick_sections.rs', + lab.ROOT / 'crates/horizon-client/src/chunk.rs', + lab.ROOT / 'crates/horizon-core/src/paletted.rs', + lab.ROOT / 'crates/horizon-world/src/level/tick.rs', + lab.ROOT / 'crates/horizon-world/src/level/ticks.rs'], + expected_lines=COUNT) From a069c2716f9a2bcf394859a53e44e0538825f9ad Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:24:07 +0200 Subject: [PATCH 2/2] Random ticks: ask for the next ticking section, and read a section's blocks faster tick_chunk_random asks for the lowest randomly ticking section from a height up, instead of asking about every section: a chunk costs one question per section that ticks, not 24. PalettedContainer::has tests whole words for the few matching palette indices (a field-wise zero test) instead of reading every entry, so a section read again after an edit costs a few hundred word operations. Co-Authored-By: Claude Opus 5.5 --- .../examples/random_tick_sections_probe.rs | 2 +- crates/horizon-client/src/game.rs | 4 +- .../src/random_tick_sections.rs | 47 ++++++-- crates/horizon-core/src/paletted.rs | 105 +++++++++++++----- crates/horizon-world/src/level/mod.rs | 2 +- crates/horizon-world/src/level/tick.rs | 18 +-- 6 files changed, 127 insertions(+), 51 deletions(-) diff --git a/crates/horizon-client/examples/random_tick_sections_probe.rs b/crates/horizon-client/examples/random_tick_sections_probe.rs index cb8a8b742..91c861f45 100644 --- a/crates/horizon-client/examples/random_tick_sections_probe.rs +++ b/crates/horizon-client/examples/random_tick_sections_probe.rs @@ -99,7 +99,7 @@ fn main() -> Result<(), Box> { &mut level, &mut ticks, ChunkPos::new(0, 0), - |_, min_y| cache.get((0, 0), &chunk, &facts).contains(min_y), + |_, from| cache.get((0, 0), &chunk, &facts).from(from), ); for pos in level.reads.borrow().iter() { let state = chunk.block(pos.x, pos.y, pos.z); diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index afdb2ee37..20e75fcdf 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2427,7 +2427,7 @@ impl Game<'_> { let mut read = None; let mut sections = Default::default(); let pos = horizon_core::position::ChunkPos::new(x, z); - b.tick_chunk_random(level, ticks, pos, |level, min_y| { + b.tick_chunk_random(level, ticks, pos, |level, from| { if read != Some(level.world.revision) { read = Some(level.world.revision); sections = level @@ -2438,7 +2438,7 @@ impl Game<'_> { level.random_tick_sections.get((x, z), chunk, level.facts) }); } - sections.contains(min_y) + sections.from(from) }); } b.run_block_events(level, ticks); diff --git a/crates/horizon-client/src/random_tick_sections.rs b/crates/horizon-client/src/random_tick_sections.rs index 23d6a3dbe..ebab40a7b 100644 --- a/crates/horizon-client/src/random_tick_sections.rs +++ b/crates/horizon-client/src/random_tick_sections.rs @@ -12,10 +12,10 @@ use std::sync::{Arc, Weak}; #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct Sections(u32); impl Sections { - /// Whether the section starting at block `min_y` is in the set. - pub fn contains(self, min_y: i32) -> bool { - let index = (min_y - MIN_Y) >> 4; - (0..SECTIONS as i32).contains(&index) && self.0 >> index & 1 != 0 + /// The minimum Y of the lowest section in the set from block `min_y` up. + pub fn from(self, min_y: i32) -> Option { + let index = ((min_y - MIN_Y) >> 4).max(0) as u32; + Sections(self.0 & u32::MAX.checked_shl(index).unwrap_or(0)).next() } } impl Iterator for Sections { @@ -184,6 +184,27 @@ mod tests { .collect::>(), [MIN_Y, MIN_Y + 9 * 16, MIN_Y + (SECTIONS as i32 - 1) * 16] ); + let sections = cache.get_with((0, 0), &chunk, |id| id == 299); + let top = MIN_Y + (SECTIONS as i32 - 1) * 16; + let from = |y| sections.from(y); + assert_eq!( + [ + from(MIN_Y - 16), + from(MIN_Y), + from(MIN_Y + 16), + from(MIN_Y + 9 * 16) + ], + [ + Some(MIN_Y), + Some(MIN_Y), + Some(MIN_Y + 9 * 16), + Some(MIN_Y + 9 * 16) + ] + ); + assert_eq!( + [from(top), from(top + 16), from(top + 1000)], + [Some(top), None, None] + ); } } @@ -359,19 +380,21 @@ mod tick_parity { for (x, z) in lit(&original) { // Vanilla's rule, asked as each section is reached: any of its // 4,096 blocks ticks randomly. - let reference = |level: &mut Level, min_y: i32| { + let reference = |level: &mut Level, from: i32| { let chunk = &level.chunks[&(x, z)]; - (0..16).any(|y| { - (0..16).any(|z| (0..16).any(|x| random(chunk.get(x, min_y + y, z)))) - }) + (from..MIN_Y + SECTIONS as i32 * 16) + .step_by(16) + .find(|&min_y| { + (0..16).any(|y| { + (0..16).any(|z| (0..16).any(|x| random(chunk.get(x, min_y + y, z)))) + }) + }) }; behaviours.tick_chunk_random(&mut original, &mut a, ChunkPos::new(x, z), reference); } for (x, z) in lit(&cached) { - let memoized = |level: &mut Level, min_y| { - cache - .get((x, z), &level.chunks[&(x, z)], &facts) - .contains(min_y) + let memoized = |level: &mut Level, from| { + cache.get((x, z), &level.chunks[&(x, z)], &facts).from(from) }; behaviours.tick_chunk_random(&mut cached, &mut b, ChunkPos::new(x, z), memoized); } diff --git a/crates/horizon-core/src/paletted.rs b/crates/horizon-core/src/paletted.rs index dad7f76a0..43189f425 100644 --- a/crates/horizon-core/src/paletted.rs +++ b/crates/horizon-core/src/paletted.rs @@ -677,37 +677,43 @@ impl PalettedContainer { /// Whether any entry satisfies `predicate`. Unlike [`Self::maybe_has`], /// palette entries no entry uses any more don't count. pub fn has(&self, mut predicate: impl FnMut(u32) -> bool) -> bool { - let matching: Vec = match &self.palette { + let list = match &self.palette { Palette::Single(value) => return predicate(*value), - Palette::List(list) => list.iter().map(|&v| predicate(v)).collect(), - Palette::Global => Vec::new(), + Palette::List(list) => list, + Palette::Global => { + return (0..self.strategy.entries()).any(|i| predicate(self.raw(i) as u32)); + } }; - if matches!(self.palette, Palette::List(_)) { - if !matching.contains(&true) { - return false; - } - if !matching.contains(&false) { - return true; - } + let matching: Vec = list.iter().map(|&v| predicate(v)).collect(); + let count = matching.iter().filter(|&&m| m).count(); + if count == 0 || count == list.len() { + return count != 0; } - let bits = usize::from(self.bits); + let (bits, entries) = (usize::from(self.bits), self.strategy.entries()); let per = 64 / bits; - let m = mask(self.bits); - let mut left = self.strategy.entries(); - for &word in &self.words { - for slot in 0..per.min(left) { - let id = ((word >> (slot * bits)) & m) as usize; - let hit = match self.palette { - Palette::Global => predicate(id as u32), - _ => matching[id], - }; - if hit { - return true; - } - } - left = left.saturating_sub(per); + // The words whose fields all hold entries; the last may be partial. + let full = entries / per; + if count <= 4 { + // A field-wise zero test of each word XORed with the matching + // index in every field: `(v - lo) & !v & hi` is non-zero exactly + // when some field of `v` is zero. + let lo = (0..per).fold(0u64, |a, f| a | 1 << (f * bits)); + let hi = lo << (bits - 1); + let words = &self.words[..full]; + let found = matching + .iter() + .enumerate() + .filter(|(_, m)| **m) + .any(|(i, _)| { + let pattern = lo * i as u64; + words.iter().any(|&w| { + let v = w ^ pattern; + v.wrapping_sub(lo) & !v & hi != 0 + }) + }); + return found || (full * per..entries).any(|i| matching[self.raw(i)]); } - false + (0..entries).any(|i| matching[self.raw(i)]) } /// Heap bytes held by the palette and the storage. pub fn heap_bytes(&self) -> usize { @@ -816,6 +822,53 @@ mod tests { } } #[test] + fn has_matches_a_scan_at_every_width() { + let mut state = 0x9E37_79B9_7F4A_7C15u64; + for (strategy, distinct) in [ + (BLOCKS, 2u32), + (BLOCKS, 3), + (BLOCKS, 17), + (BLOCKS, 33), + (BLOCKS, 65), + (BLOCKS, 129), + (BIOMES, 2), + (BIOMES, 3), + (BIOMES, 5), + ] { + let entries = strategy.entries(); + let mut c = PalettedContainer::new(strategy, 0); + let mut plain = vec![0u32; entries]; + for i in 0..entries { + let v = (rng(&mut state) % u64::from(distinct)) as u32; + c.set(i, v); + plain[i] = v; + } + // Take some values away again (stale entries), the last index too. + for gone in [0, 1, distinct - 1] { + for i in 0..entries { + if plain[i] == gone { + c.set(i, distinct); + plain[i] = distinct; + } + } + for m in [3, 5, 7] { + let hit = |v: u32| v % m == gone % m; + assert_eq!(c.has(hit), plain.iter().any(|&v| hit(v))); + } + for wanted in 0..=distinct { + for other in [wanted, wanted + 1, wanted + 2, wanted + 3, wanted + 4] { + let hit = |v: u32| v == wanted || v == other; + assert_eq!( + c.has(hit), + plain.iter().any(|&v| hit(v)), + "{distinct} values, {wanted}/{other}, without {gone}" + ); + } + } + } + } + } + #[test] fn has_ignores_stale_palette_entries() { let mut c = PalettedContainer::new(BLOCKS, 0); assert!(c.has(|v| v == 0) && !c.has(|v| v == 3)); diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index 1c338f2ed..e343e06a7 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -69,7 +69,7 @@ //! level.time += 1; //! behaviours.tick_scheduled(&mut level, &mut ticks); //! for chunk in ticking_chunks { -//! behaviours.tick_chunk_random(&mut level, &mut ticks, chunk, |level, min_y| level.randomly_ticking(chunk, min_y)); +//! behaviours.tick_chunk_random(&mut level, &mut ticks, chunk, |level, from| level.next_ticking_section(chunk, from)); //! } //! behaviours.run_block_events(&mut level, &mut ticks); //! /* tick entities */ diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index e9e4f6791..0f640ef3a 100644 --- a/crates/horizon-world/src/level/tick.rs +++ b/crates/horizon-world/src/level/tick.rs @@ -1617,16 +1617,17 @@ impl Behaviours { } /// Random-tick one chunk (`ServerLevel.tickChunk` block part). Visits the /// sections from the bottom up and draws `randomTickSpeed` positions in - /// each one `ticking(level, min_y)` reports randomly ticking - /// (`LevelChunkSection.isRandomlyTicking`: it holds a randomly ticking - /// block or fluid). Vanilla asks as it reaches each section, so the ticks - /// of the sections below count. + /// each randomly ticking one (`LevelChunkSection.isRandomlyTicking`: it + /// holds a randomly ticking block or fluid). `next_ticking(level, min_y)` + /// is the minimum Y of the lowest such section from `min_y` up, as the + /// chunk is now: vanilla asks as it reaches each section, so the ticks of + /// the sections below count. pub fn tick_chunk_random( &self, level: &mut L, ticks: &mut Ticks, chunk: ChunkPos, - mut ticking: impl FnMut(&mut L, i32) -> bool, + mut next_ticking: impl FnMut(&mut L, i32) -> Option, ) { let speed = level.game_rules().random_tick_speed; if speed <= 0 { @@ -1641,14 +1642,13 @@ impl Behaviours { } } } - for min_y in (level.min_y()..level.max_y()).step_by(16) { - if !ticking(level, min_y) { - continue; - } + let mut from = level.min_y(); + while let Some(min_y) = next_ticking(level, from).filter(|&y| y < level.max_y()) { for _ in 0..speed { let pos = ticks.block_random_pos(min_x, min_y, min_z, 15); self.sim(level, ticks).random_tick_at(pos); } + from = min_y + 16; } } /// Random-tick a single position (block then fluid), as `tickChunk` does.