From da314fa658e9b07b0e1c8d5552a126bbeb9c7bc2 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Oct 2026 19:28:55 +0000 Subject: [PATCH 01/59] Server tick: cheaper view requeue and chunk ticket levels Two costs that grow with players on the server thread: - Hub::update_view rebuilt a player's chunk queue on every chunk crossing by scanning the queue (a Vec) once for each chunk of the view. It now checks a set. Same queue, same order (differential test against the old scan). 111 -> 16 us per crossing at view 10, 6.5 ms -> 0.13 ms at 32. - ChunkTickets rebuilt a hash map of every ticketed chunk whenever any player changed chunk, and every block entity, mob and ticking chunk hashed into it. Levels are now a grid over the tickets' bounding box, with the map kept for tickets spread too far apart. At 50 players: build 0.23 -> 0.08 ms, lookups about 2x faster (differential test over 200 random ticket layouts). Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/lan/hub.rs | 112 ++++++++-- crates/horizon-client/src/ticket_levels.rs | 232 ++++++++++++++++++++- 2 files changed, 322 insertions(+), 22 deletions(-) diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index a961d57a4..76a9551fe 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -240,6 +240,30 @@ fn tracked(cx: i32, cz: i32, r: i32, x: i32, z: i32) -> bool { dx * dx + dz * dz < i64::from(r) * i64::from(r) } +/// The view's queue around a new centre: the queued chunks still tracked, then +/// the tracked ones neither sent nor queued, closest first (a stable sort, so +/// equally close chunks keep their order). +fn requeue( + queue: &mut Vec<(i32, i32)>, + sent: &crate::fast_hash::FxHashSet<(i32, i32)>, + (cx, cz): (i32, i32), + r: i32, +) { + queue.retain(|&(x, z)| tracked(cx, cz, r, x, z)); + // A walking player changes chunk every few ticks with hundreds of chunks + // queued: a set, not a scan of the queue for each of the view's chunks. + let mut queued: crate::fast_hash::FxHashSet<(i32, i32)> = queue.iter().copied().collect(); + for dz in -r - 2..=r + 2 { + for dx in -r - 2..=r + 2 { + let key = (cx + dx, cz + dz); + if tracked(cx, cz, r, key.0, key.1) && !sent.contains(&key) && queued.insert(key) { + queue.push(key); + } + } + } + queue.sort_by_key(|&(x, z)| i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2)); +} + /// What a level's players were last told of its clock and weather. #[derive(Clone, Copy)] struct LevelSync { @@ -1288,20 +1312,7 @@ impl Hub { g.sent_chunks.remove(&(x, z)); g.send(&C::ForgetLevelChunk(play::ForgetLevelChunk { pos: [x, z] })); } - g.chunk_queue.retain(|&(x, z)| tracked(cx, cz, r, x, z)); - for dz in -r - 2..=r + 2 { - for dx in -r - 2..=r + 2 { - let key = (cx + dx, cz + dz); - if tracked(cx, cz, r, key.0, key.1) - && !g.sent_chunks.contains(&key) - && !g.chunk_queue.contains(&key) - { - g.chunk_queue.push(key); - } - } - } - g.chunk_queue - .sort_by_key(|&(x, z)| i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2)); + requeue(&mut g.chunk_queue, &g.sent_chunks, (cx, cz), r); } /// PlayerChunkSender.sendNextChunks' choice: ready chunks, closest first, @@ -2457,3 +2468,76 @@ fn ticking_state(rate: f32, frozen: bool) -> C { w.bool(frozen); raw(ids::TICKING_STATE, w.data) } + +#[cfg(test)] +mod tests { + use super::*; + use crate::fast_hash::FxHashSet; + + /// `requeue` as it was, scanning the queue for each chunk of the view. + fn requeue_scan( + queue: &mut Vec<(i32, i32)>, + sent: &FxHashSet<(i32, i32)>, + (cx, cz): (i32, i32), + r: i32, + ) { + queue.retain(|&(x, z)| tracked(cx, cz, r, x, z)); + for dz in -r - 2..=r + 2 { + for dx in -r - 2..=r + 2 { + let key = (cx + dx, cz + dz); + if tracked(cx, cz, r, key.0, key.1) && !sent.contains(&key) && !queue.contains(&key) + { + queue.push(key); + } + } + } + queue.sort_by_key(|&(x, z)| i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2)); + } + + /// A player walking a loop, sending a few chunks a tick: the queue + /// after every move is the one the scan built. + #[test] + fn requeue_matches_the_scan() { + for r in [2, 5, 10, 12, 32] { + let (mut a, mut b) = (Vec::new(), Vec::new()); + let mut sent = FxHashSet::default(); + for step in 0..60i32 { + let center = ((step % 17) - 8, (step * 3 % 11) - 5); + requeue(&mut a, &sent, center, r); + requeue_scan(&mut b, &sent, center, r); + assert_eq!(a, b, "radius {r}, step {step}"); + for key in a.drain(..a.len().min(7)) { + sent.insert(key); + } + b.drain(..b.len().min(7)); + sent.retain(|&(x, z)| tracked(center.0, center.1, r, x, z)); + } + } + } + + /// cargo test --release -p horizon-client --lib lan::hub::tests::requeue_cost -- --ignored --nocapture + #[test] + #[ignore] + fn requeue_cost() { + for r in [10, 16, 32] { + for (name, f) in [ + ("scan", requeue_scan as fn(&mut _, &_, _, _)), + ("set", requeue as fn(&mut _, &_, _, _)), + ] { + let sent = FxHashSet::default(); + let mut queue = Vec::new(); + let start = std::time::Instant::now(); + let moves = 200; + for step in 0..moves { + // Nothing sent yet (an explorer waiting on generation). + f(&mut queue, &sent, (step, 0), r); + } + let per = start.elapsed().as_secs_f64() * 1e6 / f64::from(moves); + println!( + "view {r}: {name} {per:.1} us per chunk crossed, {} queued", + queue.len() + ); + } + } + } +} diff --git a/crates/horizon-client/src/ticket_levels.rs b/crates/horizon-client/src/ticket_levels.rs index 216815de1..de2c427ad 100644 --- a/crates/horizon-client/src/ticket_levels.rs +++ b/crates/horizon-client/src/ticket_levels.rs @@ -45,13 +45,52 @@ pub struct Sources { /// block ticking or lower; `None` ticks everywhere (a game with no server and /// no player: the headless fixtures). #[derive(Clone, Default)] -pub struct Levels(Option>>); +pub struct Levels(Option>); + +/// The levels by chunk: a grid over the tickets' bounding box while it is +/// small (players near each other, the usual case), a map otherwise. Every +/// block entity, mob and ticking chunk asks each tick, so an index beats a +/// hash; and a player crossing into another chunk rebuilds it all. +enum Map { + Grid { + x0: i32, + z0: i32, + width: u32, + depth: u32, + cells: Box<[(u8, u8)]>, + }, + Sparse(FxHashMap<(i32, i32), (u8, u8)>), +} + +/// The largest grid, in chunks: 1 MiB of levels, a box 724 chunks wide. +const GRID_CELLS: u64 = 1 << 19; + +impl Map { + fn get(&self, x: i32, z: i32) -> (u8, u8) { + match self { + Self::Grid { + x0, + z0, + width, + depth, + cells, + } => { + let (dx, dz) = (x.wrapping_sub(*x0) as u32, z.wrapping_sub(*z0) as u32); + if dx < *width && dz < *depth { + cells[(dz * width + dx) as usize] + } else { + NONE + } + } + Self::Sparse(map) => map.get(&(x, z)).copied().unwrap_or(NONE), + } + } +} impl Levels { /// Chunk coordinates. fn get(&self, x: i32, z: i32) -> Option<(u8, u8)> { - let map = self.0.as_ref()?; - Some(map.get(&(x, z)).copied().unwrap_or(NONE)) + Some(self.0.as_ref()?.get(x, z)) } /// `DistanceManager.inEntityTickingRange`, in an entity-ticking chunk: /// where entities tick. @@ -112,19 +151,89 @@ impl ChunkTickets { } } -fn compute(s: &Sources) -> FxHashMap<(i32, i32), (u8, u8)> { +/// How far a player's tickets reach, and the simulation ticket's level. +fn reach(s: &Sources) -> (i32, i32, i32) { let view = s.view_distance.clamp(0, 32); let simulation = s.simulation_distance.clamp(0, 32); + // PLAYER_LOADING within the view distance, PLAYER_SIMULATION at the + // player's chunk (`getPlayerTicketLevel`: never below 0). + let player_sim = (i32::from(ENTITY_TICKING) - simulation).max(0); + let reach = (view + 1).max(i32::from(BLOCK_TICKING) - player_sim); + (view, player_sim, reach) +} + +fn compute(s: &Sources) -> Map { + let (view, player_sim, reach) = reach(s); + let boxes = s + .players + .iter() + .map(|&p| (p, reach)) + .chain(s.forced.iter().map(|&f| (f, 1))); + let Some((x0, z0, x1, z1)) = boxes.fold(None, |b, ((x, z), r)| { + let (lo_x, lo_z, hi_x, hi_z) = ( + i64::from(x) - i64::from(r), + i64::from(z) - i64::from(r), + i64::from(x) + i64::from(r), + i64::from(z) + i64::from(r), + ); + Some(match b { + None => (lo_x, lo_z, hi_x, hi_z), + Some((a, b, c, d)) => (lo_x.min(a), lo_z.min(b), hi_x.max(c), hi_z.max(d)), + }) + }) else { + return Map::Sparse(FxHashMap::default()); + }; + let (width, depth) = ((x1 - x0 + 1) as u64, (z1 - z0 + 1) as u64); + if width * depth > GRID_CELLS { + return Map::Sparse(compute_sparse(s)); + } + let (x0, z0, width, depth) = (x0 as i32, z0 as i32, width as u32, depth as u32); + let mut cells = vec![NONE; (width * depth) as usize].into_boxed_slice(); + let mut lower = |x: i32, z: i32, loading: i32, sim: i32| { + let i = ((z - z0) as u32 * width + (x - x0) as u32) as usize; + let e = &mut cells[i]; + e.0 = e.0.min(loading.min(i32::from(NONE.0)) as u8); + e.1 = e.1.min(sim.min(i32::from(NONE.1)) as u8); + }; + for &(px, pz) in &s.players { + for dz in -reach..=reach { + for dx in -reach..=reach { + let d = dx.abs().max(dz.abs()); + lower( + px + dx, + pz + dz, + i32::from(ENTITY_TICKING) + (d - view).max(0), + player_sim + d, + ); + } + } + } + for &(fx, fz) in &s.forced { + for dz in -1i32..=1 { + for dx in -1i32..=1 { + let level = i32::from(ENTITY_TICKING) + dx.abs().max(dz.abs()); + lower(fx + dx, fz + dz, level, level); + } + } + } + Map::Grid { + x0, + z0, + width, + depth, + cells, + } +} + +/// The levels as a map, for tickets spread too far apart for a grid. +fn compute_sparse(s: &Sources) -> FxHashMap<(i32, i32), (u8, u8)> { + let (view, player_sim, reach) = reach(s); let mut levels: FxHashMap<(i32, i32), (u8, u8)> = FxHashMap::default(); let mut lower = |key, loading: i32, sim: i32| { let e = levels.entry(key).or_insert(NONE); e.0 = e.0.min(loading.min(i32::from(NONE.0)) as u8); e.1 = e.1.min(sim.min(i32::from(NONE.1)) as u8); }; - // PLAYER_LOADING within the view distance, PLAYER_SIMULATION at the - // player's chunk (`getPlayerTicketLevel`: never below 0). - let player_sim = (i32::from(ENTITY_TICKING) - simulation).max(0); - let reach = (view + 1).max(i32::from(BLOCK_TICKING) - player_sim); for &(px, pz) in &s.players { for dz in -reach..=reach { for dx in -reach..=reach { @@ -229,4 +338,111 @@ mod tests { t.update(None); assert!(t.levels().0.is_none()); } + + /// The grid answers as the map does, everywhere around the tickets. + #[test] + fn grid_matches_the_map() { + let mut seed = 0x2545_f491_4f6c_dd1du64; + let mut next = |n: i32| { + seed ^= seed << 13; + seed ^= seed >> 7; + seed ^= seed << 17; + (seed % (2 * n as u64 + 1)) as i32 - n + }; + for case in 0..200 { + let spread = [3, 20, 80][case % 3]; + let players: Vec<_> = (0..1 + case % 12) + .map(|_| (next(spread), next(spread))) + .collect(); + let forced: Vec<_> = (0..case % 4) + .map(|_| (next(spread), next(spread))) + .collect(); + let s = Sources { + players, + forced, + view_distance: 2 + next(12).abs(), + simulation_distance: 2 + next(12).abs(), + }; + let Map::Grid { .. } = compute(&s) else { + panic!("case {case} fell back to the map"); + }; + let (grid, map) = (compute(&s), Map::Sparse(compute_sparse(&s))); + let r = spread + 50; + for z in -r..=r { + for x in -r..=r { + assert_eq!(grid.get(x, z), map.get(x, z), "case {case} at ({x}, {z})"); + } + } + } + } + + #[test] + fn far_apart_tickets_use_the_map() { + let l = levels( + &[(0, 0), (100_000, -100_000)], + &[(i32::MAX - 2, i32::MIN + 2)], + 10, + 10, + ); + assert!(matches!(**l.0.as_ref().unwrap(), Map::Sparse(_))); + assert!(l.entity_ticking(100_010, -100_010) && !l.block_ticking(50_000, 0)); + assert!(l.entity_ticking(i32::MAX - 2, i32::MIN + 2)); + } + + /// cargo test --release -p horizon-client --lib ticket_levels::tests::levels_cost -- --ignored --nocapture + #[test] + #[ignore] + fn levels_cost() { + for players in [1usize, 10, 25, 50] { + // The benchmark's bots: most near spawn, a fifth flying outwards. + let at: Vec<_> = (0..players) + .map(|i| { + let a = i as f64 * 2.399; + let d = if i % 5 == 0 { 30.0 } else { 3.0 }; + ((a.cos() * d) as i32, (a.sin() * d) as i32) + }) + .collect(); + let s = Sources { + players: at.clone(), + forced: Vec::new(), + view_distance: 10, + simulation_distance: 10, + }; + let rounds = 200; + let t = std::time::Instant::now(); + for _ in 0..rounds { + std::hint::black_box(compute_sparse(std::hint::black_box(&s))); + } + let map_build = t.elapsed().as_secs_f64() * 1e3 / rounds as f64; + let t = std::time::Instant::now(); + for _ in 0..rounds { + std::hint::black_box(compute(std::hint::black_box(&s))); + } + let grid_build = t.elapsed().as_secs_f64() * 1e3 / rounds as f64; + // A tick's questions: every chunk within 12 of every player. + let (map, grid) = (Map::Sparse(compute_sparse(&s)), compute(&s)); + let ask = |m: &Map| { + let t = std::time::Instant::now(); + let mut n = 0u32; + for _ in 0..rounds { + for &(px, pz) in &at { + for z in pz - 12..=pz + 12 { + for x in px - 12..=px + 12 { + n += + u32::from(std::hint::black_box(m.get(x, z)).0 <= BLOCK_TICKING); + } + } + } + } + std::hint::black_box(n); + t.elapsed().as_secs_f64() * 1e3 / rounds as f64 + }; + println!( + "{players} players: build {map_build:.3} -> {grid_build:.3} ms, {} lookups {:.3} -> {:.3} ms", + players * 625, + ask(&map), + ask(&grid) + ); + } + } } From 62874d8dc43d131c93b2800a767e68f37b0b4be6 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 00:31:00 +0000 Subject: [PATCH 02/59] Furnaces: look up the cooking recipe in an index, without cloning it Every lit furnace, smoker and blast furnace called Recipes::cook each tick, which scanned all cooking recipes (string compares and hash lookups) and the furnace then cloned the recipe found, its ingredient's item set included. Recipes now keeps, built at the first lookup, the first recipe of each kind for each item, which is what the scan returned; the furnace borrows it. 1000 lookups over 320 recipes: 2.07 -> 0.08 ms Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/containers.rs | 2 +- crates/horizon-client/src/crafting.rs | 96 +++++++++++++++++++++++++ 2 files changed, 97 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index 6a135799c..854332815 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -528,7 +528,7 @@ impl Furnace { let has_fuel = self.items[1].is_some(); if lit || has_fuel && has_ingredient { if let Some(ingredient) = self.items[0].clone() { - if let Some(recipe) = recipes.cook(self.kind.recipe_type(), &ingredient).cloned() { + if let Some(recipe) = recipes.cook(self.kind.recipe_type(), &ingredient) { if self.cooking_timer == 0 { self.cooking_total = total_time(recipe.time, self.speed); } diff --git a/crates/horizon-client/src/crafting.rs b/crates/horizon-client/src/crafting.rs index e96ca0067..d0b8906ee 100644 --- a/crates/horizon-client/src/crafting.rs +++ b/crates/horizon-client/src/crafting.rs @@ -1102,7 +1102,11 @@ pub struct Recipes { facts: HashMap, Facts>, /// The `#minecraft:curse` enchantments. curses: HashSet, + /// The first cooking recipe of each kind taking each item, built at the + /// first lookup (furnaces look theirs up every tick). + cook_index: std::sync::OnceLock, } +type CookIndex = HashMap>; /// `MinMaxBounds.Ints` as (min, max) with the given defaults. fn bounds(v: Option<&Value>, default: (i64, i64), open: (i64, i64)) -> (i64, i64) { match v { @@ -1421,6 +1425,7 @@ impl Recipes { meta, facts, curses, + cook_index: Default::default(), }) } /// Match a `size`x`size` grid (row-major) against the crafting recipes. @@ -1606,6 +1611,22 @@ impl Recipes { out } pub fn cook(&self, kind: &str, input: &ItemStack) -> Option<&Cooking> { + let index = self.cook_index.get_or_init(|| { + let mut index = CookIndex::new(); + for (i, c) in self.cooking.iter().enumerate() { + let of_kind = index.entry(c.kind.clone()).or_default(); + for item in &c.ingredient.0 { + of_kind.entry(item.clone()).or_insert(i); + } + } + index + }); + let i = *index.get(kind)?.get(&*input.item)?; + self.cooking.get(i) + } + /// `cook` by scanning every recipe, as it was before the index. + #[cfg(test)] + fn cook_scan(&self, kind: &str, input: &ItemStack) -> Option<&Cooking> { self.cooking .iter() .find(|c| c.kind == kind && c.ingredient.test(input)) @@ -1625,6 +1646,80 @@ mod tests { s.data_mut().banner_patterns = vec![BannerLayer::new("minecraft:cross", "red")]; s } + /// About vanilla's count of cooking recipes: four kinds, ingredients of + /// one to twelve items, overlapping (several recipes take some items). + fn cooking_book() -> Recipes { + let kinds = ["smelting", "blasting", "smoking", "campfire_cooking"]; + let cooking = (0..320usize) + .map(|i| Cooking { + id: format!("r{i}"), + category: "misc".into(), + group: String::new(), + kind: kinds[i % 4].into(), + ingredient: ingredient( + &(0..1 + i % 12) + .map(|k| format!("minecraft:item_{}", (i * 7 + k * 13) % 400)) + .collect::>() + .iter() + .map(String::as_str) + .collect::>(), + ), + result: ItemStack::new("minecraft:stone", 1), + experience: 0.1, + time: 200, + }) + .collect(); + Recipes { + crafting: Vec::new(), + cooking, + meta: HashMap::new(), + facts: HashMap::new(), + curses: HashSet::new(), + cook_index: Default::default(), + } + } + #[test] + fn cook_finds_the_first_recipe_the_scan_finds() { + let recipes = cooking_book(); + for kind in [ + "smelting", + "blasting", + "smoking", + "campfire_cooking", + "other", + ] { + for n in 0..420 { + let stack = ItemStack::new(&format!("minecraft:item_{n}"), 1); + let a = recipes.cook(kind, &stack).map(|c| &c.id); + let b = recipes.cook_scan(kind, &stack).map(|c| &c.id); + assert_eq!(a, b, "{kind} item_{n}"); + } + } + } + /// A furnace's recipe lookup, once per lit furnace per tick. + #[test] + #[ignore] + fn cook_cost() { + let recipes = cooking_book(); + let stacks: Vec = (0..1000) + .map(|n| ItemStack::new(&format!("minecraft:item_{}", n % 400), 1)) + .collect(); + let t = std::time::Instant::now(); + let a = stacks + .iter() + .filter(|s| recipes.cook_scan("smelting", s).cloned().is_some()) + .count(); + let before = t.elapsed().as_secs_f64() * 1e3; + recipes.cook("smelting", &stacks[0]); + let t = std::time::Instant::now(); + let b = stacks + .iter() + .filter(|s| recipes.cook("smelting", s).is_some()) + .count(); + let after = t.elapsed().as_secs_f64() * 1e3; + assert_eq!(a, b); + println!("1000 furnace lookups (scan and clone -> index): {before:.3} ms -> {after:.3} ms"); + } fn run(special: &Special, cells: &[ItemStack]) -> Option { let recipes = Recipes { crafting: Vec::new(), @@ -1632,6 +1727,7 @@ mod tests { meta: HashMap::new(), facts: HashMap::new(), curses: HashSet::new(), + cook_index: Default::default(), }; let ctx = Context { recipes: &recipes, From 2ecbdd57ebfc50459e4cd5017cbe24f3a790ae8a Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 00:46:17 +0000 Subject: [PATCH 03/59] Mob pushes: one list per mob once a crowd is pushing Pushes between mobs wait in a list until their target ticks; each mob's tick scanned the whole list, and take_mob_pushes removed each push from the events in place, shifting the rest. In a pen where every mob pushes its neighbours both grow with the square of the crowd per mob. The pending pushes stay a list while short (64) and become one list per mob past that, each in push order, so every velocity adds up the same values in the same order. take_mob_pushes splits the events in one pass, keeping the order of the others. A test checks velocities bit for bit and the remaining events against the old code. 30 mobs pushing each other: 0.11 -> 0.04 ms per tick 100 mobs pushing each other: 1.73 -> 0.37 ms 200 mobs pushing each other: 9.07 -> 2.61 ms Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- .../horizon-client/examples/mob_ai_probe.rs | 2 +- crates/horizon-client/src/game/creatures.rs | 2 +- crates/horizon-client/src/mobs.rs | 282 +++++++++++++++++- 3 files changed, 270 insertions(+), 16 deletions(-) diff --git a/crates/horizon-client/examples/mob_ai_probe.rs b/crates/horizon-client/examples/mob_ai_probe.rs index 2a4969221..974293ee5 100644 --- a/crates/horizon-client/examples/mob_ai_probe.rs +++ b/crates/horizon-client/examples/mob_ai_probe.rs @@ -1132,7 +1132,7 @@ fn main() -> horizon_client::Result<()> { } #[allow(unused_mut)] // filled only with the rng-trace feature let mut traces: Vec = Vec::new(); - let mut pushes = Vec::new(); + let mut pushes = horizon_client::mobs::PendingPushes::default(); let mut born = Vec::new(); for i in 0..mobs.len() { if mobs[i].removed { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 113558e34..baf968729 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -498,7 +498,7 @@ impl Game<'_> { // The level random, lent to the mobs (brain behaviours draw from // it) and taken back after their ticks. let mut scratch = self.world.random.clone(); - let mut pushes = Vec::new(); + let mut pushes = horizon_client::mobs::PendingPushes::default(); let mut keep = Vec::with_capacity(mobs.len()); let mut grid = horizon_client::mobs::seen_grid::SeenGrid::new(snapshot.iter().map(|s| s.bounds)); diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index c8155984c..2c19b9251 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1308,31 +1308,67 @@ impl Mob { /// `Entity.push` on other mobs acts at once in vanilla: a mob ticking later /// moves with it this tick. Takes the `Push` events aimed at mobs out of /// `events[from..]` into `pending`, which the caller adds to each mob's -/// velocity before its tick (and to every mob once all have ticked). -pub fn take_mob_pushes(events: &mut Vec, from: usize, pending: &mut Vec<(u32, Vec3)>) { - let mut i = from; - while i < events.len() { +/// velocity before its tick (and to every mob once all have ticked). The +/// other events keep their order. +pub fn take_mob_pushes(events: &mut Vec, from: usize, pending: &mut PendingPushes) { + // One pass: a crowd's tick holds a push per neighbour, and removing each + // in place would shift the rest every time. + let mut kept = from; + for i in from..events.len() { if let MobEvent::Push { target: Who::Mob(id), velocity, } = events[i] { - pending.push((id, Vec3::new(velocity[0], velocity[1], velocity[2]))); - events.remove(i); + pending.push(id, Vec3::new(velocity[0], velocity[1], velocity[2])); } else { - i += 1; + events.swap(kept, i); + kept += 1; } } + events.truncate(kept); +} +/// Pushes waiting for their mob's tick, in push order. A list while short; +/// past [`PendingPushes::LIST_MAX`] (a crowd pushing each other) one list +/// per mob, as scanning the whole list for each mob grows with its square. +#[derive(Default)] +pub struct PendingPushes { + list: Vec<(u32, Vec3)>, + by_mob: crate::fast_hash::FxHashMap>, +} +impl PendingPushes { + const LIST_MAX: usize = 64; + pub fn push(&mut self, id: u32, v: Vec3) { + if self.by_mob.is_empty() && self.list.len() < Self::LIST_MAX { + self.list.push((id, v)); + return; + } + // Older pushes first, so each mob's stay in order. + for (id, v) in self.list.drain(..) { + self.by_mob.entry(id).or_default().push(v); + } + self.by_mob.entry(id).or_default().push(v); + } } /// Adds the pending pushes aimed at `m` to its velocity, in push order. -pub fn apply_mob_pushes(m: &mut Mob, pending: &mut Vec<(u32, Vec3)>) { - pending.retain(|(id, v)| { - if *id != m.id { - return true; - } +pub fn apply_mob_pushes(m: &mut Mob, pending: &mut PendingPushes) { + let mut add = |v: Vec3| { m.velocity = Vec3::new(m.velocity.x + v.x, m.velocity.y + v.y, m.velocity.z + v.z); - false - }); + }; + if !pending.list.is_empty() { + pending.list.retain(|(id, v)| { + if *id != m.id { + return true; + } + add(*v); + false + }); + } + if !pending.by_mob.is_empty() + && let Some(pushes) = pending.by_mob.remove(&m.id) + { + pushes.into_iter().for_each(add); + } } /// Applies the brain memories a mob's tick set on other mobs (from event /// index `from` on), at once: vanilla sets them on the other entity during @@ -2132,3 +2168,221 @@ mod elytra_tests { assert!((wings.angles[1] - 0.08726646).abs() < 0.00001); } } +#[cfg(test)] +mod push_tests { + use super::*; + use horizon_core::geometry::Vec3; + use serde_json::json; + + fn kind() -> Arc { + Arc::new(MobType { + id: "minecraft:cow".into(), + species: Species::Cow, + width: 0.9, + height: 1.4, + eye_height: 1.3, + category: "creature".into(), + max_health: 10.0, + speed: 0.2, + flying_speed: 0.4, + attack_damage: 0.0, + attack_knockback: 0.0, + follow_range: 16.0, + step_height: 0.6, + armor: 0.0, + armor_toughness: 0.0, + knockback_resistance: 0.0, + jump_strength: 0.42, + attributes: Arc::default(), + gravity: 0.08, + safe_fall_distance: 3.0, + fall_damage_multiplier: 1.0, + water_efficiency: 0.0, + water_slowdown: 0.8, + air_speed: 0.02, + baby_scale: 0.5, + head_rot_speed: 10.0, + max_head_x_rot: 40.0, + max_head_y_rot: 75.0, + ambient_interval: 120, + flags: Flags { + animal: true, + ..Default::default() + }, + model: Arc::new(Part::parse("root", &json!({}))), + layers: HashMap::new(), + texture: String::new(), + brain: Brain::Passive, + anim: Anim::Rabbit, + sounds: [""; 3], + step_sound: None, + food: Arc::default(), + tempt: Arc::default(), + }) + } + + /// The pending pushes as one list, scanned for each mob, as before. + fn take_old(events: &mut Vec, from: usize, pending: &mut Vec<(u32, Vec3)>) { + let mut i = from; + while i < events.len() { + if let MobEvent::Push { + target: Who::Mob(id), + velocity, + } = events[i] + { + pending.push((id, Vec3::new(velocity[0], velocity[1], velocity[2]))); + events.remove(i); + } else { + i += 1; + } + } + } + fn apply_old(velocity: &mut Vec3, id: u32, pending: &mut Vec<(u32, Vec3)>) { + pending.retain(|(to, v)| { + if *to != id { + return true; + } + *velocity = Vec3::new(velocity.x + v.x, velocity.y + v.y, velocity.z + v.z); + false + }); + } + fn mobs(n: u32) -> Vec { + let kind = kind(); + (0..n) + .map(|id| Mob::new(id, kind.clone(), Vec3::ZERO, 0.0)) + .collect() + } + /// A crowd tick: each mob takes its pushes, then pushes every other + /// mob (and the player, and hisses now and then); then all take theirs. + fn crowd_tick( + n: u32, + tick: u32, + mut on_push: impl FnMut(&mut Vec, usize), + mut on_apply: impl FnMut(u32), + ) -> Vec { + let mut events = Vec::new(); + for i in 0..n { + on_apply(i); + let from = events.len(); + for j in 0..n { + if j != i && !(i * 31 + j * 17 + tick).is_multiple_of(5) { + let f = f64::from(i * 7 + j + tick) * 0.001; + events.push(MobEvent::Push { + target: Who::Mob(j), + velocity: [f, -f * 0.5, f * 0.25], + }); + } + if j.is_multiple_of(9) { + events.push(MobEvent::Hiss { mob: j }); + } + } + events.push(MobEvent::Push { + target: Who::Player, + velocity: [0.1, 0.0, 0.1], + }); + on_push(&mut events, from); + } + for i in 0..n { + on_apply(i); + } + events + } + + #[test] + fn pushes_land_as_with_the_list() { + for n in [1u32, 3, 8, 20, 60] { + let mut new_mobs = mobs(n); + let mut old_v = vec![Vec3::ZERO; n as usize]; + let mut pending = PendingPushes::default(); + let mut old_pending = Vec::new(); + for tick in 0..4 { + let new_events = { + let pending = std::cell::RefCell::new(&mut pending); + let mobs = std::cell::RefCell::new(&mut new_mobs); + crowd_tick( + n, + tick, + |e, from| take_mob_pushes(e, from, &mut pending.borrow_mut()), + |i| { + apply_mob_pushes( + &mut mobs.borrow_mut()[i as usize], + &mut pending.borrow_mut(), + ) + }, + ) + }; + let old_events = { + let pending = std::cell::RefCell::new(&mut old_pending); + let v = std::cell::RefCell::new(&mut old_v); + crowd_tick( + n, + tick, + |e, from| take_old(e, from, &mut pending.borrow_mut()), + |i| { + apply_old( + &mut v.borrow_mut()[i as usize], + i, + &mut pending.borrow_mut(), + ) + }, + ) + }; + assert_eq!(format!("{new_events:?}"), format!("{old_events:?}")); + for i in 0..n as usize { + let (a, b) = (new_mobs[i].velocity, old_v[i]); + assert_eq!( + (a.x.to_bits(), a.y.to_bits(), a.z.to_bits()), + (b.x.to_bits(), b.y.to_bits(), b.z.to_bits()), + "{n} mobs, tick {tick}, mob {i}" + ); + } + } + } + } + + /// One tick of a pen of `n` mobs pushing each other. + #[test] + #[ignore] + fn push_cost() { + for n in [10u32, 30, 100, 200] { + let mut ms = mobs(n); + let mut v = vec![Vec3::ZERO; n as usize]; + let t = std::time::Instant::now(); + { + let pending = std::cell::RefCell::new(Vec::new()); + let v = std::cell::RefCell::new(&mut v); + crowd_tick( + n, + 0, + |e, from| take_old(e, from, &mut pending.borrow_mut()), + |i| { + apply_old( + &mut v.borrow_mut()[i as usize], + i, + &mut pending.borrow_mut(), + ) + }, + ); + } + let before = t.elapsed().as_secs_f64() * 1e3; + let t = std::time::Instant::now(); + { + let pending = std::cell::RefCell::new(PendingPushes::default()); + let ms = std::cell::RefCell::new(&mut ms); + crowd_tick( + n, + 0, + |e, from| take_mob_pushes(e, from, &mut pending.borrow_mut()), + |i| { + apply_mob_pushes( + &mut ms.borrow_mut()[i as usize], + &mut pending.borrow_mut(), + ) + }, + ); + } + let after = t.elapsed().as_secs_f64() * 1e3; + println!("{n} mobs pushing each other: {before:.3} ms -> {after:.3} ms"); + } + } +} From 6216b846691aab89cf46a105a66e871703670401 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Oct 2026 23:54:13 +0000 Subject: [PATCH 04/59] Mob tick: build the mob world once a tick, index the snapshot tick_creature_entities called mob_world_base for every mob. That rebuilt the player view (its allies set scans every mob UUID) and, with any scoreboard team, an owned copy of every mob's team, each a clone of the team's player set: cubic in the mobs on a team. The base is now built once and cloned per mob, with the teams borrowed behind an Arc. 100 mobs, half on a team: 37.7 ms -> 0.06 ms per tick 500 mobs, half on a team: 4297 ms -> 0.31 ms per tick MobWorld::seen looked mobs up by scanning the snapshot; the mob ticks now pass an id index (first slot wins, as the scan did): 2000 lookups over 2000 mobs 1.09 -> 0.01 ms. The nearest-living-entity sensors, the look-at goal, the ravager's roar and MobWorld::nearby read candidates from the tick's position grid instead of every mob, in the same order: 2000 mobs 0.39 -> 0.11 ms per tick. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/game/creatures.rs | 20 +- crates/horizon-client/src/game/scoreboard.rs | 8 +- crates/horizon-client/src/mobs.rs | 253 +++++++++++++++++- .../horizon-client/src/mobs/animal_brain.rs | 2 +- crates/horizon-client/src/mobs/goals.rs | 3 +- .../horizon-client/src/mobs/monster_brain.rs | 2 +- crates/horizon-client/src/mobs/ravager.rs | 2 +- .../horizon-client/src/mobs/villager_brain.rs | 2 +- .../horizon-client/src/mobs/warden_brain.rs | 2 +- crates/horizon-client/src/mobs/world.rs | 18 +- 10 files changed, 285 insertions(+), 27 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 113558e34..d538b5828 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -389,6 +389,7 @@ impl Game<'_> { player, others, others_grid: None, + others_index: None, daylight: self.dim != Dim::Nether && self.sky_darken() < 4, game_time: self.world.game_time, day_time: self.world.day_time, @@ -401,7 +402,7 @@ impl Game<'_> { end: self.dim == Dim::End, world_seed: self.level.seed, sea_level: if self.dim == Dim::Nether { 32 } else { 63 }, - teams: self.mob_teams(), + teams: std::sync::Arc::new(self.mob_teams()), items: Some(self.res.items()), difficulty: self.local_difficulty( self.player @@ -502,9 +503,22 @@ impl Game<'_> { let mut keep = Vec::with_capacity(mobs.len()); let mut grid = horizon_client::mobs::seen_grid::SeenGrid::new(snapshot.iter().map(|s| s.bounds)); + // All but the snapshot is the same for every mob of the tick, so + // build it once: the player view and the teams scan every UUID. + let base = self.mob_world_base(&[]); + // Each mob keeps its snapshot slot all tick; the first slot of an + // id answers, as a scan would. + let mut index = horizon_client::fast_hash::FxHashMap::::default(); + for (i, s) in snapshot.iter().enumerate() { + index.entry(s.id).or_insert(i as u32); + } for i in 0..mobs.len() { - let mut w = self.mob_world_base(&snapshot); - w.others_grid = Some(&grid); + let mut w = MobWorld { + others: &snapshot, + others_grid: Some(&grid), + others_index: Some(&index), + ..base.clone() + }; let m = &mut mobs[i]; w.nearest_player = super::natural_spawning::nearest_player( &players, diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs index 99dae39a5..e01d6ed03 100644 --- a/crates/horizon-client/src/game/scoreboard.rs +++ b/crates/horizon-client/src/game/scoreboard.rs @@ -431,20 +431,18 @@ impl Game<'_> { self.score.board.players_team(self.acting_player_name()) } /// The teams of the player and of the mobs on one (empty without teams). - pub(super) fn mob_teams(&self) -> horizon_client::mobs::Teams { + pub(super) fn mob_teams(&self) -> horizon_client::mobs::Teams<'_> { let board = &self.score.board; if board.teams.is_empty() { return Default::default(); } horizon_client::mobs::Teams { - player: self.player_team().cloned(), + player: self.player_team(), mobs: self .persist .uuids .iter() - .filter_map(|(id, uuid)| { - Some((*id, board.players_team(&uuid_text(*uuid))?.clone())) - }) + .filter_map(|(id, uuid)| Some((*id, board.players_team(&uuid_text(*uuid))?))) .collect(), } } diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index c8155984c..10d5c19cb 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1404,6 +1404,7 @@ pub struct PlayerView { /// (`EntitySelector.pushableBy` on the client). pub remote: bool, } +#[derive(Clone)] pub struct MobWorld<'a> { pub world: &'a World, pub registry: &'a horizon_world::registry::BlockRegistry, @@ -1418,6 +1419,8 @@ pub struct MobWorld<'a> { pub others: &'a [Seen], /// `others` by position, when the caller keeps one (the mob ticks). pub others_grid: Option<&'a seen_grid::SeenGrid>, + /// Where each id stands in `others`, when the caller keeps one. + pub others_index: Option<&'a crate::fast_hash::FxHashMap>, pub daylight: bool, pub game_time: i64, pub day_time: i64, @@ -1436,22 +1439,23 @@ pub struct MobWorld<'a> { pub world_seed: i64, /// `Level.getSeaLevel` (63 in the overworld, -63 in a flat world). pub sea_level: i32, - /// The scoreboard teams of the player and the mobs (collision rules). - pub teams: Teams, + /// The scoreboard teams of the player and the mobs (collision rules), + /// shared: the mob ticks build them once a tick, not once a mob. + pub teams: std::sync::Arc>, /// Item data (max stack sizes), when the host has it. pub items: Option<&'a crate::items::Items>, } /// `Entity.getTeam` of the player and of the mobs on a team. #[derive(Clone, Debug, Default)] -pub struct Teams { - pub player: Option, - pub mobs: HashMap, +pub struct Teams<'a> { + pub player: Option<&'a crate::scoreboard::Team>, + pub mobs: HashMap, } -impl Teams { - pub fn of(&self, who: Who) -> Option<&crate::scoreboard::Team> { +impl<'a> Teams<'a> { + pub fn of(&self, who: Who) -> Option<&'a crate::scoreboard::Team> { match who { - Who::Player => self.player.as_ref(), - Who::Mob(id) => self.mobs.get(&id), + Who::Player => self.player, + Who::Mob(id) => self.mobs.get(&id).copied(), } } } @@ -2132,3 +2136,234 @@ mod elytra_tests { assert!((wings.angles[1] - 0.08726646).abs() < 0.00001); } } +#[cfg(test)] +mod teams_tests { + use super::*; + use crate::save::uuid_text; + use crate::scoreboard::{Scoreboard, Team}; + + /// A board where every other mob is on the player's team, as with a + /// datapack that colours its mobs' names. + fn board(mobs: u32) -> (Scoreboard, HashMap) { + let mut board = Scoreboard::default(); + board.add_team("red"); + board.add_to_team("Steve", "red"); + let uuids: HashMap = (0..mobs) + .map(|id| (id, [id as i32, 7, -(id as i32), 11])) + .collect(); + for (id, uuid) in &uuids { + if id % 2 == 0 { + board.add_to_team(&uuid_text(*uuid), "red"); + } + } + (board, uuids) + } + /// `Game::mob_teams` as built for each mob before: owned clones of the teams. + fn owned(board: &Scoreboard, uuids: &HashMap) -> HashMap { + uuids + .iter() + .filter_map(|(id, u)| Some((*id, board.players_team(&uuid_text(*u))?.clone()))) + .collect() + } + fn borrowed<'a>(board: &'a Scoreboard, uuids: &HashMap) -> Teams<'a> { + Teams { + player: board.players_team("Steve"), + mobs: uuids + .iter() + .filter_map(|(id, u)| Some((*id, board.players_team(&uuid_text(*u))?))) + .collect(), + } + } + + #[test] + fn borrowed_teams_answer_as_the_clones() { + let (board, uuids) = board(40); + let teams = borrowed(&board, &uuids); + let old = owned(&board, &uuids); + for id in 0..41 { + assert_eq!(teams.of(Who::Mob(id)), old.get(&id), "mob {id}"); + } + assert_eq!(teams.of(Who::Player).map(|t| t.name.as_str()), Some("red")); + } + + /// One tick's worth of team building: once per mob (before) against once. + #[test] + #[ignore] + fn teams_cost() { + for mobs in [100u32, 250, 500] { + let (board, uuids) = board(mobs); + let t = std::time::Instant::now(); + for _ in 0..mobs { + std::hint::black_box(owned(&board, &uuids)); + } + let before = t.elapsed(); + let t = std::time::Instant::now(); + let reps = 20; + for _ in 0..reps { + std::hint::black_box(borrowed(&board, &uuids)); + } + let after = t.elapsed() / reps; + println!( + "{mobs} mobs, half on a team: per tick {:.3} ms -> {:.3} ms", + before.as_secs_f64() * 1e3, + after.as_secs_f64() * 1e3 + ); + } + } +} +#[cfg(test)] +mod sensor_scan_tests { + use super::*; + use horizon_core::geometry::Vec3; + use serde_json::json; + + fn kind() -> Arc { + Arc::new(MobType { + id: "minecraft:cow".into(), + species: Species::Cow, + width: 0.9, + height: 1.4, + eye_height: 1.3, + category: "creature".into(), + max_health: 10.0, + speed: 0.2, + flying_speed: 0.4, + attack_damage: 0.0, + attack_knockback: 0.0, + follow_range: 16.0, + step_height: 0.6, + armor: 0.0, + armor_toughness: 0.0, + knockback_resistance: 0.0, + jump_strength: 0.42, + attributes: Arc::default(), + gravity: 0.08, + safe_fall_distance: 3.0, + fall_damage_multiplier: 1.0, + water_efficiency: 0.0, + water_slowdown: 0.8, + air_speed: 0.02, + baby_scale: 0.5, + head_rot_speed: 10.0, + max_head_x_rot: 40.0, + max_head_y_rot: 75.0, + ambient_interval: 120, + flags: Flags { + animal: true, + ..Default::default() + }, + model: Arc::new(Part::parse("root", &json!({}))), + layers: HashMap::new(), + texture: String::new(), + brain: Brain::Passive, + anim: Anim::Rabbit, + sounds: [""; 3], + step_sound: None, + food: Arc::default(), + tempt: Arc::default(), + }) + } + /// `n` mobs in pens of 20 spread over a square of `side` blocks, as on a + /// server's farms; their snapshot and its grid. + fn herd(n: u32, side: f64) -> (Vec, seen_grid::SeenGrid) { + let kind = kind(); + let mut seed = 0x9e37_79b9_7f4a_7c15u64; + let mut next = |range: f64| { + seed = seed.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1); + (seed >> 11) as f64 / (1u64 << 53) as f64 * range + }; + let mut pen = Vec3::ZERO; + let seen: Vec = (0..n) + .map(|id| { + if id % 20 == 0 { + pen = Vec3::new(next(side), 64.0, next(side)); + } + let at = Vec3::new(pen.x + next(8.0), 64.0, pen.z + next(8.0)); + Mob::new(id, kind.clone(), at, 0.0).seen(None) + }) + .collect(); + let grid = seen_grid::SeenGrid::new(seen.iter().map(|s| s.bounds)); + (seen, grid) + } + /// `NearestLivingEntitySensor` over every mob, as the brains ran it. + fn scan(seen: &[Seen], me: &Seen, area: Aabb) -> Vec { + seen.iter() + .filter(|o| o.id != me.id && o.alive && o.bounds.intersects(area)) + .map(|o| o.id) + .collect() + } + fn indexed(seen: &[Seen], grid: &seen_grid::SeenGrid, me: &Seen, area: Aabb) -> Vec { + let mut near = Vec::new(); + assert!(grid.candidates(area, &mut near)); + near.iter() + .map(|&i| &seen[i as usize]) + .filter(|o| o.id != me.id && o.alive && o.bounds.intersects(area)) + .map(|o| o.id) + .collect() + } + + #[test] + fn the_grid_finds_what_the_scan_finds() { + let (seen, grid) = herd(600, 160.0); + for me in &seen { + let area = me.bounds.inflate(Vec3::new(16.0, 16.0, 16.0)); + assert_eq!(indexed(&seen, &grid, me, area), scan(&seen, me, area)); + } + } + + /// `MobWorld::seen` once per mob (a target, a breeding partner...), by + /// scan as before and by the tick's id index. + #[test] + #[ignore] + fn lookup_cost() { + for n in [500u32, 1000, 2000] { + let (seen, _) = herd(n, 256.0); + let index: crate::fast_hash::FxHashMap = seen + .iter() + .enumerate() + .map(|(i, s)| (s.id, i as u32)) + .collect(); + let wanted: Vec = (0..n).map(|i| (i * 7919) % n).collect(); + let t = std::time::Instant::now(); + let a: usize = wanted + .iter() + .filter_map(|&id| seen.iter().find(|s| s.id == id)) + .map(|s| s.id as usize) + .sum(); + let before = t.elapsed().as_secs_f64() * 1e3; + let t = std::time::Instant::now(); + let b: usize = wanted + .iter() + .filter_map(|&id| index.get(&id).map(|&i| &seen[i as usize])) + .map(|s| s.id as usize) + .sum(); + let after = t.elapsed().as_secs_f64() * 1e3; + assert_eq!(a, b); + println!( + "{n} lookups over {n} mobs ({} B each): {before:.3} ms -> {after:.3} ms", + std::mem::size_of::() + ); + } + } + + /// One tick of sensing: a twentieth of the mobs fire their sensor. + #[test] + #[ignore] + fn sensor_cost() { + for (n, side) in [(500u32, 256.0), (1000, 384.0), (2000, 512.0)] { + let (seen, grid) = herd(n, side); + let time = |f: &dyn Fn(&Seen, Aabb) -> usize| { + let t = std::time::Instant::now(); + let mut found = 0; + for me in &seen { + found += f(me, me.bounds.inflate(Vec3::new(16.0, 16.0, 16.0))); + } + (t.elapsed().as_secs_f64() * 1e3 / 20.0, found) + }; + let (before, a) = time(&|me, area| scan(&seen, me, area).len()); + let (after, b) = time(&|me, area| indexed(&seen, &grid, me, area).len()); + assert_eq!(a, b); + println!("{n} mobs: per tick {before:.3} ms -> {after:.3} ms"); + } + } +} diff --git a/crates/horizon-client/src/mobs/animal_brain.rs b/crates/horizon-client/src/mobs/animal_brain.rs index 9920235a9..331870b4a 100644 --- a/crates/horizon-client/src/mobs/animal_brain.rs +++ b/crates/horizon-client/src/mobs/animal_brain.rs @@ -606,7 +606,7 @@ fn sense_living(m: &mut Mob, w: &MobWorld) { let r = m.attrs.follow_range; let area = m.bounds().inflate(Vec3::new(r, r, r)); let mut found: Vec<(Who, f64)> = Vec::new(); - for o in w.others { + for o in w.others_near(area) { if o.id != m.id && o.alive && o.bounds.intersects(area) { found.push((Who::Mob(o.id), m.distance_sqr(o.position))); } diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs index 9419a23ba..38108f8bc 100644 --- a/crates/horizon-client/src/mobs/goals.rs +++ b/crates/horizon-client/src/mobs/goals.rs @@ -970,8 +970,7 @@ impl Goal for LookAtPlayer { let (id, only) = (m.id, self.only); let at = Vec3::new(m.position.x, m.eye_y(), m.position.z); let candidates: Vec<(u32, Vec3)> = - cx.w.others - .iter() + cx.w.others_near(area) .filter(|s| s.id != id && s.alive && s.bounds.intersects(area)) .filter(|s| only.is_none_or(|o| s.species == o)) .map(|s| (s.id, s.position)) diff --git a/crates/horizon-client/src/mobs/monster_brain.rs b/crates/horizon-client/src/mobs/monster_brain.rs index 238653dad..eeb2c42f2 100644 --- a/crates/horizon-client/src/mobs/monster_brain.rs +++ b/crates/horizon-client/src/mobs/monster_brain.rs @@ -299,7 +299,7 @@ fn sense_living(m: &mut Mob, w: &MobWorld) { let r = m.attrs.follow_range; let area = m.bounds().inflate(Vec3::new(r, r, r)); let mut found: Vec<(Who, f64)> = Vec::new(); - for o in w.others { + for o in w.others_near(area) { if o.id != m.id && o.alive && o.bounds.intersects(area) { found.push((Who::Mob(o.id), m.distance_sqr(o.position))); } diff --git a/crates/horizon-client/src/mobs/ravager.rs b/crates/horizon-client/src/mobs/ravager.rs index ef71b8f77..49bac4d9f 100644 --- a/crates/horizon-client/src/mobs/ravager.rs +++ b/crates/horizon-client/src/mobs/ravager.rs @@ -177,7 +177,7 @@ fn roar(m: &mut Mob, w: &MobWorld, events: &mut Vec) { velocity: fling(p.position), }); } - for s in w.others.iter() { + for s in w.others_near(area) { if s.id == m.id || !s.alive || s.species == Species::Ravager || !s.bounds.intersects(area) { continue; } diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs index 5b8500c0d..d401ea6da 100644 --- a/crates/horizon-client/src/mobs/villager_brain.rs +++ b/crates/horizon-client/src/mobs/villager_brain.rs @@ -568,7 +568,7 @@ fn sense_living(m: &mut Mob, w: &MobWorld) { let r = m.attrs.follow_range; let area = m.bounds().inflate(Vec3::new(r, r, r)); let mut found: Vec<(Who, f64)> = Vec::new(); - for o in w.others { + for o in w.others_near(area) { if o.id != m.id && o.alive && o.bounds.intersects(area) { found.push((Who::Mob(o.id), m.distance_sqr(o.position))); } diff --git a/crates/horizon-client/src/mobs/warden_brain.rs b/crates/horizon-client/src/mobs/warden_brain.rs index 41353fc83..518347e77 100644 --- a/crates/horizon-client/src/mobs/warden_brain.rs +++ b/crates/horizon-client/src/mobs/warden_brain.rs @@ -492,7 +492,7 @@ fn sense_entities(m: &mut Mob, w: &MobWorld) { let r = m.attrs.follow_range; let area = m.bounds().inflate(Vec3::new(r, r, r)); let mut found: Vec<(Who, f64)> = Vec::new(); - for o in w.others { + for o in w.others_near(area) { if o.id != m.id && o.alive && o.bounds.intersects(area) { found.push((Who::Mob(o.id), m.distance_sqr(o.position))); } diff --git a/crates/horizon-client/src/mobs/world.rs b/crates/horizon-client/src/mobs/world.rs index cc4110dd7..79bbaa30c 100644 --- a/crates/horizon-client/src/mobs/world.rs +++ b/crates/horizon-client/src/mobs/world.rs @@ -226,7 +226,13 @@ impl MobWorld<'_> { .chain(all.into_iter().flatten()) } pub fn seen(&self, id: u32) -> Option<&Seen> { - self.others.iter().find(|s| s.id == id) + match self.others_index { + Some(index) => index + .get(&id) + .and_then(|&i| self.others.get(i as usize)) + .filter(|s| s.id == id), + None => self.others.iter().find(|s| s.id == id), + } } /// Living mobs of the given species within `range` of `from`, nearest first. pub fn nearby<'s>( @@ -235,9 +241,15 @@ impl MobWorld<'_> { range: f64, pred: impl Fn(&Seen) -> bool + 's, ) -> impl Iterator + 's { + // A position within `range` puts the box's bottom face in this area + // (one block wider, as the box test is strict). + let r = range + 1.0; + let area = Aabb::new( + Vec3::new(from.x - r, from.y - r, from.z - r), + Vec3::new(from.x + r, from.y + r, from.z + r), + ); let mut v: Vec<&Seen> = self - .others - .iter() + .others_near(area) .filter(|s| { s.alive && (s.position.x - from.x).abs() <= range From 67ca65bb3b003999c511a4bd729274acc0f6da38 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Oct 2026 23:20:00 +0000 Subject: [PATCH 05/59] Mob tick: drop gone mobs' guest bindings with a set, not a scan per binding On a server every ticked mob is bound to its nearest player, and each tick the bindings of mobs that are gone were dropped by scanning every mob for each binding. Mob is 1.5 KB, so the scan misses the cache on every mob: with 1000 loaded mobs that was 0.44 ms a tick, with 2000 1.86 ms; a set of the live ids makes it 0.02 and 0.04 ms (stand-in structs of Mob's size). Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/game/creatures.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 113558e34..053047b42 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -588,7 +588,11 @@ impl Game<'_> { if let Some(host) = self.lan.as_mut() && !guests.is_empty() { - bindings.retain(|id, _| mobs.iter().any(|m| m.id == *id)); + // A set: a scan of every mob for each binding is quadratic, and a + // server's loaded mobs run into the thousands. + let live: horizon_client::fast_hash::FxHashSet = + mobs.iter().map(|m| m.id).collect(); + bindings.retain(|id, _| live.contains(id)); host.mob_players = bindings; } self.mobs.append(&mut mobs); From 3b21a975bb04548d8f64a5adde7d4b24859332ce Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 01:01:03 +0000 Subject: [PATCH 06/59] Mob goals: read nearby mobs from the tick's grid in four more places FollowParentGoal (every baby, every tick), the pufferfish's puff check, the enderman's block placing and the iron golem's DefendVillage scanned every mob. They now read candidates from the position grid around the area they test (one block wider where they test positions, as a box whose bottom face holds the position meets it), in snapshot order, and test exactly as before. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/mobs/aquatic.rs | 2 +- crates/horizon-client/src/mobs/enderman.rs | 11 +++++------ crates/horizon-client/src/mobs/goals.rs | 13 +++++++++++-- crates/horizon-client/src/mobs/golem.rs | 5 ++++- 4 files changed, 21 insertions(+), 10 deletions(-) diff --git a/crates/horizon-client/src/mobs/aquatic.rs b/crates/horizon-client/src/mobs/aquatic.rs index 702e3740d..adb2cbe3a 100644 --- a/crates/horizon-client/src/mobs/aquatic.rs +++ b/crates/horizon-client/src/mobs/aquatic.rs @@ -438,7 +438,7 @@ impl Goal for PufferfishPuff { .as_ref() .is_some_and(|p| p.alive && !p.creative && area.intersects(p.bounds)); // TARGETING_CONDITIONS: not other fish (not_scary_for_pufferfish) and alive. - let mob = cx.w.others.iter().any(|s| { + let mob = cx.w.others_near(area).any(|s| { s.id != m.id && s.alive && !matches!( diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs index 13e6c8a44..fcfba832e 100644 --- a/crates/horizon-client/src/mobs/enderman.rs +++ b/crates/horizon-client/src/mobs/enderman.rs @@ -391,12 +391,11 @@ impl Goal for LeaveBlock { let target = cx.w.world.block(x, y, z); let below = cx.w.world.block(x, y - 1, z); let bf = cx.w.facts.get(below); - let free = !cx.w.others.iter().any(|s| { - s.bounds.intersects(Aabb::new( - Vec3::new(f64::from(x), f64::from(y), f64::from(z)), - Vec3::new(f64::from(x + 1), f64::from(y + 1), f64::from(z + 1)), - )) - }); + let block = Aabb::new( + Vec3::new(f64::from(x), f64::from(y), f64::from(z)), + Vec3::new(f64::from(x + 1), f64::from(y + 1), f64::from(z + 1)), + ); + let free = !cx.w.others_near(block).any(|s| s.bounds.intersects(block)); if cx.w.facts.is_air(target) && !cx.w.facts.is_air(below) && &*bf.name != "minecraft:bedrock" diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs index 38108f8bc..c12f9e7ee 100644 --- a/crates/horizon-client/src/mobs/goals.rs +++ b/crates/horizon-client/src/mobs/goals.rs @@ -1,7 +1,11 @@ //! Vanilla's `GoalSelector` (priorities, MOVE/LOOK/JUMP/TARGET control flags, //! interruption) and the shared goals of `net.minecraft.world.entity.ai.goal`. use super::{Mob, MobEvent, MobWorld, Seen, Species, Who, world::TargetInfo}; -use horizon_core::{geometry::Vec3, jmath, random::RandomSource}; +use horizon_core::{ + geometry::{Aabb, Vec3}, + jmath, + random::RandomSource, +}; use std::sync::Arc; pub const MOVE: u8 = 1; @@ -1901,7 +1905,12 @@ impl Goal for FollowParent { let species = m.species(); let pos = m.position; let mut best: Option<(u32, f64)> = None; - for s in cx.w.others.iter().filter(|s| { + // Every position in range puts the box's bottom face in this area. + let area = Aabb::new( + Vec3::new(pos.x - 9.0, pos.y - 5.0, pos.z - 9.0), + Vec3::new(pos.x + 9.0, pos.y + 5.0, pos.z + 9.0), + ); + for s in cx.w.others_near(area).filter(|s| { s.alive && s.species == species && !s.baby diff --git a/crates/horizon-client/src/mobs/golem.rs b/crates/horizon-client/src/mobs/golem.rs index d4d67660b..c41c34f11 100644 --- a/crates/horizon-client/src/mobs/golem.rs +++ b/crates/horizon-client/src/mobs/golem.rs @@ -68,7 +68,10 @@ impl Goal for DefendVillage { if !b.intersects(p.bounds) || m.position.distance_squared(p.position) > 64.0 * 64.0 { return false; } - let bad = cx.w.others.iter().any(|s| { + // A position inside `b` puts the box's bottom face there (one block + // wider, as the box test is strict). + let near = b.inflate(Vec3::new(1.0, 1.0, 1.0)); + let bad = cx.w.others_near(near).any(|s| { s.species == Species::Villager && s.alive && s.player_rep <= -100 From a893fa6125eacaa13ea9db58d2c8d0e278bee1f3 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 00:54:15 +0000 Subject: [PATCH 07/59] Villagers: count the others' POI tickets once per search pois_in_range (AcquirePoi and the job, bed and meeting point searches) asked, for every candidate POI in range, how many tickets it had, and each answer scanned every other mob for villagers holding it: POIs times mobs per search. The others' tickets are now counted into a map at the first candidate and read from it; this villager's own memories are still checked per POI, as before. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- .../horizon-client/src/mobs/villager_brain.rs | 26 +++++++++++++------ 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs index 5b8500c0d..e981e4dda 100644 --- a/crates/horizon-client/src/mobs/villager_brain.rs +++ b/crates/horizon-client/src/mobs/villager_brain.rs @@ -898,8 +898,9 @@ fn poi_matches(m: &Mob, f: PoiFilter, p: Poi) -> bool { _ => false, } } -/// Tickets taken on a POI: by this villager's memories and by others'. -fn tickets(m: &Mob, w: &MobWorld, p: [i32; 3]) -> usize { +/// Tickets taken on a POI: by this villager's memories and by others' +/// (counted once per search by [`others_tickets`]). +fn tickets(m: &Mob, others: &crate::fast_hash::FxHashMap<[i32; 3], usize>, p: [i32; 3]) -> usize { let mut n = 0; if let Some(mm) = mem_ref(m) { for s in [ @@ -913,16 +914,22 @@ fn tickets(m: &Mob, w: &MobWorld, p: [i32; 3]) -> usize { } } } + n + others.get(&p).copied().unwrap_or(0) +} +/// The tickets the other living villagers' POIs take, by POI. +fn others_tickets(m: &Mob, w: &MobWorld) -> crate::fast_hash::FxHashMap<[i32; 3], usize> { + let mut taken = crate::fast_hash::FxHashMap::default(); for o in w.others { if o.id != m.id && o.alive && o.species == Species::Villager { - for q in [o.job, o.bed, o.potential_job, o.meeting] { - if q == Some(p) { - n += 1; - } + for q in [o.job, o.bed, o.potential_job, o.meeting] + .into_iter() + .flatten() + { + *taken.entry(q).or_insert(0) += 1; } } } - n + taken } /// The POIs of chunk `(qx, qz)` from `y0` to `y1` (within the world), in /// scan order: y, then z, then x. Only the indexed POI blocks of the sections @@ -962,6 +969,8 @@ fn pois_in_range( ) -> Vec<(Poi, [i32; 3])> { let c = block_of(m.position); let mut found = Vec::new(); + // Every candidate asks how taken it is: count the others' once. + let mut taken = None; let r2 = i64::from(radius) * i64::from(radius); let (cx, cz) = (c[0] >> 4, c[2] >> 4); let chunks = radius.div_euclid(16) + 1; @@ -974,7 +983,8 @@ fn pois_in_range( || (p[2] - c[2]).abs() > radius || dist_sqr(p, c) > r2 || !poi_matches(m, f, poi) - || tickets(m, w, p) >= poi.max_tickets() + || tickets(m, taken.get_or_insert_with(|| others_tickets(m, w)), p) + >= poi.max_tickets() { return; } From 3917f35e3e781954186d7c2c5be5fa739a333e5e Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 00:07:18 +0000 Subject: [PATCH 08/59] Natural spawning: answer mob box queries from a grid after a few scans GameLevel's isUnobstructed, noCollision (living shulkers) and the spawners' entity count each scanned every mob, computing each 1.5 KB mob's box. A spawn pass holds the game immutably, so after eight queries it builds a grid of the mobs' boxes once and reads candidates from it; the first queries still scan, as the build costs a few scans. 100 box tests, 2000 mobs: 3.48 -> 0.31 ms (grid build included) Also gives the mob_ai_probe example the new others_index field. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- .../horizon-client/examples/mob_ai_probe.rs | 1 + .../src/game/natural_spawning.rs | 88 ++++++++++++++++--- crates/horizon-client/src/mobs.rs | 52 +++++++++++ 3 files changed, 127 insertions(+), 14 deletions(-) diff --git a/crates/horizon-client/examples/mob_ai_probe.rs b/crates/horizon-client/examples/mob_ai_probe.rs index 2a4969221..66d06aa84 100644 --- a/crates/horizon-client/examples/mob_ai_probe.rs +++ b/crates/horizon-client/examples/mob_ai_probe.rs @@ -1027,6 +1027,7 @@ fn main() -> horizon_client::Result<()> { nearest_player: player.as_ref().filter(|p| !p.spectator).map(|p| p.position), others: $snapshot, others_grid: $grid, + others_index: None, daylight: (world.day_time.rem_euclid(24000)) < 12000, game_time: world.game_time, day_time: world.day_time, diff --git a/crates/horizon-client/src/game/natural_spawning.rs b/crates/horizon-client/src/game/natural_spawning.rs index 0fab09bde..6e7ddf500 100644 --- a/crates/horizon-client/src/game/natural_spawning.rs +++ b/crates/horizon-client/src/game/natural_spawning.rs @@ -9,6 +9,7 @@ use horizon_client::{ mobs::{ Mob, MobWorld, Species, data::{self, MobData}, + seen_grid::SeenGrid, spawn_rules::{Dimension, SpawnLevel}, spawn_selection::{ self, Category, Counted, Heightmap, NaturalLevel, SpawnCost, SpawnPlayer, SpawnRequest, @@ -75,8 +76,72 @@ pub(super) struct GameLevel<'g, 'a> { pub(super) pending: std::cell::RefCell>, /// The types and boxes of what a spawner created this tick. pub(super) pending_ids: std::cell::RefCell>, + /// The game's mobs by box, built once a pass has asked more than + /// [`SCANNED_QUERIES`] box queries (the mobs do not change while it + /// holds the game); the first ones scan, as the build costs a few scans. + pub(super) boxes: std::cell::OnceCell, + pub(super) box_queries: std::cell::Cell, +} +const SCANNED_QUERIES: u32 = 8; +/// A mob not removed: its index in `Game::mobs`, box, alive, and whether +/// it is a living shulker. +type MobBox = (usize, Aabb, bool, bool); +fn mob_box(i: usize, m: &Mob) -> MobBox { + let alive = m.alive(); + ( + i, + m.bounds(), + alive, + alive && m.species() == Species::Shulker, + ) +} +/// The boxes of the game's mobs not removed, and a grid over them. +pub(super) struct MobBoxes { + entries: Vec, + grid: SeenGrid, +} +impl MobBoxes { + fn new(mobs: &[Mob]) -> Self { + let entries: Vec<_> = mobs + .iter() + .enumerate() + .filter(|(_, m)| !m.removed) + .map(|(i, m)| mob_box(i, m)) + .collect(); + let grid = SeenGrid::new(entries.iter().map(|e| e.1)); + Self { entries, grid } + } + /// The entries whose boxes meet `area` (and possibly a few more). + fn near(&self, area: Aabb) -> impl Iterator + '_ { + let mut near = Vec::new(); + let indexed = self.grid.candidates(area, &mut near); + let all = (!indexed).then(|| self.entries.iter()); + near.into_iter() + .map(|i| self.entries[i as usize]) + .chain(all.into_iter().flatten().copied()) + } } impl GameLevel<'_, '_> { + /// The mobs not removed whose boxes may meet `area` (callers test them). + fn mobs_near(&self, area: Aabb) -> Box + '_> { + let asked = self.box_queries.get() + 1; + self.box_queries.set(asked); + if asked <= SCANNED_QUERIES && self.boxes.get().is_none() { + return Box::new( + self.game + .mobs + .iter() + .enumerate() + .filter(|(_, m)| !m.removed) + .map(|(i, m)| mob_box(i, m)), + ); + } + Box::new( + self.boxes + .get_or_init(|| MobBoxes::new(&self.game.mobs)) + .near(area), + ) + } fn biome(&self, x: i32, y: i32, z: i32) -> Option<&BiomeInfo> { let chunk = self.game.world.chunks.get(&(x >> 4, z >> 4))?; Some(self.game.res.biomes().get(chunk.biome(x, y, z))) @@ -218,12 +283,9 @@ impl NaturalLevel for GameLevel<'_, '_> { // getEntityCollisions(null, box): living shulkers are solid. let grown = bounds.inflate(Vec3::new(1e-7, 1e-7, 1e-7)); no_collision_empty(&mut scene, bounds) - && !self.game.mobs.iter().any(|m| { - m.species() == Species::Shulker - && m.alive() - && !m.removed - && m.bounds().intersects(grown) - }) + && !self + .mobs_near(grown) + .any(|(_, b, _, shulker)| shulker && b.intersects(grown)) && !self .pending_ids .borrow() @@ -238,10 +300,8 @@ impl NaturalLevel for GameLevel<'_, '_> { !player && !self.pending.borrow().iter().any(|b| b.intersects(bounds)) && !self - .game - .mobs - .iter() - .any(|m| m.alive() && !m.removed && m.bounds().intersects(bounds)) + .mobs_near(bounds) + .any(|(_, b, alive, _)| alive && b.intersects(bounds)) } fn spawn_mobs(&self) -> bool { self.game.ui.rules.bool("spawn_mobs") @@ -283,10 +343,8 @@ impl horizon_client::mobs::spawner::SpawnerLevel for GameLevel<'_, '_> { } fn count_entities(&self, id: &str, bounds: Aabb) -> usize { let mobs = self - .game - .mobs - .iter() - .filter(|m| !m.removed && m.kind.id == id && m.bounds().intersects(bounds)) + .mobs_near(bounds) + .filter(|&(i, b, ..)| self.game.mobs[i].kind.id == id && b.intersects(bounds)) .count(); let pending = self .pending_ids @@ -305,6 +363,8 @@ impl<'a> Game<'a> { players: self.level_players(), pending: Default::default(), pending_ids: Default::default(), + boxes: Default::default(), + box_queries: Default::default(), } } /// Creates a mob the spawner accepted, finalized the game's way; the diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 10d5c19cb..ecce6fede 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -2346,6 +2346,58 @@ mod sensor_scan_tests { } } + /// Natural spawning's `isUnobstructed` box test against every mob (real + /// `Mob`s), by scan and by a grid built once for the pass. + #[test] + #[ignore] + fn spawn_box_cost() { + let kind = kind(); + for n in [500u32, 1000, 2000] { + let (seen, _) = herd(n, 384.0); + let mobs: Vec = seen + .iter() + .map(|s| Mob::new(s.id, kind.clone(), s.position, 0.0)) + .collect(); + let mut seed = 7u64; + let mut next = |range: f64| { + seed = seed.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1); + (seed >> 11) as f64 / (1u64 << 53) as f64 * range + }; + let queries: Vec = (0..100) + .map(|_| { + let (x, z) = (next(384.0), next(384.0)); + Aabb::new(Vec3::new(x, 64.0, z), Vec3::new(x + 0.9, 65.4, z + 0.9)) + }) + .collect(); + let t = std::time::Instant::now(); + let a: Vec = queries + .iter() + .map(|&q| { + mobs.iter() + .any(|m| m.alive() && !m.removed && m.bounds().intersects(q)) + }) + .collect(); + let before = t.elapsed().as_secs_f64() * 1e3; + let t = std::time::Instant::now(); + let boxes: Vec = mobs.iter().map(|m| m.bounds()).collect(); + let grid = seen_grid::SeenGrid::new(boxes.iter().copied()); + let build = t.elapsed().as_secs_f64() * 1e3; + let mut near = Vec::new(); + let b: Vec = queries + .iter() + .map(|&q| { + assert!(grid.candidates(q, &mut near)); + near.iter().any(|&i| boxes[i as usize].intersects(q)) + }) + .collect(); + let after = t.elapsed().as_secs_f64() * 1e3; + assert_eq!(a, b); + println!( + "{n} mobs, 100 spawn box tests: {before:.3} ms -> {after:.3} ms (grid build {build:.3} ms included)" + ); + } + } + /// One tick of sensing: a twentieth of the mobs fire their sensor. #[test] #[ignore] From 863a3091612f065e9118fc94c709249fa14ada68 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 00:34:52 +0000 Subject: [PATCH 09/59] Allays and piglins: hoist per-tick lookups out of the per-mob loop tick_allays scanned every block entity of the level for each allay, every tick, to find a playing jukebox within 10 blocks. The playing jukeboxes are now collected once, at the first allay (no allay starts or stops one). piglin_pickups looked up the piglin_loved tag and hashed every item entity's id once per piglin. Each item's flag is now computed once and kept until an item is added (always pushed at the end under a new id) or removed. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/game/allays.rs | 22 ++++++++++++++++------ crates/horizon-client/src/game/piglins.rs | 14 +++++++++++++- 2 files changed, 29 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs index 52dfa7e1c..bed835663 100644 --- a/crates/horizon-client/src/game/allays.rs +++ b/crates/horizon-client/src/game/allays.rs @@ -9,18 +9,28 @@ impl Game<'_> { pub(super) fn tick_allays(&mut self) { let griefing = self.ui.rules.bool("mob_griefing"); let player = self.player.as_ref().map(|p| p.position); + // The playing jukeboxes, found at the first allay: no allay starts + // or stops one, and the block entities run into the thousands. + let mut jukeboxes: Option> = None; for i in 0..self.mobs.len() { if self.mobs[i].species() != Species::Allay || !self.mobs[i].alive() { continue; } let pos = self.mobs[i].position; // Dancing: a playing jukebox within 10 blocks. - let dancing = self.world.block_entities.iter().any(|(k, e)| { - matches!(e, BlockEntity::Jukebox(j) if j.playing) - && (f64::from(k.0) + 0.5 - pos.x).powi(2) - + (f64::from(k.1) + 0.5 - pos.y).powi(2) - + (f64::from(k.2) + 0.5 - pos.z).powi(2) - <= 100.0 + let jukeboxes = jukeboxes.get_or_insert_with(|| { + self.world + .block_entities + .iter() + .filter(|(_, e)| matches!(e, BlockEntity::Jukebox(j) if j.playing)) + .map(|(k, _)| *k) + .collect() + }); + let dancing = jukeboxes.iter().any(|k| { + (f64::from(k.0) + 0.5 - pos.x).powi(2) + + (f64::from(k.1) + 0.5 - pos.y).powi(2) + + (f64::from(k.2) + 0.5 - pos.z).powi(2) + <= 100.0 }); self.mobs[i].extra.flag = dancing && !horizon_client::mobs::goals::should_panic(&self.mobs[i]); diff --git a/crates/horizon-client/src/game/piglins.rs b/crates/horizon-client/src/game/piglins.rs index 9df5311aa..6a1e2d6b7 100644 --- a/crates/horizon-client/src/game/piglins.rs +++ b/crates/horizon-client/src/game/piglins.rs @@ -34,6 +34,9 @@ impl Game<'_> { if !self.ui.rules.bool("mob_griefing") { return; } + // Whether each item is piglin-loved, kept until an item is added or + // removed (added ones are pushed at the end under a new id). + let mut loved: (Option<(usize, Option)>, Vec) = (None, Vec::new()); for i in 0..self.mobs.len() { let m = &self.mobs[i]; if m.species() != Species::Piglin @@ -46,11 +49,20 @@ impl Game<'_> { continue; } let pos = m.position; + let key = (self.dropped.len(), self.dropped.last().map(|e| e.id)); + if loved.0 != Some(key) { + loved.0 = Some(key); + loved.1 = self + .dropped + .iter() + .map(|e| self.piglin_loved(&e.stack.item)) + .collect(); + } let best = self .dropped .iter() .enumerate() - .filter(|(_, e)| self.piglin_loved(&e.stack.item)) + .filter(|&(j, _)| loved.1[j]) .map(|(j, e)| (j, e.position.distance_squared(pos))) .filter(|(_, d)| *d <= 81.0) .min_by(|a, b| a.1.total_cmp(&b.1)); From cb0bbe7d19e0123e11915244f906791786dd244d Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 00:33:01 +0000 Subject: [PATCH 10/59] Sculk: skip the loaded-chunk diff while no chunk came or went sculk_sync_index collected every loaded chunk key into a set and diffed it against the known chunks every ten ticks, thousands of keys on a busy server. It now remembers the chunk map's membership revision and skips the diff while it is unchanged; a replaced chunk keeps its key and was not rescanned before either. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/game/sculk.rs | 7 ++++++- crates/horizon-client/src/game/sculk_fixture.rs | 1 + 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs index 096562608..8667f305f 100644 --- a/crates/horizon-client/src/game/sculk.rs +++ b/crates/horizon-client/src/game/sculk.rs @@ -71,6 +71,8 @@ pub(super) struct SculkState { /// The sculk block entities in the order they were added. index: Index, pub known: HashSet<(i32, i32)>, + /// The chunk map's membership revision `known` was taken at. + pub known_revision: Option, // Keyed by mob ids the server gives out: the fast hasher is safe. steps: FxHashMap, damaged: FxHashMap, @@ -336,7 +338,10 @@ impl Game<'_> { /// the block writes recorded since the last tick. pub(super) fn sculk_sync_index(&mut self) { // Chunks that arrived or left (every half second is plenty). - if self.sculk.ticks.is_multiple_of(10) { + // Nothing to do while no chunk came or went. + let revision = self.world.chunks.membership_revision(); + if self.sculk.ticks.is_multiple_of(10) && self.sculk.known_revision != Some(revision) { + self.sculk.known_revision = Some(revision); let loaded: HashSet<(i32, i32)> = self.world.chunks.keys().copied().collect(); let arrived: Vec<(i32, i32)> = loaded.difference(&self.sculk.known).copied().collect(); for key in arrived { diff --git a/crates/horizon-client/src/game/sculk_fixture.rs b/crates/horizon-client/src/game/sculk_fixture.rs index 890e571b8..df376a7e3 100644 --- a/crates/horizon-client/src/game/sculk_fixture.rs +++ b/crates/horizon-client/src/game/sculk_fixture.rs @@ -433,6 +433,7 @@ impl Game<'_> { }); self.level_events.clear(); self.sculk.known = self.world.chunks.keys().copied().collect(); + self.sculk.known_revision = Some(self.world.chunks.membership_revision()); self.sculk_sync_index(); let mut names: HashMap = HashMap::new(); let mut sources: Vec = Vec::new(); From 186777110f6c7996889726d90d02a80f8f0cf9fa Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 00:22:26 +0000 Subject: [PATCH 11/59] Hoppers: skip the item scan when no item reaches the hopper's column HopperBlockEntity.suckInItems scanned every item entity for each hopper that ticked without a container above. During the block-entity pass the game now keeps the set of block columns item boxes reach; a hopper whose column is not in it has nothing to suck, and the scan (same order, same item taken) runs only for the rest. Items do not move within the pass: removals leave a superset, and additions (pushed at the end with a new id) or removing the last item rebuild the set. It is dropped at the end of the pass. 500 hoppers, 200 items: 1.36 -> 0.05 ms per tick 2000 hoppers, 500 items: 13.52 -> 0.26 ms per tick 2000 hoppers, 2000 items: 60.6 -> 3.3 ms per tick Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/game.rs | 3 + .../src/game/block_entity_ticks.rs | 3 + crates/horizon-client/src/game/machines.rs | 164 ++++++++++++++++++ 3 files changed, 170 insertions(+) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 56d37a3af..c87875e4d 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1393,6 +1393,8 @@ struct Game<'a> { arrow_model: Option, tnts: Vec, hoppers: HashMap<(i32, i32, i32), machines::HopperState>, + /// Where item entities are, while the block entities tick (hoppers). + item_columns: Option, creative_screen: Creative, control: Option, frame_stats: horizon_client::control::FrameStats, @@ -11381,6 +11383,7 @@ impl<'a> Game<'a> { arrow_model: prepared.arrow_model, tnts: Vec::new(), hoppers: HashMap::new(), + item_columns: None, creative_screen: prepared.creative_screen, control: None, frame_stats: Default::default(), diff --git a/crates/horizon-client/src/game/block_entity_ticks.rs b/crates/horizon-client/src/game/block_entity_ticks.rs index bb1cadd15..094aed6ef 100644 --- a/crates/horizon-client/src/game/block_entity_ticks.rs +++ b/crates/horizon-client/src/game/block_entity_ticks.rs @@ -24,6 +24,7 @@ impl Game<'_> { let ticking = self.block_ticking_area(); let mut spawners = Vec::new(); let mut trial_spawners = Vec::new(); + self.item_columns = Some(Default::default()); for slot in self.world.block_entity_tickers() { let pos = slot.0; // Ticks before this one can remove it (`TickingBlockEntity.isRemoved`). @@ -56,6 +57,8 @@ impl Game<'_> { _ => {} } } + // Items move between passes: the columns hold for this one only. + self.item_columns = None; self.update_song_volumes(); self.scan_for_hearts(); // The client ticks (particles, sounds, the turning mob) are for a diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index c05c7295f..8ce1940c9 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -327,6 +327,46 @@ impl Containers<'_> { } } +/// The block columns any item entity's box reaches, so that a hopper with +/// no item over it skips the scan of every item. Kept for one block-entity +/// pass, in which items do not move: removing one leaves a superset, still +/// right, and adding one (always pushed at the end, under a new id) or +/// removing the last rebuilds the columns. +#[derive(Default)] +pub(super) struct ItemColumns { + /// The item count and last item id when last asked, if built. + seen: Option<(usize, Option)>, + cells: horizon_client::fast_hash::FxHashSet<(i32, i32)>, +} +impl ItemColumns { + /// Whether an item's box may reach into column (x, z). + fn may_reach( + &mut self, + items: &[horizon_client::entities::ItemEntity], + x: i32, + z: i32, + ) -> bool { + let (len, last) = (items.len(), items.last().map(|i| i.id)); + let stale = self + .seen + .is_none_or(|(seen_len, seen_last)| len > seen_len || last != seen_last); + self.seen = Some((len, last)); + if stale { + self.cells.clear(); + for item in items { + let b = item.bounds(); + let (lo, hi) = (b.min_position(), b.max_position()); + for cx in lo.x.floor() as i32..=hi.x.floor() as i32 { + for cz in lo.z.floor() as i32..=hi.z.floor() as i32 { + self.cells.insert((cx, cz)); + } + } + } + } + self.cells.contains(&(x, z)) + } +} + fn bone_meal() -> ItemStack { ItemStack { item: "minecraft:bone_meal".into(), @@ -648,6 +688,11 @@ impl Game<'_> { f64::from(pos.2) + 1.0, ], ); + if let Some(columns) = self.item_columns.as_mut() + && !columns.may_reach(&self.dropped, pos.0, pos.2) + { + return false; + } let mut i = 0; while i < self.dropped.len() { let b = self.dropped[i].bounds(); @@ -880,3 +925,122 @@ impl Game<'_> { true } } + +#[cfg(test)] +mod item_column_tests { + use super::ItemColumns; + use horizon_client::{entities::ItemEntity, items::ItemStack}; + use horizon_core::geometry::Vec3; + + fn item(id: u32, x: f64, y: f64, z: f64) -> ItemEntity { + let at = Vec3::new(x, y, z); + ItemEntity { + health: 5, + fire_ticks: 0, + id, + stack: ItemStack::new("minecraft:stone", 1), + thrower: None, + position: at, + previous: at, + velocity: Vec3::ZERO, + on_ground: true, + age: 0, + pickup_delay: 0, + bob_offset: 0.0, + ticks: 0, + } + } + /// `hopper_suck`'s test: some item box meets the hopper's SUCK_AABB. + fn scan(items: &[ItemEntity], (x, y, z): (i32, i32, i32)) -> bool { + let (min, max) = ( + Vec3::new(f64::from(x), f64::from(y) + 11.0 / 16.0, f64::from(z)), + Vec3::new(f64::from(x) + 1.0, f64::from(y) + 2.0, f64::from(z) + 1.0), + ); + items.iter().any(|i| { + let b = i.bounds(); + let (lo, hi) = (b.min_position(), b.max_position()); + lo.x < max.x + && hi.x > min.x + && lo.y < max.y + && hi.y > min.y + && lo.z < max.z + && hi.z > min.z + }) + } + + /// One tick of empty hoppers looking for items: each scans every item + /// (before) or asks the columns first (after, build included). + #[test] + #[ignore] + fn hopper_suck_cost() { + for (hoppers, count) in [(500i32, 200u32), (2000, 500), (2000, 2000)] { + let mut seed = 99u64; + let mut next = |range: f64| { + seed = seed.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1); + (seed >> 11) as f64 / (1u64 << 53) as f64 * range + }; + let items: Vec = (0..count) + .map(|id| item(id, next(160.0), 64.0, next(160.0))) + .collect(); + let at: Vec<(i32, i32, i32)> = (0..hoppers) + .map(|_| (next(160.0) as i32, 63, next(160.0) as i32)) + .collect(); + let t = std::time::Instant::now(); + let a: Vec = at.iter().map(|&h| scan(&items, h)).collect(); + let before = t.elapsed().as_secs_f64() * 1e3; + let t = std::time::Instant::now(); + let mut columns = ItemColumns::default(); + let b: Vec = at + .iter() + .map(|&h| columns.may_reach(&items, h.0, h.2) && scan(&items, h)) + .collect(); + let after = t.elapsed().as_secs_f64() * 1e3; + assert_eq!(a, b); + println!("{hoppers} hoppers, {count} items: {before:.3} ms -> {after:.3} ms"); + } + } + + #[test] + fn no_hopper_with_an_item_over_it_is_skipped() { + let mut seed = 0x1234_5678_9abc_def1u64; + let mut next = |range: f64| { + seed = seed.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1); + (seed >> 11) as f64 / (1u64 << 53) as f64 * range + }; + let mut items: Vec = Vec::new(); + let mut columns = ItemColumns::default(); + let mut next_id = 0; + let mut skipped = 0; + for round in 0..3000 { + // Items come and go as hoppers take them and crafters drop them. + match round % 5 { + 0 | 1 => { + next_id += 1; + // On edges too: a quarter of them sit on a block line. + let snap = |v: f64, edge: bool| if edge { v.floor() + 0.125 } else { v }; + let edge = round % 4 == 0; + items.push(item( + next_id, + snap(next(24.0) - 12.0, edge), + 64.0, + snap(next(24.0) - 12.0, edge), + )); + } + 2 if !items.is_empty() => { + let i = next(items.len() as f64) as usize; + items.remove(i); + } + _ => {} + } + let hopper = (next(26.0) as i32 - 13, 63, next(26.0) as i32 - 13); + let reach = columns.may_reach(&items, hopper.0, hopper.2); + let found = scan(&items, hopper); + assert!( + reach || !found, + "round {round}: skipped a hopper with an item over it" + ); + skipped += usize::from(!reach); + } + assert!(skipped > 1000, "skipped only {skipped}"); + } +} From 9019d708d0b49df09945213fe6e33246aa8b2dc0 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Oct 2026 23:10:14 +0000 Subject: [PATCH 12/59] Streaming: answer "near a player?" from a grid of the players' squares On a server every player is an extra area, and streaming asks of every loaded and wanted column, several times a tick (unloading, dropping protos, finishing, decoration, the generation scan), whether one of those squares reaches it: a scan of every player's square per question. The squares are now one grid of distances, made again when a player changes chunk, and in_extra reads it. Differential test against the scan over 60 random layouts, every margin. At 50 players, 6081 columns, 3 questions each: 0.45 ms -> 0.04 ms, plus 0.02 ms to make the grid. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE --- crates/horizon-client/src/streaming.rs | 235 +++++++++++++++++++++++++ 1 file changed, 235 insertions(+) diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 858d05d30..49d1a052b 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -276,6 +276,8 @@ pub struct Streaming { /// chunks finish out to `radius + 1` (Chebyshev) and generation reaches /// past that as around the player. They are generated and kept but not meshed. pub extra: Vec<((i32, i32), i32)>, + /// `extra`'s squares as a grid, made again when `extra` changes. + cover: Option, /// Mesh the sections for drawing (false on a server thread). pub mesh: bool, } @@ -391,6 +393,7 @@ impl GenerationScan { radius: input.ranges.radius, extra: input.ranges.extra, forced: input.ranges.forced, + cover: input.ranges.cover, }; self.remember(ranges, input.world); } else { @@ -562,6 +565,7 @@ impl Streaming { meshed_total: 0, remote: false, extra: Vec::new(), + cover: None, mesh: true, } } @@ -808,6 +812,7 @@ impl Streaming { if self.paused { return (uploads, Vec::new()); } + ExtraCover::refresh(&mut self.cover, &self.extra); self.relight_edits(world); let deferred = std::mem::take(&mut self.deferred); let received = std::iter::from_fn(|| self.results.try_recv().ok()); @@ -982,6 +987,7 @@ impl Streaming { radius: self.radius, extra: &self.extra, forced: &self.forced, + cover: ExtraCover::matching(&self.cover, &self.extra), }; let (protos, generating) = (&self.protos, &self.generating); self.decoration_order.retain(|x, z| { @@ -1109,6 +1115,7 @@ impl Streaming { radius: self.radius, extra: &self.extra, forced: &self.forced, + cover: ExtraCover::matching(&self.cover, &self.extra), }; self.waiting.retain(|&(x, sy, z)| { let back = ranges.in_view(x, z); @@ -1185,6 +1192,7 @@ impl Streaming { radius: self.radius, extra: &self.extra, forced: &self.forced, + cover: ExtraCover::matching(&self.cover, &self.extra), }, world, generating: &self.generating, @@ -1280,6 +1288,7 @@ impl Streaming { radius: self.radius, extra: &self.extra, forced: &self.forced, + cover: ExtraCover::matching(&self.cover, &self.extra), } } fn near_finished(&self, x: i32, z: i32, reach: i32) -> bool { @@ -1365,6 +1374,99 @@ struct Ranges<'a> { radius: i32, extra: &'a [((i32, i32), i32)], forced: &'a HashSet<(i32, i32)>, + /// `extra` as a grid, when one was made for it: `in_extra` without a + /// scan of every area. + cover: Option<&'a ExtraCover>, +} +/// For every column near the extra areas, how far it lies outside the +/// nearest one's square (Chebyshev distance less its radius; 0 inside). A server has an area per player, and streaming asks of every +/// loaded and wanted column whether one reaches it, several times a tick: +/// with fifty players, a scan of fifty squares per question. +struct ExtraCover { + extra: Vec<((i32, i32), i32)>, + x0: i32, + z0: i32, + width: u32, + depth: u32, + cells: Box<[i8]>, +} +impl ExtraCover { + /// The largest margin the grid answers for; beyond it (and outside the + /// grid) a column is further than that from every square. + const REACH: i32 = 4; + /// The largest grid, in columns (a mebibyte). + const CELLS: u64 = 1 << 20; + fn matching<'a>( + cover: &'a Option, + extra: &[((i32, i32), i32)], + ) -> Option<&'a ExtraCover> { + cover.as_ref().filter(|c| c.extra == extra) + } + /// Make the grid again if `extra` changed; none for one area or none + /// (a scan is as quick), or areas too far apart. + fn refresh(cover: &mut Option, extra: &[((i32, i32), i32)]) { + if cover.as_ref().is_some_and(|c| c.extra == extra) { + return; + } + *cover = Self::new(extra); + } + fn new(extra: &[((i32, i32), i32)]) -> Option { + if extra.len() < 2 || extra.iter().any(|&(_, r)| !(0..=64).contains(&r)) { + return None; + } + let k = i64::from(Self::REACH); + let (mut x0, mut z0, mut x1, mut z1) = (i64::MAX, i64::MAX, i64::MIN, i64::MIN); + for &((x, z), r) in extra { + let (x, z, r) = (i64::from(x), i64::from(z), i64::from(r) + k); + (x0, z0, x1, z1) = (x0.min(x - r), z0.min(z - r), x1.max(x + r), z1.max(z + r)); + } + let (width, depth) = ((x1 - x0 + 1) as u64, (z1 - z0 + 1) as u64); + if width * depth > Self::CELLS || x0 < i64::from(i32::MIN) || x1 > i64::from(i32::MAX) { + return None; + } + let (x0, z0, width, depth) = (x0 as i32, z0 as i32, width as u32, depth as u32); + let mut cells = vec![(Self::REACH + 1) as i8; (width * depth) as usize].into_boxed_slice(); + // Inside a square counts as 0: no margin asked for is below it. Each + // row of a square is a run of one value with a slope at either end. + let lower = |run: &mut [i8], v: i8| run.iter_mut().for_each(|c| *c = (*c).min(v)); + for &((cx, cz), r) in extra { + let reach = r + Self::REACH; + for dz in -reach..=reach { + let start = (cz + dz - z0) as usize * width as usize + (cx - x0) as usize; + let row = &mut cells[start - reach as usize..=start + reach as usize]; + let flat = dz.abs().max(r); + let centre = reach as usize; + lower( + &mut row[centre - flat as usize..=centre + flat as usize], + (flat - r) as i8, + ); + for d in flat + 1..=reach { + let v = (d - r) as i8; + lower(&mut row[centre - d as usize..=centre - d as usize], v); + lower(&mut row[centre + d as usize..=centre + d as usize], v); + } + } + } + Some(Self { + extra: extra.to_vec(), + x0, + z0, + width, + depth, + cells, + }) + } + /// Whether (x, z) is within `margin` of an area's square, for a + /// `margin` up to `REACH`. + fn within(&self, x: i32, z: i32, margin: i32) -> bool { + let (dx, dz) = ( + x.wrapping_sub(self.x0) as u32, + z.wrapping_sub(self.z0) as u32, + ); + dx < self.width + && dz < self.depth + && i32::from(self.cells[(dz * self.width + dx) as usize]) <= margin + } } impl Ranges<'_> { /// `distance`, or `rings` while the level loading screen is up. @@ -1441,6 +1543,11 @@ impl Ranges<'_> { /// Within `margin` of an extra area's square (Chebyshev distance, as /// vanilla's ticket levels spread). fn in_extra(&self, x: i32, z: i32, margin: i32) -> bool { + if let Some(cover) = self.cover + && (0..=ExtraCover::REACH).contains(&margin) + { + return cover.within(x, z, margin); + } self.extra .iter() .any(|&(c, radius)| (x - c.0).abs().max((z - c.1).abs()) <= radius + margin) @@ -1554,6 +1661,7 @@ mod tests { radius: self.radius, extra: &self.extra, forced: &self.forced, + cover: None, }, world: &self.world, generating: &self.generating, @@ -1866,6 +1974,7 @@ mod tests { radius, extra: &[], forced: &forced, + cover: None, }; let square = |x: i32, z: i32, n: i32| { (-n..=n).flat_map(move |dz| (-n..=n).map(move |dx| (x + dx, z + dz))) @@ -1920,6 +2029,7 @@ mod tests { radius: 12, extra: &[], forced: &forced, + cover: None, }; let at = |dx: i32, dz: i32| (2 + dx, -1 + dz); let key = |(x, z): (i32, i32), loading| r.priority(x, z, loading); @@ -1945,6 +2055,7 @@ mod tests { radius, extra: &[((radius * 2 + 9, 3), 4)], forced: &forced, + cover: None, }; let span = radius * 3 + 20; for x in -span..=span { @@ -1984,6 +2095,7 @@ mod tests { radius: 2, extra: &extra, forced: &forced, + cover: None, }; let level = |x: i32, z: i32| 31 + ((x - 40).abs().max((z + 9).abs()) - view).max(0); for x in 40 - view - 8..=40 + view + 8 { @@ -2021,3 +2133,126 @@ mod tests { } } } + +#[cfg(test)] +mod cover_tests { + use super::*; + + fn areas(seed: &mut u64, n: usize, spread: i32) -> Vec<((i32, i32), i32)> { + let mut next = |m: i32| { + *seed ^= *seed << 13; + *seed ^= *seed >> 7; + *seed ^= *seed << 17; + (*seed % (2 * m as u64 + 1)) as i32 - m + }; + (0..n) + .map(|_| ((next(spread), next(spread)), 2 + next(14).abs())) + .collect() + } + + /// Every question streaming asks gets the same answer with the grid. + #[test] + fn the_grid_answers_as_the_scan() { + let mut seed = 0x9E37_79B9_7F4A_7C15u64; + let forced: HashSet<(i32, i32)> = [(40, -40)].into(); + for case in 0..60 { + let extra = areas(&mut seed, 2 + case % 20, [4, 30, 120][case % 3]); + let cover = ExtraCover::new(&extra).expect("a grid"); + let ranges = |cover| Ranges { + center: (3, -2), + radius: 10, + extra: &extra, + forced: &forced, + cover, + }; + let (scan, grid) = (ranges(None), ranges(Some(&cover))); + let span = [4, 30, 120][case % 3] + 40; + for z in -span..=span { + for x in -span..=span { + for m in 0..=ExtraCover::REACH + 2 { + assert_eq!( + scan.in_extra(x, z, m), + grid.in_extra(x, z, m), + "case {case} ({x}, {z}) {m}" + ); + } + for d in [false, true] { + assert_eq!(scan.unloaded(x, z, d), grid.unloaded(x, z, d)); + assert_eq!(scan.requested(x, z, d), grid.requested(x, z, d)); + assert_eq!(scan.chunk_kept(x, z, d), grid.chunk_kept(x, z, d)); + } + } + } + } + } + + #[test] + fn a_stale_or_impossible_grid_is_not_used() { + let mut cover = None; + ExtraCover::refresh(&mut cover, &[((0, 0), 11), ((5, 5), 11)]); + assert!(ExtraCover::matching(&cover, &[((0, 0), 11), ((5, 5), 11)]).is_some()); + assert!(ExtraCover::matching(&cover, &[((0, 0), 11), ((5, 6), 11)]).is_none()); + // Too far apart for a mebibyte of grid, and one area alone: scans. + assert!(ExtraCover::new(&[((0, 0), 11), ((100_000, 0), 11)]).is_none()); + assert!(ExtraCover::new(&[((0, 0), 11)]).is_none()); + assert!(ExtraCover::new(&[((i32::MAX - 1, 0), 11), ((i32::MAX - 3, 0), 11)]).is_none()); + } + + /// cargo test --release -p horizon-client --lib cover_tests::cover_cost -- --ignored --nocapture + #[test] + #[ignore] + fn cover_cost() { + let forced = HashSet::new(); + for players in [10usize, 25, 50] { + // The benchmark's bots: most near spawn, a fifth flying outwards. + let extra: Vec<_> = (0..players) + .map(|i| { + let a = i as f64 * 2.399; + let d = if i % 5 == 0 { 30.0 } else { 3.0 }; + (((a.cos() * d) as i32, (a.sin() * d) as i32), 11) + }) + .collect(); + let cover = ExtraCover::new(&extra).unwrap(); + let ranges = |cover| Ranges { + center: (0, 0), + radius: 10, + extra: &extra, + forced: &forced, + cover, + }; + // The columns streaming asks about: everything kept, and the + // generation scan's ring past it. + let columns: Vec<(i32, i32)> = (-60..=60) + .flat_map(|z| (-60..=60).map(move |x| (x, z))) + .filter(|&(x, z)| { + ranges(None).requested(x, z, true) || !ranges(None).unloaded(x, z, true) + }) + .collect(); + let rounds = 100; + let time = |r: &Ranges| { + let t = std::time::Instant::now(); + let mut n = 0usize; + for _ in 0..rounds { + for &(x, z) in &columns { + n += usize::from(r.unloaded(x, z, true)); + n += usize::from(r.requested(x, z, true)); + n += usize::from(r.in_range(x, z, 1)); + } + } + std::hint::black_box(n); + t.elapsed().as_secs_f64() * 1e3 / f64::from(rounds) + }; + let t = std::time::Instant::now(); + for _ in 0..rounds { + std::hint::black_box(ExtraCover::new(std::hint::black_box(&extra))); + } + let build = t.elapsed().as_secs_f64() * 1e3 / f64::from(rounds); + println!( + "{players} players, {} columns, 3 questions each: scan {:.3} ms, grid {:.3} ms (+ {build:.3} ms to build)", + columns.len(), + time(&ranges(None)), + time(&ranges(Some(&cover))), + ); + } + } +} From dfe795bc090809090993c44c2a032f108efbf3f4 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 02:42:12 +0000 Subject: [PATCH 13/59] Faster Perlin volumes and climate search, same results PerlinNoise::add_volume worked out each Y coordinate's cell, offset and fade once per X/Z column. Every column walks the same Y coordinates, so they are now computed once per volume. The arithmetic is unchanged, so the output is bit for bit the same. ClimateIndex kept its tree as nodes with a Vec of child ids each. The built tree is now renumbered breadth first into flat arrays, so a branch's children are one contiguous run. The search visits the same nodes in the same order, so ties resolve exactly as before. terrain_bench (seed 12345, 8x8 chunks, 1 thread, medians of 3 runs): terrain 14.5 -> 12.4 ms/chunk, biomes 1.20 -> 1.06 ms/chunk. Checked against vanilla 26.3 in-process: 2304 chunks on seeds 12345, -1 and 987654321987 identical, and the biome-source and biome-generation parity suites (2.1M lines) match. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01M3pNrSHA2ifNrH7SAMHgSW --- crates/horizon-core/src/noise/perlin.rs | 58 ++++++++++++----- .../src/worldgen/climate/index.rs | 65 ++++++++++++------- 2 files changed, 84 insertions(+), 39 deletions(-) diff --git a/crates/horizon-core/src/noise/perlin.rs b/crates/horizon-core/src/noise/perlin.rs index 725373eff..92fa2a880 100644 --- a/crates/horizon-core/src/noise/perlin.rs +++ b/crates/horizon-core/src/noise/perlin.rs @@ -164,6 +164,31 @@ impl PerlinNoise { return Err(DensityError::BufferTooShort); } let [size_x, size_y, size_z] = volume.sizes(); + // Every X/Z column walks the same Y coordinates, so their cells, offsets + // and fades are computed once per volume instead of once per column. + let mut stack = [YSample::default(); STACK_Y]; + let mut heap = Vec::new(); + let ys = if size_y <= STACK_Y { + &mut stack[..size_y] + } else { + heap.resize(size_y, YSample::default()); + &mut heap[..] + }; + for (y, sample) in ys.iter_mut().enumerate() { + let input_y = f64::from(volume.coordinate(1, y)) * y_scale; + let shifted_y = wrap(input_y) + self.table.offsets[1]; + let cell = floor_i32(shifted_y); + let dy = shifted_y - f64::from(cell); + *sample = YSample { + cell, + fade: smoothstep(dy as f32), + offset: match fudge_y_scale { + Some(scale) => (dy - compute_fudge_y(input_y, dy, scale)) as f32, + None => dy as f32, + }, + }; + } + let ys = &*ys; let mut index = 0; for z in 0..size_z { let shifted_z = @@ -182,37 +207,40 @@ impl PerlinNoise { let mut previous_y = i32::MIN; let mut xz_dots = [0.0_f32; 8]; let mut y_gradients = [0.0_f32; 8]; - for y in 0..size_y { - let input_y = f64::from(volume.coordinate(1, y)) * y_scale; - let shifted_y = wrap(input_y) + self.table.offsets[1]; - let cell_y = floor_i32(shifted_y); - let dy = shifted_y - f64::from(cell_y); - let fade_y = smoothstep(dy as f32); - if previous_y != cell_y { - let gradients = self.gradients_at(p, q, cell_y, cell_z); + for (sample, out) in ys.iter().zip(&mut buffer[index..index + size_y]) { + if previous_y != sample.cell { + let gradients = self.gradients_at(p, q, sample.cell, cell_z); for i in 0..8 { xz_dots[i] = gradients[i][0] as f32 * (dx - (i & 1) as f32) + gradients[i][2] as f32 * (dz - ((i >> 2) & 1) as f32); y_gradients[i] = gradients[i][1] as f32; } - previous_y = cell_y; + previous_y = sample.cell; } - let dy = match fudge_y_scale { - Some(scale) => (dy - compute_fudge_y(input_y, dy, scale)) as f32, - None => dy as f32, - }; + let dy = sample.offset; let values = std::array::from_fn(|i| { xz_dots[i] + y_gradients[i] * (dy - ((i >> 1) & 1) as f32) }); - buffer[index] += amplitude * lerp3([fade_x, fade_y, fade_z], values); - index += 1; + *out += amplitude * lerp3([fade_x, sample.fade, fade_z], values); } + index += size_y; } } Ok(()) } } +/// Y columns up to this height keep their per-Y samples on the stack. +const STACK_Y: usize = 64; + +#[derive(Clone, Copy, Default)] +struct YSample { + cell: i32, + fade: f32, + /// The Y offset inside the cell used for the corner values, after any fudge. + offset: f32, +} + #[derive(Clone, Debug)] pub struct SmearedPerlinNoise { base: PerlinNoise, diff --git a/crates/horizon-world/src/worldgen/climate/index.rs b/crates/horizon-world/src/worldgen/climate/index.rs index 3e9b50f51..6a602ed92 100644 --- a/crates/horizon-world/src/worldgen/climate/index.rs +++ b/crates/horizon-world/src/worldgen/climate/index.rs @@ -202,8 +202,11 @@ fn build( #[derive(Debug)] pub struct ClimateIndex { entries: Vec<(ParameterPoint, T)>, - nodes: Vec, - root: usize, + /// The built tree renumbered breadth first, root at 0, so each branch's + /// children are one contiguous run and a search walks memory in order. + spaces: Vec<[Parameter; 7]>, + /// Per node: its first child and child count, or its entry and 0 for a leaf. + links: Vec<(u32, u32)>, } impl ClimateIndex { pub fn new(entries: Vec<(ParameterPoint, T)>) -> Result { @@ -232,10 +235,25 @@ impl ClimateIndex { .collect(); let children = (0..nodes.len()).collect(); let root = build(&mut nodes, children, branching)?; + let mut order = vec![root]; + let mut links = Vec::with_capacity(nodes.len()); + let mut next = 0; + while next < order.len() { + let node = &nodes[order[next]]; + next += 1; + links.push(match &node.children { + Children::Leaf(entry) => (*entry as u32, 0), + Children::Branch(children) => { + let first = order.len() as u32; + order.extend_from_slice(children); + (first, children.len() as u32) + } + }); + } Ok(Self { entries, - nodes, - root, + spaces: order.iter().map(|id| nodes[*id].space).collect(), + links, }) } pub fn entries(&self) -> &[(ParameterPoint, T)] { @@ -263,18 +281,18 @@ impl ClimateIndex { } /// Preorder leaf entry indices expose stable tree layout for comparison. pub fn leaf_order(&self) -> Vec { - fn walk(nodes: &[Node], id: usize, out: &mut Vec) { - match &nodes[id].children { - Children::Leaf(entry) => out.push(*entry), - Children::Branch(children) => { - for child in children { - walk(nodes, *child, out); + fn walk(links: &[(u32, u32)], id: usize, out: &mut Vec) { + match links[id] { + (entry, 0) => out.push(entry as usize), + (first, count) => { + for child in first..first + count { + walk(links, child as usize, out); } } } } let mut result = Vec::with_capacity(self.entries.len()); - walk(&self.nodes, self.root, &mut result); + walk(&self.links, 0, &mut result); result } fn search( @@ -283,19 +301,20 @@ impl ClimateIndex { values: &[i64; 7], previous: Option, ) -> Result { - let Children::Branch(children) = &self.nodes[id].children else { + let (first, count) = self.links[id]; + if count == 0 { return Ok(id); - }; + } let mut best = previous; - let mut fitness = previous.map_or(i64::MAX, |id| distance(&self.nodes[id].space, values)); - for child in children { - let lower = distance(&self.nodes[*child].space, values); + let mut fitness = previous.map_or(i64::MAX, |id| distance(&self.spaces[id], values)); + for child in first as usize..(first + count) as usize { + let lower = distance(&self.spaces[child], values); if fitness > lower { - let result = self.search(*child, values, best)?; - let next = if result == *child { + let result = self.search(child, values, best)?; + let next = if result == child { lower } else { - distance(&self.nodes[result].space, values) + distance(&self.spaces[result], values) }; if fitness > next { fitness = next; @@ -313,13 +332,11 @@ pub struct ClimateSearch<'a, T> { } impl<'a, T> ClimateSearch<'a, T> { pub fn find(&mut self, target: TargetPoint) -> Result<&'a T, IndexError> { - let result = self - .index - .search(self.index.root, &target.parameters(), self.last)?; + let result = self.index.search(0, &target.parameters(), self.last)?; self.last = Some(result); - let Children::Leaf(entry) = self.index.nodes[result].children else { + let (entry, 0) = self.index.links[result] else { unreachable!("search returns a leaf"); }; - Ok(&self.index.entries[entry].1) + Ok(&self.index.entries[entry as usize].1) } } From bc9e5afacce9cea888472491a83f57660c224dcf Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 06:26:11 +0000 Subject: [PATCH 14/59] Faster feature decoration: region grid, ore column fast path, lazy biome cache TerrainRegion indexes its chunks through a grid over their bounding box. OreFeature asks the world whether any column under its blob reaches the floor heightmap in one call, and tracks tested positions in a bitset. BiomeTemperature no longer preallocates its map and queue. Same output. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01M3pNrSHA2ifNrH7SAMHgSW --- .../src/worldgen/biome_temperature.rs | 6 +- .../src/worldgen/feature_region.rs | 76 +++++++++++++------ .../src/worldgen/generator_decoration.rs | 37 +++++++++ .../horizon-world/src/worldgen/ore_feature.rs | 33 ++++++-- .../src/worldgen/placement/context.rs | 12 +++ 5 files changed, 133 insertions(+), 31 deletions(-) diff --git a/crates/horizon-world/src/worldgen/biome_temperature.rs b/crates/horizon-world/src/worldgen/biome_temperature.rs index c7e22c985..7111214f4 100644 --- a/crates/horizon-world/src/worldgen/biome_temperature.rs +++ b/crates/horizon-world/src/worldgen/biome_temperature.rs @@ -123,10 +123,12 @@ pub struct BiomeTemperature { } impl BiomeTemperature { pub fn new(settings: BiomeTemperatureSettings) -> Self { + // Empty until used: a decoration region makes one per biome, and + // most biomes never ask for a temperature. Self { settings, - values: HashMap::with_capacity(1024), - order: VecDeque::with_capacity(1024), + values: HashMap::new(), + order: VecDeque::new(), } } pub fn settings(&self) -> BiomeTemperatureSettings { diff --git a/crates/horizon-world/src/worldgen/feature_region.rs b/crates/horizon-world/src/worldgen/feature_region.rs index 5ab361985..91de61905 100644 --- a/crates/horizon-world/src/worldgen/feature_region.rs +++ b/crates/horizon-world/src/worldgen/feature_region.rs @@ -58,7 +58,13 @@ impl From for PlacementQueryError { } } pub struct TerrainRegion<'r, B: TerrainBlockStates> { - chunks: BTreeMap<(i32, i32), TerrainChunk<'r, B>>, + /// Ordered by X then Z. + chunks: Vec>, + /// Each chunk's index in `chunks` over the chunks' bounding box, row by + /// row from `origin` (`u32::MAX`: none): every block access looks one up. + grid: Vec, + origin: (i32, i32), + columns: i32, min_y: i32, height: i32, generation: WorldGenerationContext, @@ -83,15 +89,32 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { }) { return Err(RegionError::InvalidChunks); } - let mut stored = BTreeMap::new(); - for chunk in chunks { + let mut chunks = chunks; + chunks.sort_by_key(|c| (c.position().x, c.position().z)); + let (xs, zs) = ( + chunks.iter().map(|c| c.position().x), + chunks.iter().map(|c| c.position().z), + ); + let origin = (xs.clone().min().unwrap(), zs.clone().min().unwrap()); + let columns = i64::from(xs.max().unwrap()) - i64::from(origin.0) + 1; + let rows = i64::from(zs.max().unwrap()) - i64::from(origin.1) + 1; + if columns * rows > 1 << 20 { + return Err(RegionError::InvalidChunks); + } + let mut grid = vec![u32::MAX; (columns * rows) as usize]; + for (i, chunk) in chunks.iter().enumerate() { let p = chunk.position(); - if stored.insert((p.x, p.z), chunk).is_some() { + let cell = (p.z - origin.1) as usize * columns as usize + (p.x - origin.0) as usize; + if grid[cell] != u32::MAX { return Err(RegionError::InvalidChunks); } + grid[cell] = i as u32; } Ok(Self { - chunks: stored, + chunks, + grid, + origin, + columns: columns as i32, sea_level: generator.sea_level, game_time: 0, next_tick_order: 0, @@ -114,10 +137,7 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { mut self, bindings: &super::block_feature::FeatureBlockBindings<'r>, ) -> Result { - if !std::ptr::eq( - self.chunks.first_key_value().unwrap().1.registry(), - bindings.registry(), - ) { + if !std::ptr::eq(self.chunks[0].registry(), bindings.registry()) { return Err(RegionError::InvalidBindings); } self.block_queries = Some(RegionBlockQueries { @@ -186,20 +206,35 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { } /// Release the resident chunks, ordered by X then Z; match them by position. pub fn into_chunks(self) -> Vec> { - self.chunks.into_values().collect() + self.chunks } pub fn chunks(&self) -> impl Iterator> { - self.chunks.values() + self.chunks.iter() + } + fn index(&self, x: i32, z: i32) -> Option { + let (dx, dz) = (x.wrapping_sub(self.origin.0), z.wrapping_sub(self.origin.1)); + if dx < 0 || dz < 0 || dx >= self.columns { + return None; + } + match *self + .grid + .get(dz as usize * self.columns as usize + dx as usize)? + { + u32::MAX => None, + i => Some(i as usize), + } } pub fn chunk(&self, x: i32, z: i32) -> Result<&TerrainChunk<'r, B>, RegionError> { - self.chunks - .get(&(x, z)) - .ok_or(RegionError::MissingChunk([x, z])) + match self.index(x, z) { + Some(i) => Ok(&self.chunks[i]), + None => Err(RegionError::MissingChunk([x, z])), + } } pub fn chunk_mut(&mut self, x: i32, z: i32) -> Result<&mut TerrainChunk<'r, B>, RegionError> { - self.chunks - .get_mut(&(x, z)) - .ok_or(RegionError::MissingChunk([x, z])) + match self.index(x, z) { + Some(i) => Ok(&mut self.chunks[i]), + None => Err(RegionError::MissingChunk([x, z])), + } } pub fn block(&self, [x, y, z]: [i32; 3]) -> Result { Ok(self.chunk(x >> 4, z >> 4)?.block(x, y, z)) @@ -302,12 +337,7 @@ impl PlacementContext for TerrainRegion<'_, B> { block: BlockStateId, delay: i32, ) -> Result<(), PlacementQueryError> { - let registry = self - .chunks - .first_key_value() - .expect("nonempty region") - .1 - .registry(); + let registry = self.chunks[0].registry(); let state = registry .state(block) .ok_or(RegionError::InvalidTickState(block))?; diff --git a/crates/horizon-world/src/worldgen/generator_decoration.rs b/crates/horizon-world/src/worldgen/generator_decoration.rs index bc5dbda70..a16baa506 100644 --- a/crates/horizon-world/src/worldgen/generator_decoration.rs +++ b/crates/horizon-world/src/worldgen/generator_decoration.rs @@ -1116,4 +1116,41 @@ impl PlacementContext for World<'_> { fn height(&mut self, kind: HeightmapType, x: i32, z: i32) -> Result { self.region.height(kind, x, z) } + /// OreFeature's search for a column under its blob, without a trait call + /// per column. Defers to `height` when a heightmap still has to be primed. + fn any_height_at_least( + &mut self, + kind: HeightmapType, + [x0, z0]: [i32; 2], + size: i32, + y: i32, + ) -> Result, PlacementQueryError> { + let (x1, z1) = (x0.wrapping_add(size), z0.wrapping_add(size)); + if size < 0 || x1 < x0 || z1 < z0 { + return Ok(None); + } + for cx in x0 >> 4..=x1 >> 4 { + for cz in z0 >> 4..=z1 >> 4 { + if !self + .region + .chunk(cx, cz) + .is_ok_and(|c| c.heightmap(kind).is_some()) + { + return Ok(None); + } + } + } + for x in x0..=x1 { + for z in z0..=z1 { + let map = self.region.chunk(x >> 4, z >> 4)?.heightmap(kind).unwrap(); + let floor = map + .first_available(x & 15, z & 15) + .map_err(|e| RegionError::from(super::terrain::TerrainError::from(e)))?; + if y <= floor { + return Ok(Some(true)); + } + } + } + Ok(Some(false)) + } } diff --git a/crates/horizon-world/src/worldgen/ore_feature.rs b/crates/horizon-world/src/worldgen/ore_feature.rs index 9d723ae40..d69874d76 100644 --- a/crates/horizon-world/src/worldgen/ore_feature.rs +++ b/crates/horizon-world/src/worldgen/ore_feature.rs @@ -180,6 +180,27 @@ impl OreFeature { let z_start = origin[2].wrapping_sub(spread_ceil).wrapping_sub(max_radius); let size_xz = 2 * (spread_ceil + max_radius); let size_y = 2 * (2 + max_radius); + if let Some(found) = world + .any_height_at_least( + HeightmapType::OceanFloorWg, + [x_start, z_start], + size_xz, + y_start, + ) + .map_err(FeatureExecutionError::Query)? + { + return match found { + true => self.do_place( + world, + random, + [x0, x1, z0, z1, y0, y1], + [x_start, y_start, z_start], + size_xz, + size_y, + ), + false => Ok(false), + }; + } for x in 0..=size_xz { for z in 0..=size_xz { let (px, pz) = (x_start.wrapping_add(x), z_start.wrapping_add(z)); @@ -243,7 +264,8 @@ impl OreFeature { } } } - let mut tested = vec![false; (size_xz as usize) * (size_y as usize) * (size_xz as usize)]; + let tested_len = (size_xz as usize) * (size_y as usize) * (size_xz as usize); + let mut tested = vec![0u64; tested_len.div_ceil(64)]; let mut placed = 0; for [xx, yy, zz, r] in data { if r < 0.0 { @@ -280,16 +302,15 @@ impl OreFeature { * i64::from(size_xz) * i64::from(size_y); // The sphere bounds keep indices inside the native BitSet. - let Some(bit) = usize::try_from(index) - .ok() - .and_then(|index| tested.get_mut(index)) + let Some(index) = usize::try_from(index).ok().filter(|&i| i < tested_len) else { return Err(FeatureExecutionError::WorkLimit); }; - if *bit { + let (word, bit) = (&mut tested[index / 64], 1u64 << (index % 64)); + if *word & bit != 0 { continue; } - *bit = true; + *word |= bit; let p = [x, y, z]; if !world .ensure_can_write(p) diff --git a/crates/horizon-world/src/worldgen/placement/context.rs b/crates/horizon-world/src/worldgen/placement/context.rs index 8d2a1dab7..73b9afd67 100644 --- a/crates/horizon-world/src/worldgen/placement/context.rs +++ b/crates/horizon-world/src/worldgen/placement/context.rs @@ -344,6 +344,18 @@ pub trait PlacementContext { /// World minimum, which can differ from the generator's minimum. fn min_y(&mut self) -> Result; fn height(&mut self, kind: HeightmapType, x: i32, z: i32) -> Result; + /// Whether any column of the square `x..=x + size`, `z..=z + size` has + /// `height(kind)` at least `y`, read faster than column by column; `None` + /// when the world can't (callers then ask `height` for each column). + fn any_height_at_least( + &mut self, + _kind: HeightmapType, + _corner: [i32; 2], + _size: i32, + _y: i32, + ) -> Result, PlacementQueryError> { + Ok(None) + } } impl PlacementContext for WorldGenerationContext { fn max_y(&mut self) -> Result { From 5bad717213c5119dd1d0bbfbf134ec44f6c9a6f2 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 08:43:40 +0000 Subject: [PATCH 15/59] Perlin noise without libm floor or int-to-float conversions, same values floor_i32 is now Java's Mth.floor (truncate, step down for negative fractions): f64::floor is a libm call on baseline x86-64, made for every Perlin sample. Perlin's gradient table is stored as floats (every component is -1, 0 or 1, exact either way), so the corner dot products skip three conversions each. About 10% fewer instructions generating terrain; values unchanged. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01M3pNrSHA2ifNrH7SAMHgSW --- crates/horizon-core/src/geometry/mod.rs | 34 ++++++++++++++++++++++++- crates/horizon-core/src/noise/mod.rs | 24 ++++++++++++++--- crates/horizon-core/src/noise/perlin.rs | 14 +++++----- 3 files changed, 60 insertions(+), 12 deletions(-) diff --git a/crates/horizon-core/src/geometry/mod.rs b/crates/horizon-core/src/geometry/mod.rs index 950403ee8..9b581c044 100644 --- a/crates/horizon-core/src/geometry/mod.rs +++ b/crates/horizon-core/src/geometry/mod.rs @@ -602,8 +602,16 @@ pub(crate) fn clamp(value: f64, min: f64, max: f64) -> f64 { java_min(value, max) } } +/// `Mth.floor`: truncate, then step down for negative fractions. A truncating +/// conversion and a compare, where `f64::floor` is a libm call on baseline x86-64. +#[inline] pub(crate) fn floor_i32(value: f64) -> i32 { - value.floor() as i32 + let truncated = value as i32; + if value < f64::from(truncated) { + truncated.wrapping_sub(1) + } else { + truncated + } } fn lerp(amount: f64, start: f64, end: f64) -> f64 { start + amount * (end - start) @@ -635,6 +643,30 @@ fn next_down(value: f64) -> f64 { #[cfg(test)] mod tests { use super::*; + + #[test] + fn floor_i32_is_mths_floor() { + for v in [ + 0.0, + -0.0, + 0.5, + -0.5, + 1.0, + -1.0, + 2.999, + -2.999, + 1e-300, + -1e-300, + 16_777_215.5, + -16_777_215.5, + ] { + assert_eq!(floor_i32(v), v.floor() as i32, "{v}"); + } + assert_eq!(floor_i32(f64::NAN), 0); + assert_eq!(floor_i32(3e9), i32::MAX); + // Java's (int) cast saturates, then the step down wraps. + assert_eq!(floor_i32(-3e9), i32::MAX); + } #[test] fn ray_faces_and_half_open_bounds() { let b = Aabb::block(BlockPos::new(0, 0, 0)); diff --git a/crates/horizon-core/src/noise/mod.rs b/crates/horizon-core/src/noise/mod.rs index cb255fbe5..e715b10f0 100644 --- a/crates/horizon-core/src/noise/mod.rs +++ b/crates/horizon-core/src/noise/mod.rs @@ -61,8 +61,8 @@ impl GradientTable { i32::from(self.permutations[(index & 255) as usize]) } - fn gradient(&self, index: i32) -> [i32; 3] { - GRADIENTS[(self.permute(index) & 15) as usize] + fn gradient(&self, index: i32) -> [f32; 3] { + PERLIN_GRADIENTS[(self.permute(index) & 15) as usize] } } @@ -87,8 +87,24 @@ const GRADIENTS: [[i32; 3]; 16] = [ [0, -1, -1], ]; -fn dot(gradient: [i32; 3], point: [f32; 3]) -> f32 { - gradient[0] as f32 * point[0] + gradient[1] as f32 * point[1] + gradient[2] as f32 * point[2] +/// [`GRADIENTS`] as floats, so a dot product needs no conversions: every +/// component is -1, 0 or 1, which a float holds exactly. +const PERLIN_GRADIENTS: [[f32; 3]; 16] = { + let mut out = [[0.0; 3]; 16]; + let mut i = 0; + while i < 16 { + out[i] = [ + GRADIENTS[i][0] as f32, + GRADIENTS[i][1] as f32, + GRADIENTS[i][2] as f32, + ]; + i += 1; + } + out +}; + +fn dot(gradient: [f32; 3], point: [f32; 3]) -> f32 { + gradient[0] * point[0] + gradient[1] * point[1] + gradient[2] * point[2] } /// Vanilla's periodic coordinate reduction with the normal Far Lands flag off. diff --git a/crates/horizon-core/src/noise/perlin.rs b/crates/horizon-core/src/noise/perlin.rs index 725373eff..bdf5f792b 100644 --- a/crates/horizon-core/src/noise/perlin.rs +++ b/crates/horizon-core/src/noise/perlin.rs @@ -39,7 +39,7 @@ impl PerlinNoise { ) } - fn gradients(&self, cell: [i32; 3]) -> [[i32; 3]; 8] { + fn gradients(&self, cell: [i32; 3]) -> [[f32; 3]; 8] { self.gradients_at( self.table.permute(cell[0]), self.table.permute(cell[0].wrapping_add(1)), @@ -52,7 +52,7 @@ impl PerlinNoise { /// resolved. `add_volume` reuses one X column across every Y, so hoisting /// the two X permutes out of that loop avoids repeating them per Y. #[inline] - fn gradients_at(&self, p: i32, q: i32, cell_y: i32, cell_z: i32) -> [[i32; 3]; 8] { + fn gradients_at(&self, p: i32, q: i32, cell_y: i32, cell_z: i32) -> [[f32; 3]; 8] { let lower = self.table.permute(p.wrapping_add(cell_y)); let upper = self.table.permute(p.wrapping_add(cell_y).wrapping_add(1)); let lower_x = self.table.permute(q.wrapping_add(cell_y)); @@ -66,7 +66,7 @@ impl PerlinNoise { }) } - fn corner_values(gradients: [[i32; 3]; 8], point: [f32; 3]) -> [f32; 8] { + fn corner_values(gradients: [[f32; 3]; 8], point: [f32; 3]) -> [f32; 8] { std::array::from_fn(|i| { dot( gradients[i], @@ -99,7 +99,7 @@ impl PerlinNoise { let values = Self::corner_values(gradients, point); let fade = point.map(smoothstep); let gradient = - std::array::from_fn::<_, 3, _>(|axis| lerp3(fade, gradients.map(|g| g[axis] as f32))); + std::array::from_fn::<_, 3, _>(|axis| lerp3(fade, gradients.map(|g| g[axis]))); let changes = [ lerp2( fade[1], @@ -191,9 +191,9 @@ impl PerlinNoise { if previous_y != cell_y { let gradients = self.gradients_at(p, q, cell_y, cell_z); for i in 0..8 { - xz_dots[i] = gradients[i][0] as f32 * (dx - (i & 1) as f32) - + gradients[i][2] as f32 * (dz - ((i >> 2) & 1) as f32); - y_gradients[i] = gradients[i][1] as f32; + xz_dots[i] = gradients[i][0] * (dx - (i & 1) as f32) + + gradients[i][2] * (dz - ((i >> 2) & 1) as f32); + y_gradients[i] = gradients[i][1]; } previous_y = cell_y; } From 86e08072e44651634a581e20a689ceaf34e46601 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:14:26 +0200 Subject: [PATCH 16/59] streaming: bound ExtraCover's z range too ExtraCover::new checked only x0/x1 against the i32 range, so two areas near i32::MAX or i32::MIN in z built a grid whose row arithmetic (cz + dz) overflows: a panic in debug builds, wrong cells in release. Check z the same way, and test both ends. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/streaming.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 49d1a052b..356614cb3 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -1421,7 +1421,8 @@ impl ExtraCover { (x0, z0, x1, z1) = (x0.min(x - r), z0.min(z - r), x1.max(x + r), z1.max(z + r)); } let (width, depth) = ((x1 - x0 + 1) as u64, (z1 - z0 + 1) as u64); - if width * depth > Self::CELLS || x0 < i64::from(i32::MIN) || x1 > i64::from(i32::MAX) { + let fits = |lo: i64, hi: i64| lo >= i64::from(i32::MIN) && hi <= i64::from(i32::MAX); + if width * depth > Self::CELLS || !fits(x0, x1) || !fits(z0, z1) { return None; } let (x0, z0, width, depth) = (x0 as i32, z0 as i32, width as u32, depth as u32); @@ -2196,6 +2197,8 @@ mod cover_tests { assert!(ExtraCover::new(&[((0, 0), 11), ((100_000, 0), 11)]).is_none()); assert!(ExtraCover::new(&[((0, 0), 11)]).is_none()); assert!(ExtraCover::new(&[((i32::MAX - 1, 0), 11), ((i32::MAX - 3, 0), 11)]).is_none()); + assert!(ExtraCover::new(&[((0, i32::MAX - 1), 11), ((0, i32::MAX - 3), 11)]).is_none()); + assert!(ExtraCover::new(&[((0, i32::MIN + 1), 11), ((0, i32::MIN + 3), 11)]).is_none()); } /// cargo test --release -p horizon-client --lib cover_tests::cover_cost -- --ignored --nocapture From a49cf5502d187daae072a039468a156226d90533 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:37:37 +0200 Subject: [PATCH 17/59] geometry: floor_i32 saturates below i32::MIN, as (int) Math.floor Vanilla 26.3 Mth.floor(double) is (int) Math.floor(v), so a value below i32::MIN floors to i32::MIN. The truncate-and-step version wrapped to i32::MAX there (block_collision_scan parity failed at the chunk of x = -2147483648.8: Rust 134217727, vanilla -134217728). Step down with saturating_sub; the fast path is unchanged, and the test now checks the ends of the i32 range, infinities and f64::MIN/MAX against f64::floor as i32. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-core/src/geometry/mod.rs | 26 +++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/crates/horizon-core/src/geometry/mod.rs b/crates/horizon-core/src/geometry/mod.rs index 9b581c044..3081f66be 100644 --- a/crates/horizon-core/src/geometry/mod.rs +++ b/crates/horizon-core/src/geometry/mod.rs @@ -602,13 +602,15 @@ pub(crate) fn clamp(value: f64, min: f64, max: f64) -> f64 { java_min(value, max) } } -/// `Mth.floor`: truncate, then step down for negative fractions. A truncating -/// conversion and a compare, where `f64::floor` is a libm call on baseline x86-64. +/// `Mth.floor`, which is `(int) Math.floor(v)`: truncate, then step down for +/// negative fractions. A truncating conversion and a compare, where +/// `f64::floor` is a libm call on baseline x86-64. Both casts saturate (NaN is +/// 0), so the step down saturates too: below `i32::MIN` stays `i32::MIN`. #[inline] pub(crate) fn floor_i32(value: f64) -> i32 { let truncated = value as i32; if value < f64::from(truncated) { - truncated.wrapping_sub(1) + truncated.saturating_sub(1) } else { truncated } @@ -659,13 +661,25 @@ mod tests { -1e-300, 16_777_215.5, -16_777_215.5, + // Past the i32 range `(int) Math.floor` saturates (vanilla 26.3's + // BlockCollisions and BlockPos.containing rely on it). + 2_147_483_647.5, + 2_147_483_648.0, + -2_147_483_648.0, + -2_147_483_648.5, + -2_147_483_649.0, + 3e9, + -3e9, + f64::MAX, + f64::MIN, + f64::INFINITY, + f64::NEG_INFINITY, ] { assert_eq!(floor_i32(v), v.floor() as i32, "{v}"); } assert_eq!(floor_i32(f64::NAN), 0); - assert_eq!(floor_i32(3e9), i32::MAX); - // Java's (int) cast saturates, then the step down wraps. - assert_eq!(floor_i32(-3e9), i32::MAX); + assert_eq!(floor_i32(-3e9), i32::MIN); + assert_eq!(floor_i32(-2_147_483_648.5), i32::MIN); } #[test] fn ray_faces_and_half_open_bounds() { From ac60b337aa4374456664ed54c06f58e9bf9d2a56 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:40:07 +0200 Subject: [PATCH 18/59] worldgen: chunks far apart still make a region (map past the grid) TerrainRegion::new refused a region whose chunks bounding box passed 2^20 columns, where it took any set of distinct chunks before: the bulk_section parity fixture puts a chunk at x = 4194304 beside the origin and failed with InvalidChunks. Keep the grid for the usual small box and fall back to a map past it; both refuse a position twice. The lookup now subtracts in i64, so no coordinate can wrap into the grid. Co-Authored-By: Claude Opus 5.5 --- .../src/worldgen/feature_region.rs | 120 ++++++++++++------ crates/horizon-world/tests/feature_region.rs | 43 +++++++ 2 files changed, 124 insertions(+), 39 deletions(-) diff --git a/crates/horizon-world/src/worldgen/feature_region.rs b/crates/horizon-world/src/worldgen/feature_region.rs index 91de61905..b4e8c07b0 100644 --- a/crates/horizon-world/src/worldgen/feature_region.rs +++ b/crates/horizon-world/src/worldgen/feature_region.rs @@ -22,7 +22,7 @@ use horizon_core::{ }, }; use std::{ - collections::{BTreeMap, BTreeSet}, + collections::{BTreeMap, BTreeSet, HashMap}, sync::Arc, }; @@ -60,11 +60,8 @@ impl From for PlacementQueryError { pub struct TerrainRegion<'r, B: TerrainBlockStates> { /// Ordered by X then Z. chunks: Vec>, - /// Each chunk's index in `chunks` over the chunks' bounding box, row by - /// row from `origin` (`u32::MAX`: none): every block access looks one up. - grid: Vec, - origin: (i32, i32), - columns: i32, + /// Each chunk's index in `chunks`: every block access looks one up. + index: ChunkIndex, min_y: i32, height: i32, generation: WorldGenerationContext, @@ -74,6 +71,77 @@ pub struct TerrainRegion<'r, B: TerrainBlockStates> { block_queries: Option, world_seed: Option, } +/// Where each chunk of a region sits in its list: a grid over the chunks' +/// bounding box while it is small (the usual square of neighbours), else a +/// map (chunks spread far apart). +enum ChunkIndex { + Grid { + origin: (i32, i32), + columns: i64, + rows: i64, + /// Row by row from `origin`; `u32::MAX` where no chunk is. + cells: Vec, + }, + Sparse(HashMap<(i32, i32), u32>), +} +impl ChunkIndex { + /// The largest grid, in chunk columns. + const GRID_CELLS: i64 = 1 << 20; + /// `None` when two chunks share a position. + fn new(positions: &[(i32, i32)]) -> Option { + let x0 = positions.iter().map(|p| p.0).min()?; + let z0 = positions.iter().map(|p| p.1).min()?; + let columns = i64::from(positions.iter().map(|p| p.0).max()?) - i64::from(x0) + 1; + let rows = i64::from(positions.iter().map(|p| p.1).max()?) - i64::from(z0) + 1; + if columns * rows > Self::GRID_CELLS { + let mut map = HashMap::with_capacity(positions.len()); + for (i, &p) in positions.iter().enumerate() { + if map.insert(p, i as u32).is_some() { + return None; + } + } + return Some(Self::Sparse(map)); + } + let mut cells = vec![u32::MAX; (columns * rows) as usize]; + for (i, &(x, z)) in positions.iter().enumerate() { + let cell = (i64::from(z) - i64::from(z0)) * columns + (i64::from(x) - i64::from(x0)); + let cell = &mut cells[cell as usize]; + if *cell != u32::MAX { + return None; + } + *cell = i as u32; + } + Some(Self::Grid { + origin: (x0, z0), + columns, + rows, + cells, + }) + } + fn get(&self, x: i32, z: i32) -> Option { + match self { + Self::Grid { + origin, + columns, + rows, + cells, + } => { + let (dx, dz) = ( + i64::from(x) - i64::from(origin.0), + i64::from(z) - i64::from(origin.1), + ); + if !(0..*columns).contains(&dx) || !(0..*rows).contains(&dz) { + return None; + } + match cells[(dz * columns + dx) as usize] { + u32::MAX => None, + i => Some(i as usize), + } + } + Self::Sparse(map) => map.get(&(x, z)).map(|&i| i as usize), + } + } +} impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { pub fn new( chunks: Vec>, @@ -91,30 +159,14 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { } let mut chunks = chunks; chunks.sort_by_key(|c| (c.position().x, c.position().z)); - let (xs, zs) = ( - chunks.iter().map(|c| c.position().x), - chunks.iter().map(|c| c.position().z), - ); - let origin = (xs.clone().min().unwrap(), zs.clone().min().unwrap()); - let columns = i64::from(xs.max().unwrap()) - i64::from(origin.0) + 1; - let rows = i64::from(zs.max().unwrap()) - i64::from(origin.1) + 1; - if columns * rows > 1 << 20 { - return Err(RegionError::InvalidChunks); - } - let mut grid = vec![u32::MAX; (columns * rows) as usize]; - for (i, chunk) in chunks.iter().enumerate() { - let p = chunk.position(); - let cell = (p.z - origin.1) as usize * columns as usize + (p.x - origin.0) as usize; - if grid[cell] != u32::MAX { - return Err(RegionError::InvalidChunks); - } - grid[cell] = i as u32; - } + let positions: Vec<(i32, i32)> = chunks + .iter() + .map(|c| (c.position().x, c.position().z)) + .collect(); + let index = ChunkIndex::new(&positions).ok_or(RegionError::InvalidChunks)?; Ok(Self { chunks, - grid, - origin, - columns: columns as i32, + index, sea_level: generator.sea_level, game_time: 0, next_tick_order: 0, @@ -212,17 +264,7 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { self.chunks.iter() } fn index(&self, x: i32, z: i32) -> Option { - let (dx, dz) = (x.wrapping_sub(self.origin.0), z.wrapping_sub(self.origin.1)); - if dx < 0 || dz < 0 || dx >= self.columns { - return None; - } - match *self - .grid - .get(dz as usize * self.columns as usize + dx as usize)? - { - u32::MAX => None, - i => Some(i as usize), - } + self.index.get(x, z) } pub fn chunk(&self, x: i32, z: i32) -> Result<&TerrainChunk<'r, B>, RegionError> { match self.index(x, z) { diff --git a/crates/horizon-world/tests/feature_region.rs b/crates/horizon-world/tests/feature_region.rs index c484393bf..7ff34da6f 100644 --- a/crates/horizon-world/tests/feature_region.rs +++ b/crates/horizon-world/tests/feature_region.rs @@ -385,3 +385,46 @@ fn retained_upgrade_status_allows_old_biome_reads() { } } } +#[test] +fn spread_out_regions_route_like_dense_ones() { + // Chunks too far apart for a grid over their bounding box (fixtures put + // one at the far edge of the world beside the origin's neighbours). + let registry = registry(); + let context = WorldGenerationContext::new(0, 16, 8); + let chunk = + |x, z| TerrainChunk::new(ChunkPos::new(x, z), 0, 16, ®istry, Properties).unwrap(); + for far in [4_194_304, -4_194_304] { + let mut region = TerrainRegion::new( + vec![chunk(0, 0), chunk(far, 0), chunk(1, -1), chunk(-1, 1)], + context, + ) + .unwrap(); + let x = far * 16 + 3; + region + .set_block_worldgen([x, 7, 5], BlockStateId(2)) + .unwrap(); + assert_eq!(region.block([x, 7, 5]).unwrap(), BlockStateId(2)); + assert_eq!(region.block([3, 7, 5]).unwrap(), BlockStateId(0)); + assert_eq!(region.block([16, 7, -1]).unwrap(), BlockStateId(0)); + assert!(matches!( + region.block([x + 16, 7, 5]), + Err(RegionError::MissingChunk([_, 0])) + )); + assert!(matches!( + region.block([0, 7, 16]), + Err(RegionError::MissingChunk([0, 1])) + )); + let order: Vec<_> = region + .into_chunks() + .iter() + .map(|c| (c.position().x, c.position().z)) + .collect(); + let mut sorted = order.clone(); + sorted.sort(); + assert_eq!(order, sorted, "into_chunks is ordered by X then Z"); + // A position twice is refused either way. + assert!( + TerrainRegion::new(vec![chunk(0, 0), chunk(far, 0), chunk(far, 0)], context).is_err() + ); + } +} From e01296f99b31b4085190557fdbacb9aa4ec96de4 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 13:47:37 +0000 Subject: [PATCH 19/59] Keep the pointer locked on macOS when the game captures it winit's macOS set_cursor_position re-associates the mouse with the pointer (CGAssociateMouseAndMouseCursorPosition(true)), so warping to the window centre right after the Locked grab released it again and the pointer moved freely in first person. Warp before grabbing on macOS; Wayland still warps after, since it moves a pointer only while locked. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_0188LkUPntcZdfMF3wAqR2tK --- crates/horizon-client/src/game.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..1162be7e9 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4485,10 +4485,17 @@ impl Game<'_> { }; if capture { self.mouse.set_ignore_first_move(); + // macOS warps by re-associating the mouse with the pointer, + // which undoes a Locked grab and leaves the pointer free: warp + // first there. Wayland moves a pointer only while it is locked, + // so everywhere else warp after grabbing. + #[cfg(target_os = "macos")] + warp(window); self.captured = window .set_cursor_grab(CursorGrabMode::Locked) .or_else(|_| window.set_cursor_grab(CursorGrabMode::Confined)) .is_ok(); + #[cfg(not(target_os = "macos"))] if self.captured && self.focused { warp(window); } From 4e46f2a57a804fe81afc825b6fdfc9d3eef2df25 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 14:48:08 +0100 Subject: [PATCH 20/59] bench: profile chunk generation and saved chunk loading --- crates/horizon-client/examples/load_bench.rs | 153 ++++++++++++++++++ .../horizon-world/examples/chunkgen_bench.rs | 38 ++++- docs/chunk-performance-campaign.md | 100 ++++++++++++ 3 files changed, 290 insertions(+), 1 deletion(-) create mode 100644 crates/horizon-client/examples/load_bench.rs create mode 100644 docs/chunk-performance-campaign.md diff --git a/crates/horizon-client/examples/load_bench.rs b/crates/horizon-client/examples/load_bench.rs new file mode 100644 index 000000000..5c30a71ff --- /dev/null +++ b/crates/horizon-client/examples/load_bench.rs @@ -0,0 +1,153 @@ +//! Read-only saved chunk benchmark. All timings exclude resource/corpus setup. +//! +//! load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum] +//! Add --profile-worker when a sampling collector cannot sample the main thread. +//! Reports warm filesystem SaveDir::load (read, inflate, NBT, decode and light), +//! plus isolated inflate/NBT and native decode. No files in the save are changed. +use horizon_client::{ + assets::Assets, + biome::Biomes, + blocks::BlockFacts, + save::{SaveDir, SaveTables, decode_with}, +}; +use horizon_world::{nbt::Limits, region::RegionFile}; +use sha2::{Digest, Sha256}; +use std::{hint::black_box, path::PathBuf, sync::Arc, time::Instant}; + +type Result = std::result::Result>; + +fn main() -> Result<()> { + if std::env::args().any(|a| a == "--profile-worker") { + std::thread::spawn(|| run().map_err(|e| e.to_string())) + .join() + .expect("benchmark worker") + .map_err(Into::into) + } else { + run() + } +} + +fn run() -> Result<()> { + let args: Vec = std::env::args().skip(1).collect(); + let usage = "load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum]"; + let root = PathBuf::from(args.first().ok_or(usage)?); + let dimension = PathBuf::from(args.get(1).ok_or(usage)?); + let flag = |name: &str, default: usize| -> Result { + Ok(match args.iter().position(|a| a == name) { + Some(i) => args.get(i + 1).ok_or(usage)?.parse()?, + None => default, + }) + }; + let rounds = flag("--rounds", 5)?; + let limit = flag("--limit", 256)?; + if rounds == 0 || limit == 0 { + return Err("rounds and limit must be positive".into()); + } + let assets = Assets::load(&root)?; + let facts = BlockFacts::load(&root, assets.registry)?; + let biomes = Biomes::load(&root)?; + let tables = Arc::new(SaveTables::new(&assets).with_block_entities(&facts)); + let source = SaveDir::new(dimension.clone()); + let _ = source.tables.set(tables.clone()); + let mut paths: Vec<_> = std::fs::read_dir(dimension.join("region"))? + .map(|e| e.map(|e| e.path())) + .collect::>()?; + paths.retain(|p| p.extension().is_some_and(|e| e == "mca")); + paths.sort(); + let mut corpus = Vec::new(); + 'regions: for path in paths { + let mut region = RegionFile::open(path)?; + let mut positions: Vec<_> = region.chunks().map(|(pos, _)| pos).collect(); + positions.sort_by_key(|p| (p.x, p.z)); + for pos in positions { + let record = region.read(pos)?.ok_or("missing record")?; + let tag = record.nbt(Limits::default())?; + if decode_with(&tag, assets.registry, &biomes, Some(&tables)).is_none() { + continue; + } + corpus.push((pos, record, tag)); + if corpus.len() == limit { + break 'regions; + } + } + } + if corpus.is_empty() { + return Err("no full chunks in corpus".into()); + } + let mut records_hash = Sha256::new(); + for (pos, record, _) in &corpus { + records_hash.update(pos.x.to_le_bytes()); + records_hash.update(pos.z.to_le_bytes()); + records_hash.update((record.compressed.len() as u64).to_le_bytes()); + records_hash.update(&record.compressed); + } + println!( + "{}", + serde_json::json!({"corpus": dimension, "chunks": corpus.len(), "rounds": rounds, + "compressed_records_sha256": format!("{:x}", records_hash.finalize()), + "compressed_bytes": corpus.iter().map(|(_, r, _)| r.compressed.len()).sum::()}) + ); + // Prime SaveDir's region handles and the filesystem cache before measurement. + for (pos, _, _) in &corpus { + black_box( + source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?, + ); + } + for round in 0..rounds { + let started = Instant::now(); + for (pos, _, _) in &corpus { + black_box( + source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?, + ); + } + let load_s = started.elapsed().as_secs_f64(); + let started = Instant::now(); + for (_, record, _) in &corpus { + black_box(record.nbt(Limits::default())?); + } + let nbt_s = started.elapsed().as_secs_f64(); + let started = Instant::now(); + for (_, _, tag) in &corpus { + black_box( + decode_with(tag, assets.registry, &biomes, Some(&tables)).ok_or("decode failed")?, + ); + } + let decode_s = started.elapsed().as_secs_f64(); + println!( + "{}", + serde_json::json!({"round": round, "load_s": load_s, + "inflate_nbt_s": nbt_s, "decode_s": decode_s}) + ); + } + if args.iter().any(|a| a == "--checksum") { + let mut hash = Sha256::new(); + let mut light_loaded = 0; + for (pos, _, _) in &corpus { + let chunk = source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?; + hash.update(pos.x.to_le_bytes()); + hash.update(pos.z.to_le_bytes()); + light_loaded += usize::from(chunk.light_loaded); + for section in &chunk.sections { + for i in 0..4096 { + hash.update(section.get(i).to_le_bytes()); + hash.update([section.light(i)]); + } + for i in 0..64 { + hash.update(section.biomes.get(i).to_le_bytes()); + } + } + } + println!( + "{}", + serde_json::json!({"blocks_biomes_light_sha256": format!("{:x}", hash.finalize()), + "light_loaded": light_loaded}) + ); + } + Ok(()) +} diff --git a/crates/horizon-world/examples/chunkgen_bench.rs b/crates/horizon-world/examples/chunkgen_bench.rs index 4992515c5..23360b637 100644 --- a/crates/horizon-world/examples/chunkgen_bench.rs +++ b/crates/horizon-world/examples/chunkgen_bench.rs @@ -3,6 +3,7 @@ //! chunkgen_bench [--seed S] [--size N] [--threads T] //! [--center CX CZ] [--verify ] [--no-decorate] //! [--dimension overworld|the_nether|the_end] +//! [--warmup] [--json] [--no-map] use horizon_core::position::ChunkPos; use horizon_world::{ DATA_VERSION, @@ -275,6 +276,7 @@ fn main() -> Result<(), Error> { let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0)); let mut parity = None; let mut decorate = true; + let (mut warmup, mut json, mut map) = (false, false, true); let mut dimension = String::from("minecraft:overworld"); let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None; while let Some(arg) = args.next() { @@ -286,6 +288,9 @@ fn main() -> Result<(), Error> { "--center" => center = (next().parse()?, next().parse()?), "--verify" => parity = Some(PathBuf::from(next())), "--no-decorate" => decorate = false, + "--warmup" => warmup = true, + "--json" => json = true, + "--no-map" => map = false, "--dimension" => { let d = next(); dimension = if d.contains(':') { @@ -326,6 +331,16 @@ fn main() -> Result<(), Error> { dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?; return Ok(()); } + if warmup { + let mut worker = generator.worker(); + for z in -4..=4 { + for x in -4..=4 { + std::hint::black_box( + worker.generate_proto(ChunkPos::new(center.0 + 64 + x, center.1 + 64 + z))?, + ); + } + } + } let (x0, z0) = (center.0 - size / 2, center.1 - size / 2); let count = (size * size) as usize; let next = AtomicUsize::new(0); @@ -353,6 +368,7 @@ fn main() -> Result<(), Error> { handles.into_iter().try_for_each(|h| h.join().unwrap()) })?; let elapsed = start.elapsed(); + let cpu_elapsed = cpu_seconds() - cpu; println!( "generated {count} proto chunks with {threads} threads in {elapsed:.2?}: {:.1} chunks/s ({:.1} ms/chunk/thread)", count as f64 / elapsed.as_secs_f64(), @@ -360,7 +376,7 @@ fn main() -> Result<(), Error> { ); println!( " cpu time {:.1} ms/chunk", - (cpu_seconds() - cpu) * 1000. / count as f64 + cpu_elapsed * 1000. / count as f64 ); let timings = timings.into_inner().unwrap(); let per_chunk = |f: fn(&StageTimings) -> std::time::Duration| { @@ -379,6 +395,16 @@ fn main() -> Result<(), Error> { per_chunk(|t| t.surface), per_chunk(|t| t.carvers) ); + if json { + println!( + "BENCH {}", + serde_json::json!({"phase": "proto", "chunks": count, + "threads": threads, "wall_s": elapsed.as_secs_f64(), "cpu_s": cpu_elapsed, + "biomes_ms_chunk": per_chunk(|t| t.biomes), "noise_ms_chunk": per_chunk(|t| t.noise), + "structures_ms_chunk": per_chunk(|t| t.structures), + "surface_ms_chunk": per_chunk(|t| t.surface), "carvers_ms_chunk": per_chunk(|t| t.carvers)}) + ); + } let mut chunks: Vec> = slots .into_iter() .map(|slot| slot.into_inner().unwrap()) @@ -441,6 +467,13 @@ fn main() -> Result<(), Error> { } } let elapsed = start.elapsed(); + if json { + println!( + "BENCH {}", + serde_json::json!({"phase": "decorate", "chunks": decorated, + "wall_s": elapsed.as_secs_f64()}) + ); + } let totals = totals.into_inner().unwrap(); println!( "decorated {decorated} chunks in {elapsed:.2?}: {:.1} chunks/s; feature roots placed {}, unsupported {}, failed {}", @@ -492,6 +525,9 @@ fn main() -> Result<(), Error> { } } } + if !map { + return Ok(()); + } let mut legend = BTreeMap::>::new(); let step = (size * 16 / 96).max(1); for bz in (0..size * 16).step_by(step as usize) { diff --git a/docs/chunk-performance-campaign.md b/docs/chunk-performance-campaign.md new file mode 100644 index 000000000..99645041e --- /dev/null +++ b/docs/chunk-performance-campaign.md @@ -0,0 +1,100 @@ +# Chunk generation and loading performance campaign + +Profiling baseline: `41055168afcd8687c7efe525545de896f17f4478` (2026-10-22). No production optimization is included in this profiling step. Measurements identify work to investigate; they do not establish a candidate speedup or complete Minecraft world parity. + +## Reproduction and artifacts + +Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM, Linux 7.2.11-zen1-1-zen x86_64; Rust/Cargo 1.99.0, OpenJDK 25.0.4.1. CPU boost remained enabled, governor `powersave`; normal desktop background activity was not isolated. Builds, timed workloads and sampling runs were sequential. Release uses `opt-level=3`, thin LTO, one codegen unit; client benchmarks disable audio/controllers and need no window/GPU. Do not compare these numbers directly with earlier `fast` profile reports. + +Private/generated evidence is outside Git at `/srv/bob-data/horizon-chunk-campaign-41055168/`: `baseline-raw.json`, `baseline-summary.json`, `run_baseline.py`, individual logs, preserved executables in `baseline/`, `binary-sha256.txt`, `fixture-sha256.txt`, the `*-profile.er` sampling experiments, and `*-functions.txt` tables. The matrix binaries are preserved separately from subsequent `*-profile` binaries. The latter add a structure timing field or optional worker execution for profiling; production sources are identical. Prepared resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Pinned jars and source artifacts: `/srv/bob-data/horizon/.local/minecraft/26.3`. + +```sh +CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-target cargo build --locked --release -p horizon-world --example chunkgen_bench -p horizon-client --no-default-features --example chunk_bench --example streaming_bench --example save_bench --example load_bench +``` + +`chunkgen_bench` now accepts `--warmup --json --no-map`. Warmup generates/discards an offset 9×9 region at center+(64,64), with the same seeded generator and a separate worker, before creating fresh measured workers. This removes lazy ring initialization from the steady workload without generating target chunks. Resource loading, generator construction, warmup, diagnostic output and map rendering remain outside the measured generation brackets. `BENCH` JSON reports exact elapsed seconds, process CPU accounting and cumulative stage wall brackets. Worker stage brackets are not exclusive CPU shares; elapsed/count has no thread multiplier. Non-warmed runs should be measured separately when changing startup behavior. + +`load_bench RESOURCES DIMENSION_DIR --rounds 5 --limit 256 --checksum` is read-only. It selects full chunks in sorted region/coordinate order, primes region handles and filesystem cache, then separately times `SaveDir::load` (region read, decompression, NBT, resident decode and saved light), decompression/NBT of retained compressed records, and native decode of retained tags. Allocation and destruction are inside each timed loop. Setup and checksums are outside. Stage times come from separate loops and must not be summed as an exact breakdown. It emits compressed-record SHA256 provenance and an optional complete blocks/biomes/light checksum; this checksum does not cover all saved metadata. + +## Baseline observations + +The primary workload uses seed 12345, center (0,0), size 16: 256 proto chunks and 196 interior decorations. One-worker/four-worker results have five processes each; Nether/End have three each. Values are medians. + +| Workload | Proto wall | Decoration wall | Combined ms/input chunk | +| --- | ---: | ---: | ---: | +| Overworld, 1 worker | 2.224094 s | 0.440144 s | 10.407179 | +| Overworld, 4 workers | 0.732982 s | 0.131088 s | 3.375274 | +| Nether, 1 worker | 0.981417 s | 0.084589 s | 4.164085 | +| End, 1 worker | 0.213254 s | 0.015784 s | 0.894681 | + +The one-worker Overworld brackets are approximately noise 4.20, surface 2.55, biomes 0.40 and carvers 0.34 ms/input chunk. A separate sampled size-32 run reports structures 0.395 ms/input chunk; its larger site mix differs from size 16. + +Resident `chunk_bench --seed 12345 --size 4`, three processes: finish 0.4 ms/chunk (rounded display), light median 1.43 ms/column, mesh 109.5 µs/section (each process reports its best of three mesh sweeps), 29.8 KiB resident storage/chunk. Before qualifying a finish/light/mesh change, emit exact timings on both revisions; existing rounded/best-of-three output is exploratory evidence only. + +`streaming_bench --threads 4 --radius 4 --seed 12345 --fly 4 --seconds 3 --hz 120`, three processes: fill median 1.21 s, 81 chunks generated and 504 sections meshed; median reported update p99 0.041 ms. Flight generates 121 chunks, with median update p99 0.207 ms and no sampled frame with an unlit column within two chunks of the player. This short fixed-duration flight is a responsiveness/throughput check, not a complete long-travel stress test. + +Saved loads use 256 full chunks, three independent processes, five measured rounds/process; table entries are the median of process medians for the whole 256-chunk batch. + +| Corpus | Complete load | Inflate + NBT | Native decode | +| --- | ---: | ---: | ---: | +| Normal vanilla 26.3, seed 12345 | 55.740 ms | 22.068 ms | 27.211 ms | +| Flat vanilla 26.3 locator fixture | 12.733 ms | 4.505 ms | 4.884 ms | + +The normal fixture was generated by the pinned local vanilla server, `level-type=minecraft:normal`, seed 12345, forced block bounds -128,-128 through 127,127, followed by `save-all flush` and clean stop. It contains 400 full chunks; the sorted limit selects 256. Files remain at `vanilla-normal/world/dimensions/minecraft/overworld` under the artifact root. Flat source is `/srv/bob-data/horizon/.local/locator-bar-parity/generate/world/dimensions/minecraft/overworld`. Normal compressed-record SHA256: `ff9bf9e822e334e117e3d6ba5c26a88b7698456ec6d83bdbe4355ad0af1d6f55`; blocks/biomes/light: `661dd26eed78b051afeca11d8ba69222162b5da72e5d1572a12ce2a3b3a4f764`. All three processes agree, and all 256 selected chunks have saved light. Flat checksums are in the raw logs. These are warm storage measurements; cold physical I/O and a remote multiplayer chunk stream are not measured. + +`save_bench` also read the 400 normal chunks and checked written compressed records byte-for-byte: median encode 139 ms, compression 141 ms, parallel SaveDir encode/compress/write 54 ms, five rounds. This checks existing save output consistency, not vanilla read/write parity. + +## CPU samples and ranked investigations + +`perf`, Valgrind and samply are unavailable; GNU gprofng 2.47 is installed. Collection uses `gprofng collect app -p hi -o OUTPUT.er BINARY ARGS`, nominally 997 µs samples. On this machine the collector warns that the initial thread's timer is cleared (`997 -> 0`). Initial-thread samples are therefore unusable. The measured terrain worker (thread 4) records 9.204 sampled CPU seconds against 9.22 process CPU seconds in its generation bracket; decoration worker threads record 3.098 seconds against 3.126 wall seconds. Their worker-only tables are retained as `terrain-worker-functions.txt` and `decoration-worker-functions.txt`. Startup/main-thread percentages must not be inferred from these samples. Streaming worker samples independently reproduce the same generation hotspots. + +The initial loader experiment captured only 0.108 sampled seconds against 10.899 process CPU seconds and is rejected. Repeating the identical code with optional `load_bench --profile-worker --rounds 100` captures 11.323 sampled seconds against 11.347 process CPU seconds; its table is `load-worker-profile-functions.txt`. In this mixed complete-load/NBT/native-decode workload, `PalettedContainer::from_packed` is 16.12% exclusive / 16.62% inclusive, zlib `inflate_fast_help_avx2` 15.71% exclusive, saved `load_light` 5.80% exclusive / 7.38% inclusive, and NBT `Reader::payload` 4.08% exclusive / 15.06% inclusive. Native `decode_column` is 46.97% inclusive. Formatting (`format_inner`) is 6.52% inclusive, including property-map Debug formatting at 4.79%; these nested shares cannot be added. These are shares of all three benchmark loops, not just the complete-load loop. Palette reconstruction/validation is the strongest loading lead; replacing the formatted per-chunk state-cache key is a smaller plausible lead requiring the full-load 5% gate. + +For the size-32 Overworld terrain worker, ranked opportunities outside the excluded PRs are: + +1. Aquifer `compute_substance`: 13.00% exclusive / 15.83% inclusive CPU. Investigate repeated nearest-cell/grid work while retaining exact distance ties, arithmetic, random draws and fluid scheduling. +2. Material `CompiledRule::apply`: 8.52% exclusive / 14.58% inclusive. Check the already-merged surface work before changing anything; inspect fresh evidence for remaining dispatch/data access, preserving condition order and random consumption. +3. `BlockSection::set` 6.09% and `get` 2.79%; decoration additionally spends 9.95% in `get`. Investigate construction/access patterns rather than changing vanilla palette semantics. Shared storage changes need broad callers and palette-width boundary validation. +4. Beardifier `sample_unchecked`: 4.78% exclusive. Recent bulk-density work is already in baseline; only a distinct measured bottleneck should proceed. +5. Decoration sculk `spread_all`: 8.82% exclusive / 22.85% inclusive of decoration-worker CPU at this larger site. Strongly site-dependent; require a matched sculk corpus before claiming a whole-workload win. + +Open/overlapping work excluded from optimization: #1208 Perlin floor/int conversion and float gradients; #1206 Perlin volume/climate lookup; #1207 feature-region grid, ore column/visited handling, lazy biome temperature; #1201 player proximity/ticket/requeue grids; #1192 worker priority; #1191 content/assets loading. Existing merged sampler reuse, neighbor generation, carver cache, surface, packed lighting and bulk density changes are part of this baseline. These exclusions cover the semantic mechanism, not merely the file paths. + +## Candidate acceptance protocol + +For each independent candidate, preserve identical benchmark sources, resource/corpus hashes, build flags and baseline/candidate executables. Do not compare against an open PR's branch. Run no builds, parity jobs or profilers concurrently with timed qualification. Use one discarded baseline/candidate process pair, then at least five measured pairs, alternating A/B and B/A order. Keep every observation; if external contention invalidates a batch, retain it and restart the entire batch with an explanation. + +Primary generation command: `chunkgen_bench RESOURCES --seed 12345 --size 16 --threads 1 --warmup --json --no-map`, repeated at four workers. Add seed -1 at center (32,-32), Nether and End, with five pairs for any affected claim. Report proto, decoration and complete proto+decoration wall time; input and decorated chunk counts must match. Retain a non-warmed check for startup regressions and streaming fill/flight for player-visible effects. + +Primary loading command: `load_bench RESOURCES NORMAL_DIMENSION --rounds 5 --limit 256 --checksum`, repeated with the flat fixture. Each process's median complete `load_s` is one observation; internal rounds are not independent processes. Report native decode and inflate/NBT alongside complete load. Use the same command without profiler-worker mode on both revisions for qualification. + +Open a PR only after the affected complete workload improves by at least 5% in the paired repeated measurements, the improvement is stable across the measured pairs, and correctness gates pass. Report median reduction and range of paired reductions; add pairs if noise makes the 5% threshold ambiguous. A 5% isolated-stage win without a 5% complete affected-workload win does not qualify. Check related workloads for material regression. Explain corpus-specific results instead of claiming universal speedups. + +Correctness gates must include exact baseline/candidate generated blocks, quart biomes, heightmaps, postprocessing, structures, block entities and metadata for affected cases, preserving RNG and iteration behavior, plus the pinned vanilla oracle. Use existing `tools/test_chunk_generation_parity.py` (full world stage comparisons), relevant noise/density/aquifer/material/feature/palette harnesses, and `tools/test_light_parity.py` if lighting changes. Cover negative/far coordinates, several seeds, all affected dimensions and both worker counts. `tools/parity.py --repeat 3 ...` checks repeated oracle/probe agreement; reused Java oracle output is suitable for Rust-only comparisons, with a fresh relevant oracle run before final qualification. + +Loading changes additionally require existing save unit tests and comprehensive baseline/candidate semantic output checks, including heightmaps, block entities, ticks, structures and preserved unknown NBT. The benchmark's block/biome/light checksum is only one gate. Use `tools/test_save_roundtrip_parity.py` for the full vanilla → Horizon → vanilla path when relevant. Prepared Java 25/pinned jars/resources make these checks feasible here; full roundtrip requires the repository's virtual-display/runtime setup and has not been run in this profiling step. No complete world-parity pass is claimed by this report. Run `python3 tools/pr_ready.py --base origin/main` and repository-required checks before any PR. + +## Agent 2: saved palette validation + +Candidate: list palettes in `PalettedContainer::from_packed` keep the saved words directly, so avoid allocating/filling the discarded unpacked-index vector. Reuse index validation, scanning words and their occupied slots in entry order; a palette filling the bit capacity cannot contain an invalid index. Global reencoding remains unchanged. The first invalid index, exact storage-length errors, unused high padding, palette order and resident words are preserved. Pinned 26.3 `PalettedContainer.unpack` bytecode was inspected first: matching list configurations retain `SimpleBitStorage` directly; global configurations reencode. No palette-related open PR overlap was found on 2026-10-22. + +Evidence: `/srv/bob-data/horizon-chunk-campaign-41055168/palette/`, `palette-pairs.py`, `palette-pilot.log`, `palette-qualification.log`, `palette-candidate.patch`, `palette-java-bytecode.txt`, and `palette-*.log`. Binary hashes and commands are recorded in `palette/binaries.json` and `*-raw.json`. The preserved baseline `load_bench-profile` is used without worker/profiler flags because its source exactly matches the candidate benchmark source, including the optional worker branch. Identical release flags, resources and compressed records were used. No builds, tests or profilers overlapped qualification. + +Three pilot pairs showed 9.77–10.28% complete normal-load reductions after a discarded pair. Qualification used five alternating process pairs per corpus, each after a discarded pair, with five measured rounds per process. Values below are medians of process medians for each 256-chunk batch; reductions are medians/ranges of the paired reductions. + +| Corpus / workload | Baseline | Candidate | Paired reduction (range) | +| --- | ---: | ---: | ---: | +| Normal complete load | 55.459 ms | 49.770 ms | 10.257% (9.656–10.573%) | +| Normal native decode | 26.263 ms | 19.902 ms | 24.188% (22.323–25.987%) | +| Normal inflate + NBT | 22.260 ms | 22.086 ms | 0.782% (-1.174–1.680%) | +| Flat complete load | 12.663 ms | 12.027 ms | 5.023% (2.609–5.617%) | +| Flat native decode | 5.170 ms | 4.220 ms | 13.908% (5.850–28.399%) | +| Flat inflate + NBT | 4.537 ms | 4.548 ms | -0.159% (-1.852–0.563%) | + +Normal clears the complete-workload 5% gate in every measured pair. Flat shows no observed regression, but its variation does not support a stable at-least-5% claim. This is a warm saved-load improvement on these fixtures, not a generation or cold-I/O claim. + +Correctness: all timed baseline/candidate compressed-record and block/biome/light hashes match. Core palette tests pass (7 passed; 2 existing ignored). A differential reference test covers all saved widths through 13, single/list/global modes, duplicate values, full-capacity palettes, absent/wrong storage, dirty word/final padding, and first-invalid-index errors; successful cases compare strategy, bits, palette and words exactly. A fresh pinned Java palette oracle passes 266 scenarios and 861,864 edits with identical hashes. Existing `save::tests` pass (19/19), including malformed packed palettes, stored light, block-entity roundtrips, file upgrades and level-file roundtrip. + +The temporary `load_snapshot.rs` harness and true baseline/candidate binaries are archived under `palette/`; the harness was removed from the working tree. It hashes resident palette/word representations and light values, canonical complete reencoded NBT (including heightmaps/block entities), saved root NBT/block-entity sources/order/ticks, and loaded flags, names, postprocessing, entities and structure references. Every full chunk was checked: 400 normal and 289 flat, plus a synthetic nested unknown NBT key and nonempty block/fluid ticks for each corpus. All 691 per-case baseline/candidate outputs match byte-for-byte. `palette/correctness.json` records hashes; `palette/sources.json` authenticates both core sources and the harness. Exact candidate source was restored after the baseline comparison. + +Both baseline and candidate also ran `save_parity` against the pinned vanilla-generated worlds: 324 interior normal chunks have zero block, biome, heightmap or other metadata differences, with the same preexisting 7/63,700,992 recomputed light-value differences in both revisions. All checks on 225 interior flat chunks are identical to vanilla, including all 44,236,800 light values. This establishes no added discrepancy in these comparisons; it is not a clean normal-world lighting parity pass. The full server/client `test_save_roundtrip_parity.py` simulation was not run; the candidate changes only loading/validation, and the read-only full-output comparison covers unchanged save output. No generation parity claim or PR is included in this agent's result. From 5d82b4c999d182db825741b2998b26d7bac90167 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 14:48:08 +0100 Subject: [PATCH 21/59] perf: load list palettes without unpacking discarded indices --- crates/horizon-core/src/paletted.rs | 150 +++++++++++++++++++++++++--- 1 file changed, 134 insertions(+), 16 deletions(-) diff --git a/crates/horizon-core/src/paletted.rs b/crates/horizon-core/src/paletted.rs index 3d56bb987..0730cf5e4 100644 --- a/crates/horizon-core/src/paletted.rs +++ b/crates/horizon-core/src/paletted.rs @@ -577,14 +577,21 @@ impl PalettedContainer { if list.len() == 1 << self.bits { return Ok(()); } - for i in 0..self.strategy.entries() { - let index = read(&self.words, self.bits, i); - if index as usize >= list.len() { - return Err(PaletteError::BadIndex { - index, - palette: list.len(), - }); + let per = 64 / usize::from(self.bits); + let mut remaining = self.strategy.entries(); + let mask = mask(self.bits); + for &word in &self.words { + let count = remaining.min(per); + for slot in 0..count { + let index = ((word >> (slot * usize::from(self.bits))) & mask) as u32; + if index as usize >= list.len() { + return Err(PaletteError::BadIndex { + index, + palette: list.len(), + }); + } } + remaining -= count; } Ok(()) } @@ -644,6 +651,18 @@ impl PalettedContainer { actual: data.len(), }); } + if let Config::List(bits) = config { + // List palettes already use the saved indices as resident storage. + // Validate them without allocating an unpacked copy that is unused. + let container = Self { + strategy, + bits, + words: data.to_vec(), + palette: Palette::List(palette), + }; + container.check_indices()?; + return Ok(container); + } let mut ids = Vec::with_capacity(entries); for i in 0..entries { let index = read(data, disc_bits, i); @@ -655,15 +674,7 @@ impl PalettedContainer { } ids.push(index); } - Ok(match config { - Config::List(bits) => Self { - strategy, - bits, - words: data.to_vec(), - palette: Palette::List(palette), - }, - _ => Self::build(strategy, palette, &ids), - }) + Ok(Self::build(strategy, palette, &ids)) } /// Whether any palette entry satisfies `predicate` (`maybeHas`): entries /// no longer used by any position still count. @@ -796,6 +807,113 @@ mod tests { assert!(PalettedContainer::from_wire(BLOCKS, 0, vec![9], vec![]).is_ok()); } #[test] + fn saved_validation_matches_entrywise_reference() { + // Keep the previous loader as an independent entry-at-a-time reference: + // errors, resident palette order and unused storage bits must all agree. + fn reference( + strategy: Strategy, + palette: Vec, + data: Option<&[u64]>, + ) -> Result { + if palette.is_empty() { + return Err(PaletteError::BadPalette { len: 0 }); + } + let config = strategy.config(ceil_log2(palette.len())); + let entries = strategy.entries(); + let bits = match config { + Config::Single => return Ok(PalettedContainer::new(strategy, palette[0])), + Config::List(bits) => bits, + Config::Global => ceil_log2(palette.len()), + }; + let expected = storage_len(bits, entries); + let data = data.ok_or(PaletteError::BadStorage { + expected, + actual: 0, + })?; + if data.len() != expected { + return Err(PaletteError::BadStorage { + expected, + actual: data.len(), + }); + } + let mut ids = Vec::with_capacity(entries); + for i in 0..entries { + let index = read(data, bits, i); + if index as usize >= palette.len() { + return Err(PaletteError::BadIndex { + index, + palette: palette.len(), + }); + } + ids.push(index); + } + Ok(match config { + Config::List(bits) => PalettedContainer { + strategy, + bits, + palette: Palette::List(palette), + words: data.to_vec(), + }, + _ => PalettedContainer::build(strategy, palette, &ids), + }) + } + fn compare(strategy: Strategy, palette: &[u32], data: Option<&[u64]>) { + let expected = reference(strategy, palette.to_vec(), data); + let actual = PalettedContainer::from_packed(strategy, palette.to_vec(), data); + match (actual, expected) { + (Ok(a), Ok(b)) => { + assert_eq!(a.strategy, b.strategy); + assert_eq!(a.bits, b.bits); + assert_eq!(a.palette, b.palette); + assert_eq!(a.words, b.words); + } + (Err(a), Err(b)) => assert_eq!(a, b), + (a, b) => panic!("loader disagreement: {a:?} vs {b:?}"), + } + } + for strategy in [BLOCKS, BIOMES] { + for len in [ + 0, 1, 2, 3, 4, 5, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 127, 128, 129, 255, + 256, 257, 511, 512, 513, 1023, 1024, 1025, 2047, 2048, 2049, 4096, 4097, + ] { + let palette: Vec = (0..len).map(|i| (i as u32 * 7) % 127).collect(); + compare(strategy, &palette, None); + compare(strategy, &palette, Some(&[])); + if len <= 1 { + compare(strategy, &palette, Some(&[u64::MAX])); + continue; + } + let bits = match strategy.config(ceil_log2(len)) { + Config::List(bits) => bits, + _ => ceil_log2(len), + }; + let entries = strategy.entries(); + let mut words = pack_words(bits, entries, (0..entries).map(|i| (i % len) as u32)); + compare(strategy, &palette, Some(&words)); + compare(strategy, &palette, Some(&words[..words.len() - 1])); + // Nonzero padding in every word and in the final partial word + // is legal and must be preserved by resident list palettes. + let per = 64 / usize::from(bits); + for (word, positions) in words.iter_mut().zip((0..entries).step_by(per)) { + let used = (entries - positions).min(per) * usize::from(bits); + if used < 64 { + *word |= u64::MAX << used; + } + } + compare(strategy, &palette, Some(&words)); + if len < 1usize << bits { + for i in [0, per - 1, per, entries / 2, entries - 1] { + let mut invalid = words.clone(); + write(&mut invalid, bits, i, len as u32); + // A second invalid entry verifies first-error ordering. + write(&mut invalid, bits, entries - 1, mask(bits) as u32); + compare(strategy, &palette, Some(&invalid)); + } + } + } + } + } + #[test] fn division_magic_is_exact() { for bits in 1..=32u8 { let per = 64 / usize::from(bits); From 753c071c3776229928508b5d7d6451644f4c8ec1 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:09:08 +0100 Subject: [PATCH 22/59] docs: record early-stopped chunk optimization attempts --- docs/chunk-performance-campaign.md | 42 ++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/docs/chunk-performance-campaign.md b/docs/chunk-performance-campaign.md index 99645041e..5c9d15001 100644 --- a/docs/chunk-performance-campaign.md +++ b/docs/chunk-performance-campaign.md @@ -98,3 +98,45 @@ Correctness: all timed baseline/candidate compressed-record and block/biome/ligh The temporary `load_snapshot.rs` harness and true baseline/candidate binaries are archived under `palette/`; the harness was removed from the working tree. It hashes resident palette/word representations and light values, canonical complete reencoded NBT (including heightmaps/block entities), saved root NBT/block-entity sources/order/ticks, and loaded flags, names, postprocessing, entities and structure references. Every full chunk was checked: 400 normal and 289 flat, plus a synthetic nested unknown NBT key and nonempty block/fluid ticks for each corpus. All 691 per-case baseline/candidate outputs match byte-for-byte. `palette/correctness.json` records hashes; `palette/sources.json` authenticates both core sources and the harness. Exact candidate source was restored after the baseline comparison. Both baseline and candidate also ran `save_parity` against the pinned vanilla-generated worlds: 324 interior normal chunks have zero block, biome, heightmap or other metadata differences, with the same preexisting 7/63,700,992 recomputed light-value differences in both revisions. All checks on 225 interior flat chunks are identical to vanilla, including all 44,236,800 light values. This establishes no added discrepancy in these comparisons; it is not a clean normal-world lighting parity pass. The full server/client `test_save_roundtrip_parity.py` simulation was not run; the candidate changes only loading/validation, and the read-only full-output comparison covers unchanged save output. No generation parity claim or PR is included in this agent's result. + + +## Round 3: aquifer neighborhood pilot — rejected + +Inspected the pinned server 26.3 `Aquifer.NoiseBasedAquifer.computeSubstance` bytecode and current open PRs; no aquifer optimization overlap was found. Tested a single-current-grid cache of the 12 decoded candidate positions/indices, populated in vanilla cell order only after successful checked accesses, plus explicit four-slot nearest insertion preserving later-cell distance ties. The candidate touched only `worldgen/aquifer/noise_based.rs`; no noise evaluation or terrain traversal was changed. + +Evidence is retained in `/srv/bob-data/horizon-chunk-campaign-41055168/aquifer/`: baseline source, candidate patch, preserved candidate executable, binary hashes, build log, pilot script, all process logs, `pilot-raw.json` and `summary.json`. Pinned Java bytecode is in `aquifer-java-bytecode.txt` at the parent artifact root. The benchmark source SHA256 is `f404feb7ec526f12735d11b15af36254fd585f39b975cdbdc71905d87f10f8cc`, identical to the preserved `chunkgen_bench-profile` baseline source. Both executables use the established release flags and resources. No builds, tests or profilers ran during timing. + +One discarded process pair followed by three alternating pairs used the primary seed-12345, center-(0,0), size-16, one-worker warmed command. Every process generated 256 proto chunks and decorated 196 chunks. Complete proto+decoration paired reductions were **3.864%, 4.326%, 3.828%** (median **3.864%**); baseline/candidate complete-time medians were **2.678451 s / 2.568094 s**. This does not clear the 5% complete-workload gate. The pilot had already completed when the parent requested early cancellation. The production candidate was reverted; no qualification, four-worker/second-site matrix, parity tests, generated snapshots or PR were pursued. No correctness claim is made for the rejected candidate. This result applies to this mechanism and corpus, not an upper bound on all aquifer optimization. + +Next lead: remaining material-rule dispatch/data access (8.52% exclusive terrain-worker CPU), after checking the already-merged surface changes. Preserve rule evaluation order and random consumption; reject early if its complete-workload pilot remains below 5%. + + +## Round 4: remaining material-rule dispatch — early no-go + +Inspected merged #801 (`Specialize constant surface material-rule branches`), `docs/surface-generation-benchmark.md`, the current compiled rule/condition/density implementation, and the pinned 26.3 material resources and Java `ConditionRule`, `SequenceRule`, `OreVeinRule`, and `BlockRule` bytecode. The open-PR list was checked on 2026-10-22; no additional material-rule dispatch PR was found, and the campaign's excluded mechanisms were left untouched. Inspection evidence is retained under `/srv/bob-data/horizon-chunk-campaign-41055168/surface-feasibility/`: `pinned-material-bytecode.txt` and `inspection.json` (source commit, pinned server-game SHA256, and static expanded rule counts). + +The existing implementation already removes constant predicates and singleton/empty sequences after compiling all children, shares eager density roots, and uses unit-step material-volume indexing. The 8.52% exclusive terrain-worker sample share for `CompiledRule::apply` includes ore-vein execution and inlined work, so it cannot be treated as removable dispatch overhead. Vanilla's top-level Overworld sequence includes both ore-vein rules before the surface predicate and underground rules. Condition/block fusion or flattening nested sequences would remove only part of this work; a broad replacement evaluator would be a speculative refactor without evidence for the required complete-workload gain. The raw expanded Overworld resource tree contains 53 sequences, 149 conditions, 110 blocks, two ore-vein rules and two band rules; these static counts precede constant specialization and are not runtime frequencies. + +Decision: **early no-go**, accepted by the parent before implementation. No production source or tests were changed, no build/timing/parity jobs were run, and no candidate or PR was created. This is a feasibility rejection, not a measured performance result or an upper bound on future material optimizations. The rejected aquifer executable in the shared target directory was not used. Earlier campaign evidence and the uncommitted Round 3 report were preserved. + + +## Round 5: section access and construction — early no-go + +Inspected `BlockSection` get/set/construction, `PackedStorage` addressing, the existing ignored section microbenchmark and differential tests, and merged commits `939eabe6`, `56a251eb` and `5c55e7d8`. Checked the open-PR list on 2026-10-22; no section-storage optimization overlap was found. Pinned 26.3 `LevelChunkSection`, `PalettedContainer` and `SimpleBitStorage` bytecode was inspected before considering changes. Evidence is retained in `/srv/bob-data/horizon-chunk-campaign-41055168/section-feasibility/`: `pinned-section-bytecode.txt`, `baseline-access-assembly.txt` and `inspection.json` (source/pinned-jar/baseline hashes and the bounded open-PR catalog). + +The current implementation already reads the old packed index directly, resolves the incoming state with one multiplicative-hash map probe, reuses freed palette slots, and skips repeated storage validation after the section checks. The ignored microbenchmark compares against older pre-optimization implementations; its historical speedups are already in the campaign baseline and cannot qualify a new candidate. Uniform construction still allocates palette/count/map storage, but construction is not identified as a substantial exclusive hotspot in the retained profile. + +The preserved baseline executable confirms runtime division in packed-index addressing; pinned Java uses reciprocal multiplication in `SimpleBitStorage.cellIndex`. This is a possible future storage investigation, but the division is only part of the sampled access cost, alongside palette/word loads, incoming-state lookup and count/free-slot handling. Terrain samples assign 6.09% exclusive CPU to `set` and 2.79% to `get`, while the separate decoration sample assigns 9.95% to `get`; these site-specific shares are not a measured removable fraction or a complete-workload speedup prediction. There is no evidence here that a small addressing or construction change can remove enough complete proto-plus-decoration work to meet the 5% gate. A dense representation or bulk terrain writer would need broader semantic and workload evidence and was not attempted. + +Decision: **early no-go**, accepted by the parent before implementation. No production source or tests were changed, no build/timing/parity jobs were run, and no candidate or PR was created. No new correctness or performance result is claimed. The rejected aquifer executable in the shared target directory was not used; assembly inspection used the preserved genuine baseline. Earlier campaign evidence and uncommitted Round 3/4 reports were preserved. + + +## Round 6: saved block-state cache keys — rejected + +Inspected the loader's formatted per-chunk state-cache keys, `BlockState::from_nbt`, registry lookup/default fallback, and pinned 26.3 `StateHolder.codec`/`BlockState` bytecode. Checked the open-PR list on 2026-10-22; no saved-state-cache optimization overlap was found. The candidate derived `Hash` for `BlockState` and replaced the formatted string key with the parsed structural state. Invalid parse results returned air directly; the existing registry/default-property resolution was retained. No palette or lighting code changed. + +Evidence is retained under `/srv/bob-data/horizon-chunk-campaign-41055168/state-key/`: candidate patch and sources, preserved baseline source copies, pinned bytecode, bounded open-PR catalog, build log, paired runner, raw process observations/logs, executable hashes and summary. The baseline was the preserved **accepted palette candidate**, so these results are incremental to commit `5d82b4c9`, with none of its earlier gain counted again. Both binaries used identical `load_bench` source (SHA256 `b6f5042731d7c9d5622758043f7c1e125a3f7d098c57ee0501012474c2df7325`), release/thin-LTO/one-codegen-unit flags, resources and normal corpus. No builds, tests or profilers overlapped timing. + +One discarded process pair followed by two alternating measured pairs used `--rounds 5 --limit 256 --checksum`. Complete normal-load paired reductions were **3.257% and 2.412%** (median **2.835%**); baseline/candidate process-median medians were **49.725 / 48.316 ms** per 256 chunks. Native decode improved **5.917%** (20.266 / 19.067 ms); inflate/NBT varied by **-0.844%**. Compressed-record and block/biome/light checksums matched in every process. Those checksums are limited benchmark checks, not comprehensive semantic or vanilla parity evidence. + +Decision: **early no-go** at the incremental 5% complete-load gate. Both production files were restored exactly to their pre-candidate contents; only this report remains. No flat/long qualification, comprehensive snapshot comparison, fresh parity suite, tests, commit or PR were pursued for this rejected candidate. The shared Cargo target contains the rejected executable; future work must use the preserved accepted binary or rebuild restored sources. From 399382084a2182fced1fc01792de3a6d2b8c35e3 Mon Sep 17 00:00:00 2001 From: itspotatotime Date: Wed, 21 Oct 2026 17:41:25 +0300 Subject: [PATCH 23/59] fix(client): show server players' and NPCs' skins The tab list resolved skins only for listed players and never handed them to the level's player models, so every player and NPC in a server world kept the default Steve or Alex texture. Resolve every profile's textures each frame and give each player entity its skin, including entities that are never in the tab list. Player heads read the minecraft:profile component with the insecure lookup vanilla uses, so unsigned textures from offline servers draw too. Co-Authored-By: cairn-code (DeepSeek V4.1 Flash) --- crates/horizon-client/src/game.rs | 7 +- .../horizon-client/src/game/armor_stands.rs | 8 +- crates/horizon-client/src/game/item_draw.rs | 19 +++- crates/horizon-client/src/game/remote.rs | 103 +++++++++++++----- crates/horizon-client/src/game/scoreboard.rs | 5 + crates/horizon-client/src/mobs.rs | 4 + crates/horizon-client/src/mobs/render.rs | 5 +- crates/horizon-client/src/skins.rs | 33 ++++++ 8 files changed, 151 insertions(+), 33 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..8e0cbd373 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -214,6 +214,7 @@ use horizon_world::{ registry::BlockStateId, }; use std::{ + cell::RefCell, collections::{HashMap, HashSet}, path::PathBuf, sync::{ @@ -1387,7 +1388,7 @@ struct Game<'a> { map_patches: Vec, /// Player skin downloads, and which skin each atlas skin slot holds /// (least recently shown first). - skin_downloads: horizon_client::skins::Downloader, + skin_downloads: RefCell, skin_slots: Vec<(String, usize)>, cart_models: minecarts::CartModels, /// The boat the player rides. @@ -11627,11 +11628,11 @@ impl<'a> Game<'a> { breath_clouds: Vec::new(), dragon_model: prepared.dragon_model, map_patches: Vec::new(), - skin_downloads: horizon_client::skins::Downloader::new( + skin_downloads: RefCell::new(horizon_client::skins::Downloader::new( std::env::current_dir() .unwrap_or_default() .join("assets/skins"), - ), + )), skin_slots: Vec::new(), cart_models: prepared.cart_models, riding: None, diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs index 9f174c5ef..aa55d83df 100644 --- a/crates/horizon-client/src/game/armor_stands.rs +++ b/crates/horizon-client/src/game/armor_stands.rs @@ -700,9 +700,15 @@ impl Game<'_> { self.dim == super::Dim::Nether, )), }; + let profile = stack + .extra + .as_deref() + .and_then(|d| d.other.iter().find(|(k, _)| k == "minecraft:profile")) + .map(|(_, t)| horizon_client::scoreboard::tag_to_json(t)) + .unwrap_or(serde_json::Value::Null); self.pack.item_renderer.submit_special( &special, - &serde_json::Value::Null, + &profile, false, pose, &self.gui.atlas.sprites, diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index 8e7176a70..1d79f077d 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -9,12 +9,13 @@ use horizon_assets::item_model::{ }; use horizon_client::{ block_entity_render::{diffuse_lights, vertex_light}, - hud::HudBatch, + hud::{HudBatch, Rect}, item_render::{self, ItemRenderState, SpecialHost, WorldSink}, items::ItemStack, mesher::Vertex, }; use serde_json::Value; +use std::{cell::RefCell, collections::HashMap}; /// The game's answers to what the resolver cannot read from the stack. pub(super) struct Env<'a, 'g> { @@ -126,6 +127,8 @@ pub(super) fn local_time(pattern: &str) -> String { /// Banner and shield pattern textures from the banner pattern registry. pub(super) struct Host<'a> { banners: &'a horizon_client::banner::Banners, + sprites: &'a HashMap, + skins: &'a RefCell, } impl SpecialHost for Host<'_> { fn banner_texture(&self, pattern: &str) -> Option { @@ -138,6 +141,18 @@ impl SpecialHost for Host<'_> { .pattern(pattern) .map(|_| self.banners.shield_texture(pattern)) } + fn player_skin(&self, profile: &Value) -> Option { + // SkullBlockRenderer.getPlayerSkin: SkinManager.getInsecureSkinInformation + // accepts a texture property without a signature, unlike the tab list. + let url = horizon_client::skins::profile_skin_url(profile)?; + let location = + horizon_client::skins::skin_location(&horizon_client::skins::texture_hash(&url)?); + let _ = self + .skins + .borrow_mut() + .state(horizon_client::skins::Kind::Skin, &url); + self.sprites.contains_key(&location).then_some(location) + } } /// `ItemOwner` of an entity holding or showing an item. @@ -177,6 +192,8 @@ impl Game<'_> { pub(super) fn item_host(&self) -> Host<'_> { Host { banners: &self.res.stations().banners, + sprites: &self.gui.atlas.sprites, + skins: &self.skin_downloads, } } /// The client level as item models read it. diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..5226377be 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -140,6 +140,8 @@ pub(super) struct Remote { tab_players: HashMap, /// Each listed profile's unpacked `textures` property. skin_textures: HashMap, + /// The skin texture each profile's players show, once its download is ready. + skins: HashMap, listed: std::collections::HashSet, /// `ClientboundLoginPacket.onlineMode`: the player list shows heads. online_mode: bool, @@ -355,6 +357,7 @@ impl Game<'_> { players: HashMap::new(), tab_players: HashMap::new(), skin_textures: HashMap::new(), + skins: HashMap::new(), listed: Default::default(), online_mode: false, level_players: HashMap::new(), @@ -2459,33 +2462,20 @@ impl Game<'_> { pub(super) fn remote_tab_players( &mut self, ) -> Option<(Vec, bool, Vec)> { - let r = self.remote.as_ref()?; - let mut players: Vec<_> = r - .listed - .iter() - .filter_map(|u| r.tab_players.get(u).cloned()) - .collect(); + self.update_remote_skins(); + let mut players: Vec<_> = { + let r = self.remote.as_ref()?; + r.listed + .iter() + .filter_map(|u| r.tab_players.get(u).cloned()) + .collect() + }; for p in &mut players { - let Some(textures) = r.skin_textures.get(&p.uuid) else { - continue; - }; - // PlayerInfo.createSkinLookup: only the local player's own skin - // may be unsigned. - let downloads = &mut self.skin_downloads; - let skin = horizon_client::skins::lookup(textures, p.uuid != r.profile, |kind, url| { - downloads.state(kind, url) - }); - if let Some(skin) = skin { - p.skin = skin; - } - } - for (location, rgba) in self.skin_downloads.take_ready() { - self.store_skin(location, rgba); - } - for p in &mut players { - if p.skin.starts_with("skins/") && !self.show_skin(&p.skin) { - p.skin = horizon_client::tab_list::default_skin(p.uuid).to_owned(); - } + p.skin = self + .remote + .as_ref() + .and_then(|r| r.skins.get(&p.uuid).cloned()) + .unwrap_or_else(|| horizon_client::tab_list::default_skin(p.uuid).to_owned()); } let r = self.remote.as_ref()?; let upside_down = players @@ -2498,9 +2488,68 @@ impl Game<'_> { .collect(); Some((players, r.online_mode, upside_down)) } + /// `PlayerInfo.getSkin` for every player entity, including NPCs that are + /// never in the tab list: resolve each profile's textures and give the + /// level's player models their skin. + fn update_remote_skins(&mut self) { + let Some(r) = self.remote.as_ref() else { + return; + }; + let local = r.profile; + let entries: Vec<(u128, horizon_client::skins::Textures)> = r + .skin_textures + .iter() + .map(|(uuid, textures)| (*uuid, textures.clone())) + .collect(); + let mut resolved: Vec<(u128, String)> = Vec::new(); + for (uuid, textures) in entries { + // PlayerInfo.createSkinLookup: only the local player's own skin + // may be unsigned. + let skin = { + let mut downloads = self.skin_downloads.borrow_mut(); + horizon_client::skins::lookup(&textures, uuid != local, |kind, url| { + downloads.state(kind, url) + }) + }; + if let Some(skin) = skin { + resolved.push((uuid, skin)); + } + } + resolved.retain(|(_, skin)| !skin.starts_with("skins/") || self.show_skin(skin)); + let Some((level, skins, own)) = self.remote.as_mut().map(|r| { + r.skins = resolved.into_iter().collect(); + ( + r.level_players + .iter() + .map(|(id, uuid)| (*id as u32, *uuid)) + .collect::>(), + r.skins.clone(), + r.skins.get(&r.profile).cloned(), + ) + }) else { + return; + }; + for (id, uuid) in level { + let Some(skin) = skins.get(&uuid) else { + continue; + }; + if let Some(mob) = self + .mobs + .iter_mut() + .find(|m| m.id == id && &*m.kind.id == "minecraft:player") + { + mob.skin = Some(skin.clone()); + } + } + if let Some(skin) = own + && let Some(mob) = self.player_model.as_mut() + { + mob.skin = Some(skin); + } + } /// Puts a downloaded skin in an atlas skin slot: a free one, else the /// least recently shown. - fn store_skin(&mut self, location: String, rgba: Vec) { + pub(super) fn store_skin(&mut self, location: String, rgba: Vec) { use horizon_client::hud::SKIN_SLOTS; let slot = if self.skin_slots.len() < SKIN_SLOTS { self.skin_slots.len() diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs index 99dae39a5..09a21eba0 100644 --- a/crates/horizon-client/src/game/scoreboard.rs +++ b/crates/horizon-client/src/game/scoreboard.rs @@ -599,6 +599,11 @@ impl Game<'_> { /// objective. pub(super) fn draw_tab_list(&mut self, batch: &mut HudBatch) { use horizon_client::tab_list::{self, TabInputs}; + // Player heads and the player list both draw from the same skin slots. + let ready: Vec<_> = self.skin_downloads.borrow_mut().take_ready(); + for (location, rgba) in ready { + self.store_skin(location, rgba); + } let key = self.screen == super::Screen::Playing && self.keys.contains(&winit::keyboard::KeyCode::Tab); let (players, online_mode, upside_down) = match self.remote_tab_players() { diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index e87032f07..3c2b34178 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -846,6 +846,9 @@ pub struct Mob { /// from the game), handed over with the next tick's events or drained /// by the game. pub outbox: Vec, + /// The skin texture of a player mob (`PlayerInfo.getSkin`), which + /// replaces the type's default when its download is ready. + pub skin: Option, } /// Events a mob tick asks the game to act on. #[derive(Clone, Debug)] @@ -1519,6 +1522,7 @@ impl Mob { anim: anim::AnimState::default(), rider: None, outbox: Vec::new(), + skin: None, attrs: Attrs { speed: kind.speed, attack_damage: kind.attack_damage, diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 4248f22c6..b8098a45a 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -104,7 +104,10 @@ pub fn body(m: &Mob) -> (String, String) { } }; if &*m.kind.id == "minecraft:player" { - return ("main".into(), m.kind.texture.to_string()); + return ( + "main".into(), + m.skin.clone().unwrap_or_else(|| m.kind.texture.clone()), + ); } match m.species() { S::Llama | S::TraderLlama => { diff --git a/crates/horizon-client/src/skins.rs b/crates/horizon-client/src/skins.rs index c47c9d47f..9014032c4 100644 --- a/crates/horizon-client/src/skins.rs +++ b/crates/horizon-client/src/skins.rs @@ -112,6 +112,24 @@ pub fn unpack(value: &str, signature: Signature, valid_uris: &[&str]) -> Texture out } +/// The skin URL of a `minecraft:profile` component's property list. Player +/// heads and mannequins read their profile this way, and `SkinManager` lets +/// those textures be unsigned (`getInsecureSkinInformation`). +pub fn profile_skin_url(profile: &serde_json::Value) -> Option { + let value = profile + .get("properties")? + .as_array()? + .iter() + .find_map(|p| { + if p.get("name")?.as_str()? == "textures" { + p.get("value")?.as_str() + } else { + None + } + })?; + unpack(value, Signature::Unsigned, &TEXTURE_URIS).skin +} + /// `MinecraftProfileTexture.getHash`: the base name of the URL's path. pub fn texture_hash(url: &str) -> Option { let rest = url.split_once("://")?.1; @@ -393,6 +411,21 @@ pub fn sha1(data: &[u8]) -> [u8; 20] { #[cfg(test)] mod tests { + #[test] + fn profile_components_supply_unsigned_head_skins() { + let value = "eyJ0ZXh0dXJlcyI6IHsiU0tJTiI6IHsidXJsIjogImh0dHBzOi8vdGV4dHVyZXMubWluZWNyYWZ0Lm5ldC90ZXh0dXJlL2FiYzEyMyJ9fX0="; + let profile = serde_json::json!({"properties": [{"name": "textures", "value": value}]}); + assert_eq!( + super::profile_skin_url(&profile).as_deref(), + Some("https://textures.minecraft.net/texture/abc123") + ); + let other = serde_json::json!({"properties": [{"name": "other", "value": value}]}); + assert_eq!(super::profile_skin_url(&other), None); + let bad = serde_json::json!({"properties": [{"name": "textures", "value": "not base64"}]}); + assert_eq!(super::profile_skin_url(&bad), None); + assert_eq!(super::profile_skin_url(&serde_json::json!({})), None); + } + /// Textures come over plain HTTP too (a local server here; https is the /// same request through rustls), and only 2xx answers count. #[test] From a5e0645610546dfaf9999d0e6df02438346a7aa5 Mon Sep 17 00:00:00 2001 From: itspotatotime Date: Wed, 21 Oct 2026 17:41:34 +0300 Subject: [PATCH 24/59] fix(client): draw armor stand custom names as name tags Holograms are invisible armor stands carrying a CustomName. Armor stands parsed neither CustomName nor CustomNameVisible, and name tags came only from mobs, so a hologram drew nothing. Read both fields from NBT and entity data, keep them across a save, and put armor stands in the name tag pass at their bounding-box height even when their model is skipped. Co-Authored-By: cairn-code (DeepSeek V4.1 Flash) --- crates/horizon-client/src/entities.rs | 6 ++ crates/horizon-client/src/entity_nbt.rs | 51 ++++++++++++++++ crates/horizon-client/src/game/names.rs | 58 +++++++++++++++++++ .../horizon-client/src/game/remote_objects.rs | 8 +++ 4 files changed, 123 insertions(+) diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs index ed8fe4dec..cfbdb0636 100644 --- a/crates/horizon-client/src/entities.rs +++ b/crates/horizon-client/src/entities.rs @@ -583,6 +583,10 @@ pub struct ArmorStand { pub no_base_plate: bool, pub invisible: bool, pub marker: bool, + /// `CustomName`: the text of a hologram. + pub custom_name: Option, + /// `CustomNameVisible`. + pub name_visible: bool, /// Game time of the last hit (the wobble and the second-hit window). pub last_hit: i64, } @@ -603,6 +607,8 @@ impl ArmorStand { no_base_plate: false, invisible: false, marker: false, + custom_name: None, + name_visible: false, last_hit: i64::MIN / 2, } } diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index d9cf20db5..3044e11ff 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -13,6 +13,7 @@ use crate::{ doubles, float, floats, item_from_nbt, item_to_nbt, number, put, read_doubles, text, uuid_from_tag, }, + text::Text, }; use horizon_core::geometry::Vec3; use horizon_world::nbt::{Compound, Tag}; @@ -555,6 +556,14 @@ fn custom_name(tag: &Tag) -> Option { _ => None, } } +/// `CustomName` as text: a string keeps its legacy formatting codes, anything +/// else is a component (`ComponentSerialization`). +pub fn name_text(tag: &Tag) -> Text { + match tag { + Tag::String(s) => Text::legacy(&s.to_string_lossy()), + t => crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t)), + } +} pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) -> Option { let kind = types.get(&self::kind(tag)?)?.clone(); let position = position(tag)?; @@ -1266,6 +1275,21 @@ pub fn armor_stand_to_nbt(a: &ArmorStand, uuid: [i32; 4], raw: Option<&Tag>) -> } else if let Tag::Compound(map) = &mut tag { map.remove(&"Marker".into()); } + if a.name_visible { + put(&mut tag, "CustomNameVisible", Tag::Byte(1)); + } else if let Tag::Compound(map) = &mut tag { + map.remove(&"CustomNameVisible".into()); + } + // A name from the save keeps its own shape unless it changed. + if let Some(name) = &a.custom_name + && !tag.get("CustomName").is_some_and(|t| name_text(t) == *name) + { + put( + &mut tag, + "CustomName", + crate::scoreboard::json_to_tag(&name.component()), + ); + } put(&mut tag, "Health", Tag::Float(a.health.to_bits())); put(&mut tag, "Fire", Tag::Short(a.fire_ticks as i16)); // LivingEntity.addAdditionalSaveData and ArmorStand's own fields. @@ -1294,6 +1318,8 @@ pub fn armor_stand_from_nbt(tag: &Tag, id: u32) -> Option { a.velocity = motion(tag); a.health = float(tag.get("Health")).unwrap_or(20.0) as f32; a.fire_ticks = number(tag.get("Fire")).unwrap_or(0) as i32; + a.custom_name = tag.get("CustomName").map(name_text); + a.name_visible = flag(tag, "CustomNameVisible"); if let Some(eq) = tag.get("equipment") { for (i, slot) in ArmorStand::SLOTS.iter().enumerate() { a.equipment[i] = eq.get(slot).and_then(item_from_nbt); @@ -1574,6 +1600,31 @@ mod tests { assert!(ominous_item_spawner_from_nbt(&raw).is_none()); } + #[test] + fn armor_stand_names_keep_their_formatting_across_a_save() { + let tag = Tag::compound([ + ( + "Pos", + Tag::List(vec![ + Tag::Double(0.0f64.to_bits()), + Tag::Double(64.0f64.to_bits()), + Tag::Double(0.0f64.to_bits()), + ]), + ), + ("CustomName", string("§6Hello")), + ("CustomNameVisible", Tag::Byte(1)), + ]); + let a = armor_stand_from_nbt(&tag, 7).unwrap(); + let name = a.custom_name.as_ref().unwrap(); + assert_eq!(name.plain(), "Hello"); + assert!(name.spans[0].style.color.is_some()); + assert!(a.name_visible); + let saved = armor_stand_to_nbt(&a, [0; 4], Some(&tag)); + let restored = armor_stand_from_nbt(&saved, 7).unwrap(); + assert_eq!(restored.custom_name, a.custom_name); + assert!(restored.name_visible); + } + #[test] fn falling_block_round_trip_keeps_impact_distance_and_settings() { let state = Tag::compound([("Name", string("minecraft:damaged_anvil"))]); diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index 707b9df96..5a1ea9f68 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -171,6 +171,64 @@ impl Game<'_> { discrete, }); } + // Armor stands name themselves: an invisible one with a visible name + // is a hologram (its model is skipped, its name tag is not). + for a in &self.armor_stands { + let Some(name) = &a.custom_name else { + continue; + }; + if !a.name_visible { + continue; + } + let height = match (a.marker, a.small) { + (true, _) => 0.0, + (false, true) => 0.9875, + (false, false) => 1.975, + }; + let distance_sqr = + glam::DVec3::new(a.position.x, a.position.y, a.position.z).distance_squared(camera); + if distance_sqr >= 64.0 * 64.0 { + continue; + } + let team = self.mob_team(a.id); + let invisible = sb::invisible_to(team, viewer, self.spectator(), false); + let view = sb::NameView { + discrete: false, + distance_sqr, + invisible_to_viewer: invisible, + hud_hidden: self.ui.hide_gui, + is_camera: false, + is_vehicle: false, + }; + if !sb::name_shown(team, viewer, view) { + continue; + } + let shown = match team { + Some(t) => t.formatted_name(name.clone()), + None => name.clone(), + }; + let mut lines = Vec::new(); + let mut lift = 0.0; + let holder = self.persist.uuids.get(&a.id).map(|u| uuid_text(*u)); + if distance_sqr < 10.0 * 10.0 + && let Some(score) = holder.and_then(|h| self.below_name_text(&h)) + { + lines.push((score, 0.0)); + lift = f64::from(9.0f32 * 1.15 * 0.025); + } + lines.push((shown, lift)); + let l = self.world.light( + a.position.x.floor() as i32, + (a.position.y + height).floor() as i32, + a.position.z.floor() as i32, + ); + tags.push(NameTag { + at: glam::DVec3::new(a.position.x, a.position.y + height + 0.5, a.position.z), + lines, + light: l, + discrete: false, + }); + } tags } /// `SubmitNodeCollection.submitNameTag`: a discrete name is drawn once, diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs index 12a15bc34..4cf9cb1a8 100644 --- a/crates/horizon-client/src/game/remote_objects.rs +++ b/crates/horizon-client/src/game/remote_objects.rs @@ -123,6 +123,14 @@ impl Game<'_> { } else if let Some(a) = self.armor_stands.iter_mut().find(|a| a.id == id) { match (index, value) { (0, Value::Byte(flags)) => a.invisible = flags & 0x20 != 0, + // Entity.DATA_CUSTOM_NAME and DATA_CUSTOM_NAME_VISIBLE. + (2, Value::OptText(name)) => { + a.custom_name = name.as_ref().map(horizon_client::entity_nbt::name_text); + } + (2, Value::Text(name)) => { + a.custom_name = Some(horizon_client::entity_nbt::name_text(name)); + } + (3, Value::Bool(visible)) => a.name_visible = *visible, (9, Value::Float(health)) => a.health = *health, // ArmorStand.DATA_CLIENT_FLAGS. (15, Value::Byte(flags)) => { From c139387e2aa261afef1c502342cf03e49435e812 Mon Sep 17 00:00:00 2001 From: itspotatotime Date: Wed, 21 Oct 2026 22:20:28 +0300 Subject: [PATCH 25/59] fix(client): read server map art and item profiles A server lobby draws its signs as walls of framed maps and puts player heads on its NPCs. Horizon dropped every map_item_data packet, so framed maps stayed blank, and the item component decoder rejected attack_range (30) and profile (72), which made the whole equipment and container packets that carried them undecodable. Decode both components, carry a profile into the item data the head model reads, and apply server map patches to the map texture. The map pool now holds a wall of maps so the atlas does not re-upload every map every frame. Co-Authored-By: cairn-code (DeepSeek V4.1 Flash) --- crates/horizon-client/src/game/maps.rs | 31 +++++ crates/horizon-client/src/game/remote.rs | 30 +++++ crates/horizon-client/src/hud.rs | 6 +- crates/horizon-protocol/src/item.rs | 134 ++++++++++++++++++++ crates/horizon-protocol/src/packets/play.rs | 85 +++++++++++++ 5 files changed, 284 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/maps.rs b/crates/horizon-client/src/game/maps.rs index 855ef941a..bc2534659 100644 --- a/crates/horizon-client/src/game/maps.rs +++ b/crates/horizon-client/src/game/maps.rs @@ -275,6 +275,37 @@ impl Game<'_> { } self.maps.data.get_mut(&id) } + /// `ClientboundMapItemDataPacket.handle`: the server's colours for a map + /// this client does not own (lobby map art, a framed map on a wall). + pub(super) fn remote_map_item_data( + &mut self, + p: &horizon_protocol::packets::play::MapItemData, + ) { + let dimension = self.dimension_id(); + let map = self + .maps + .data + .entry(p.map_id) + .or_insert_with(|| MapData::fresh(0.0, 0.0, p.scale.max(0) as u8, dimension)); + map.locked = p.locked; + let Some(patch) = &p.patch else { + map.dirty = false; + return; + }; + for x in 0..patch.width { + for y in 0..patch.height { + let Some(&color) = patch.colors.get((x + y * patch.width) as usize) else { + continue; + }; + let (px, py) = (patch.start_x + x, patch.start_y + y); + if (0..128).contains(&px) && (0..128).contains(&py) { + map.update_color(px, py, color); + } + } + } + // The server owns a remote map: only the texture has to change. + map.dirty = false; + } fn next_map_id(&mut self) -> i32 { let last = *self.maps.last_id.get_or_insert_with(|| { horizon_client::save::read_dat(&self.world_root.join("data/minecraft/maps/last_id.dat")) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5226377be..36f4499b5 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -196,6 +196,30 @@ fn face_direction(face: [i32; 3]) -> u8 { } } +/// A `minecraft:profile` component as the item data JSON the model reads. +fn profile_tag(p: &horizon_protocol::item::Profile) -> Tag { + let properties = p + .properties + .iter() + .map(|(name, value, signature)| { + let mut entries: Vec<(&'static str, Tag)> = vec![ + ("name", Tag::String(name.as_str().into())), + ("value", Tag::String(value.as_str().into())), + ]; + if let Some(signature) = signature { + entries.push(("signature", Tag::String(signature.as_str().into()))); + } + Tag::compound(entries) + }) + .collect::>(); + let mut entries: Vec<(&'static str, Tag)> = Vec::new(); + if let Some(name) = &p.name { + entries.push(("name", Tag::String(name.as_str().into()))); + } + entries.push(("properties", Tag::List(properties))); + Tag::compound(entries) +} + /// A protocol number format as the scoreboard's. fn number_format(f: &play::NumberFormat) -> horizon_client::scoreboard::NumberFormat { use horizon_client::scoreboard::{NumberFormat, tag_to_json}; @@ -576,6 +600,11 @@ impl Game<'_> { out.data_mut().stored_enchantments = levels(list); } out.tidy(); + if let Some(Component::Profile(p)) = s.component(component::PROFILE) { + out.data_mut() + .other + .push(("minecraft:profile".into(), profile_tag(p))); + } Some(out) } fn to_network(&self, s: &Option) -> Option { @@ -2317,6 +2346,7 @@ impl Game<'_> { .then(|| Vec3::new(f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5)); } C::ServerData(p) => self.remote_server_data(p.icon.as_deref()), + C::MapItemData(p) => self.remote_map_item_data(&p), // handleTickingState / handleTickingStep: the level's TickRateManager. C::TickingState(p) => { self.clock.set_rate(p.rate); diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 0cc99b07b..6c2b3a006 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -30,8 +30,10 @@ pub struct HudAtlas { } /// Atlas rows reserved for glyphs rasterized at run time. pub const GLYPH_ROWS: u32 = 512; -/// 128x128 atlas slots for map textures. -pub const MAP_SLOTS: usize = 16; +/// 128x128 atlas slots for map textures. A lobby paints its signs as walls of +/// framed maps, so the pool holds a wall; too few slots re-upload every map +/// every frame. 26.3's `MapTextureManager` keeps a texture per map instead. +pub const MAP_SLOTS: usize = 256; /// The atlas slot the minimap extra draws into. pub const MINIMAP_SPRITE: &str = "horizon/minimap"; /// Atlas slots for downloaded player skins (`skins/`), 64x64 each. diff --git a/crates/horizon-protocol/src/item.rs b/crates/horizon-protocol/src/item.rs index 02c9e4966..6f59228b5 100644 --- a/crates/horizon-protocol/src/item.rs +++ b/crates/horizon-protocol/src/item.rs @@ -25,7 +25,10 @@ pub mod component { pub const REPAIR_COST: i32 = 19; pub const CREATIVE_SLOT_LOCK: i32 = 20; pub const ENCHANTMENT_GLINT_OVERRIDE: i32 = 21; + /// `AttackRange`: six floats, in the record's field order. + pub const ATTACK_RANGE: i32 = 30; pub const STORED_ENCHANTMENTS: i32 = 45; + pub const PROFILE: i32 = 72; pub const DYED_COLOR: i32 = 47; pub const MAP_ID: i32 = 48; pub const MAP_POST_PROCESSING: i32 = 50; @@ -57,6 +60,8 @@ pub enum Component { Ident(String), Lore(Vec), Enchantments(Vec<(i32, i32)>), + AttackRange([f32; 6]), + Profile(Profile), CustomModelData { floats: Vec, flags: Vec, @@ -81,6 +86,15 @@ fn filterable(r: &mut Reader, value: impl Fn(&mut Reader) -> Result) -> Re } Ok(raw) } + +/// `ResolvableProfile`: an optional name and UUID and the profile's property +/// list, followed by `PlayerSkin.Patch`'s four optional textures. +#[derive(Clone, Debug, PartialEq)] +pub struct Profile { + pub name: Option, + pub id: Option, + pub properties: Vec<(String, String, Option)>, +} impl Component { fn read(kind: i32, r: &mut Reader) -> Result { use component::*; @@ -129,6 +143,56 @@ impl Component { .collect::>()?, ) } + ATTACK_RANGE => { + let mut values = [0.0f32; 6]; + for v in &mut values { + *v = r.f32()?; + } + Self::AttackRange(values) + } + PROFILE => { + fn properties(r: &mut Reader) -> Result)>> { + let n = r.count(1024)?; + let mut out = Vec::with_capacity(n); + for _ in 0..n { + let name = r.string(32767)?; + let value = r.string(32767)?; + let signature = if r.bool()? { + Some(r.string(32767)?) + } else { + None + }; + out.push((name, value, signature)); + } + Ok(out) + } + // Either: the partial form carries + // optional fields, the resolved one a UUID, a name and the + // properties. + let (name, id, properties) = if r.u8()? == 0 { + let name = if r.bool()? { Some(r.string(64)?) } else { None }; + let id = if r.bool()? { Some(r.uuid()?) } else { None }; + (name, id, properties(r)?) + } else { + let id = Some(r.uuid()?); + let name = Some(r.string(64)?); + (name, id, properties(r)?) + }; + // PlayerSkin.Patch: body, cape, elytra and model, each absent + // in the profiles servers send for heads. + for _ in 0..4 { + if r.bool()? { + // ClientAsset.ResourceTexture: its id and its texture path. + r.string(32767)?; + r.string(32767)?; + } + } + Self::Profile(Profile { + name, + id, + properties, + }) + } CUSTOM_MODEL_DATA => { let n = r.count(r.remaining())?; let floats = (0..n).map(|_| r.f32()).collect::>()?; @@ -175,6 +239,30 @@ impl Component { w.varint(*level); } } + Self::AttackRange(values) => values.iter().for_each(|v| w.f32(*v)), + Self::Profile(p) => { + w.u8(0); + w.bool(p.name.is_some()); + if let Some(name) = &p.name { + w.string(name); + } + w.bool(p.id.is_some()); + if let Some(id) = p.id { + w.uuid(id); + } + w.varint(p.properties.len() as i32); + for (name, value, signature) in &p.properties { + w.string(name); + w.string(value); + w.bool(signature.is_some()); + if let Some(signature) = signature { + w.string(signature); + } + } + for _ in 0..4 { + w.bool(false); + } + } Self::CustomModelData { floats, flags, @@ -471,4 +559,50 @@ mod tests { let bytes = [1, 5, 1, 0, 99]; assert!(Slot::read(&mut Reader::new(&bytes)).is_err()); } + + #[test] + fn attack_range_and_profiles_round_trip() { + let mut sword = Stack::new(900, 1); + sword.added.push(( + component::ATTACK_RANGE, + Component::AttackRange([0.0, 3.0, 0.0, 4.0, 0.1, 1.0]), + )); + sword.added.push(( + component::PROFILE, + Component::Profile(Profile { + name: Some("Player53470".into()), + id: Some(0x7a5d_6a1a_30d7_4187_88c5_efe9_1201_8922), + properties: vec![("textures".into(), "dGV4dHVyZXM=".into(), None)], + }), + )); + round::, Slot>(Some(sword)); + } + + #[test] + fn a_partial_profile_decodes_from_the_wire() { + // count 1, item 1, one added component of kind 72 (profile): a partial + // profile with an empty name, a UUID, one unsigned texture property + // and an empty skin patch. + let uuid = [ + 0x7a, 0x5d, 0x6a, 0x1a, 0x30, 0xd7, 0x41, 0x87, 0x88, 0xc5, 0xef, 0xe9, 0x12, 0x01, + 0x89, 0x22, + ]; + let mut bytes = vec![1, 1, 1, 0, 72, 0, 1, 0, 1]; + bytes.extend_from_slice(&uuid); + bytes.extend_from_slice(&[1, 8]); + bytes.extend_from_slice(b"textures"); + bytes.extend_from_slice(&[1, b'x', 0, 0, 0, 0, 0]); + let mut r = Reader::new(&bytes); + let stack = Slot::read(&mut r).unwrap().unwrap(); + assert_eq!(r.remaining(), 0); + let Some(Component::Profile(profile)) = stack.component(component::PROFILE) else { + panic!("the profile component did not decode"); + }; + assert_eq!(profile.name.as_deref(), Some("")); + assert_eq!(profile.id, Some(0x7a5d_6a1a_30d7_4187_88c5_efe9_1201_8922)); + assert_eq!( + profile.properties, + [("textures".to_owned(), "x".to_owned(), None)] + ); + } } diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs index bfda58e9b..537ecf6ef 100644 --- a/crates/horizon-protocol/src/packets/play.rs +++ b/crates/horizon-protocol/src/packets/play.rs @@ -273,6 +273,68 @@ packet!(Login { online_mode: bool => Bool, enforces_secure_chat: bool => Bool, }); +packet!( +/// MapDecoration: a registry holder, its map position and rotation, and an +/// optional name. +MapDecoration { + kind: i32 => VarInt, + x: i8 => Byte, + y: i8 => Byte, + rot: i8 => Byte, + name: Option => Opt, +} +); + +/// MapItemSavedData.MapPatch: an empty patch is a zero width. +#[derive(Clone, Debug, PartialEq)] +pub struct MapPatch { + pub start_x: i32, + pub start_y: i32, + pub width: i32, + pub height: i32, + pub colors: Vec, +} +pub struct MapPatchOpt; +impl Codec> for MapPatchOpt { + fn read(r: &mut Reader) -> Result> { + let width = i32::from(r.u8()?); + if width == 0 { + return Ok(None); + } + let height = i32::from(r.u8()?); + let start_x = i32::from(r.u8()?); + let start_y = i32::from(r.u8()?); + let n = r.count(r.remaining())?; + let colors = r.bytes(n)?.to_vec(); + Ok(Some(MapPatch { + start_x, + start_y, + width, + height, + colors, + })) + } + fn write(patch: &Option, w: &mut Writer) { + let Some(patch) = patch else { + w.u8(0); + return; + }; + w.u8(patch.width as u8); + w.u8(patch.height as u8); + w.u8(patch.start_x as u8); + w.u8(patch.start_y as u8); + w.varint(patch.colors.len() as i32); + w.bytes(&patch.colors); + } +} + +packet!(MapItemData { + map_id: i32 => VarInt, + scale: i8 => Byte, + locked: bool => Bool, + decorations: Option> => Opt>, + patch: Option => MapPatchOpt, +}); /// VecDelta: per-axis deltas in 1/4096 blocks, linear or in timed steps. #[derive(Clone, Debug, PartialEq)] pub enum VecDelta { @@ -1425,6 +1487,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound { LevelEvent(LevelEvent) = LEVEL_EVENT, LightUpdate(LightUpdate) = LIGHT_UPDATE, Login(Login) = LOGIN, + MapItemData(MapItemData) = MAP_ITEM_DATA, MoveEntityPos(MoveEntityPos) = MOVE_ENTITY_POS, MoveEntityPosRot(MoveEntityPosRot) = MOVE_ENTITY_POS_ROT, MoveEntityRot(MoveEntityRot) = MOVE_ENTITY_ROT, @@ -2490,4 +2553,26 @@ mod tests { assert_eq!(crate::ids::play::clientbound::UPDATE_ATTRIBUTES, 134); assert_eq!(Clientbound::decode(134, &body[2..]).unwrap(), p); } + + #[test] + fn map_item_data_carries_a_server_patch() { + let patch = MapPatch { + start_x: 3, + start_y: 4, + width: 2, + height: 1, + colors: vec![1, 2], + }; + let mut w = Writer::new(); + MapPatchOpt::write(&Some(patch.clone()), &mut w); + assert_eq!(w.data, [2, 1, 3, 4, 2, 1, 2]); + let p = Clientbound::MapItemData(MapItemData { + map_id: 2146483647, + scale: 1, + locked: true, + decorations: None, + patch: Some(patch), + }); + round_trip(p, Clientbound::encode, Clientbound::decode); + } } From d01327862d008dfe3f636aab120e80fe959071c4 Mon Sep 17 00:00:00 2001 From: itspotatotime Date: Wed, 21 Oct 2026 23:29:13 +0300 Subject: [PATCH 26/59] fix(client): hide marker stands and read server entity names A marker armor stand has an empty box, so vanilla's shouldRenderAtSqrDistance computes a zero range and the model never draws; Horizon substituted a 4-block range, which turned the stacked marker stands a lobby uses for holograms into a visible tower. Follow vanilla and let the zero edge cull the model. Server NPCs and mobs also carry CustomName, CustomNameVisible and the shared invisible flag in entity data; Horizon only read those for armor stands. Apply them to every mob, keep the styled component for the name tag, and hide the body when the flag is set. Co-Authored-By: cairn-code (DeepSeek V4.1 Flash) --- crates/horizon-client/src/entity_nbt.rs | 1 + .../horizon-client/src/game/armor_stands.rs | 5 +++- crates/horizon-client/src/game/creatures.rs | 4 ++++ crates/horizon-client/src/game/debug_keys.rs | 2 +- crates/horizon-client/src/game/dispenser.rs | 2 ++ crates/horizon-client/src/game/names.rs | 13 ++++++++--- crates/horizon-client/src/game/remote.rs | 23 +++++++++++++++++++ .../src/game/zombie_villagers.rs | 2 ++ crates/horizon-client/src/mobs.rs | 6 +++++ 9 files changed, 53 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 3044e11ff..aaccdd844 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -615,6 +615,7 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.persistent = flag(tag, "PersistenceRequired"); m.extra.pick_up_loot = flag(tag, "CanPickUpLoot"); m.custom_name = custom_name(tag); + m.custom_name_text = tag.get("CustomName").map(name_text); if m.kind.category == "creature" { m.extra.age = number(tag.get("Age")).unwrap_or(0) as i32; m.extra.forced_age = number(tag.get("ForcedAge")).unwrap_or(0) as i32; diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs index aa55d83df..018c3d7ab 100644 --- a/crates/horizon-client/src/game/armor_stands.rs +++ b/crates/horizon-client/src/game/armor_stands.rs @@ -432,7 +432,10 @@ impl Game<'_> { (false, false) => (0.5, 1.975), }; let edge = (width + height + width) / 3.0 * 4.0; - let range = if edge == 0.0 { 4.0 } else { edge } * 64.0; + // A marker's empty box gives a range of zero: vanilla's + // `distance < 0` never holds, so marker stands never draw. + let edge = if edge == 1.0 { 4.0 } else { edge }; + let range = edge * 64.0; let dragon = a.equipment[5] .as_ref() .is_some_and(|i| &*i.item == "minecraft:dragon_head"); diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index d36e0adec..98756217f 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2929,6 +2929,10 @@ impl Game<'_> { let scale = f64::from(self.settings.entity_distance); for mob in &self.mobs { let entity_start = out.len(); + // Entity.DATA_SHARED_FLAGS_ID invisible: only the name tag draws. + if mob.invisible { + continue; + } let d = glam::DVec3::new(mob.position.x, mob.position.y, mob.position.z) - camera; // Entity.shouldRenderAtSqrDistance: 64 times the bounding box's // mean edge, scaled by the entity distance option. diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index a2e1b0ce6..553cd0d96 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -753,7 +753,7 @@ impl Game<'_> { let lerp = |a: f64, b: f64| a + f64::from(alpha) * (b - a); let lerpf = |a: f32, b: f32| a + alpha * (b - a); for m in &self.mobs { - if m.removed || m.has_effect("minecraft:invisibility") { + if m.removed || m.invisible || m.has_effect("minecraft:invisibility") { continue; } let pos = [ diff --git a/crates/horizon-client/src/game/dispenser.rs b/crates/horizon-client/src/game/dispenser.rs index b4e358d50..61725c6ab 100644 --- a/crates/horizon-client/src/game/dispenser.rs +++ b/crates/horizon-client/src/game/dispenser.rs @@ -1736,7 +1736,9 @@ impl Game<'_> { mob.head_pitch = old.head_pitch; mob.persistent = old.persistent; mob.custom_name = old.custom_name.clone(); + mob.custom_name_text = old.custom_name_text.clone(); mob.name_visible = old.name_visible; + mob.invisible = old.invisible; mob.no_ai = old.no_ai; mob.silent = old.silent; mob.no_gravity = old.no_gravity; diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index 5a1ea9f68..be829f1bb 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -124,7 +124,7 @@ impl Game<'_> { team, viewer, self.spectator(), - m.has_effect("minecraft:invisibility"), + m.invisible || m.has_effect("minecraft:invisibility"), ); // Entity.isDiscrete: a crouching player. let discrete = player && m.extra.crouching; @@ -144,9 +144,16 @@ impl Game<'_> { continue; } // getDisplayName: the name in the team's prefix, suffix and colour. + let member = if player { + Text::literal(&name) + } else { + m.custom_name_text + .clone() + .unwrap_or_else(|| Text::literal(&name)) + }; let shown = match team { - Some(t) => t.formatted_name(Text::literal(&name)), - None => Text::literal(&name), + Some(t) => t.formatted_name(member), + None => member, }; let mut lines = Vec::new(); // EntityRenderer.extractNameTags: the score shows within the diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 36f4499b5..c3da8b903 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -1709,6 +1709,29 @@ impl Game<'_> { } } C::SetEntityData(p) => { + // Entity.DATA_SHARED_FLAGS_ID, DATA_CUSTOM_NAME and + // DATA_CUSTOM_NAME_VISIBLE: server NPCs and holograms rely on + // these instead of saved NBT. + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { + for (index, _, value) in &p.values { + match (index, value) { + (0, Value::Byte(flags)) => m.invisible = flags & 0x20 != 0, + (2, Value::OptText(name)) => { + let text = name.as_ref().map(horizon_client::entity_nbt::name_text); + m.custom_name = + text.as_ref().map(horizon_client::text::Text::plain); + m.custom_name_text = text; + } + (2, Value::Text(name)) => { + let text = horizon_client::entity_nbt::name_text(name); + m.custom_name = Some(text.plain()); + m.custom_name_text = Some(text); + } + (3, Value::Bool(visible)) => m.name_visible = *visible, + _ => {} + } + } + } if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) && m.species() == horizon_client::mobs::Species::Rabbit { diff --git a/crates/horizon-client/src/game/zombie_villagers.rs b/crates/horizon-client/src/game/zombie_villagers.rs index c68c0f1c1..b47e2460c 100644 --- a/crates/horizon-client/src/game/zombie_villagers.rs +++ b/crates/horizon-client/src/game/zombie_villagers.rs @@ -194,7 +194,9 @@ fn carry_over(from: &Mob, to: &mut Mob) { to.fire_ticks = from.fire_ticks; to.persistent = from.persistent; to.custom_name = from.custom_name.clone(); + to.custom_name_text = from.custom_name_text.clone(); to.name_visible = from.name_visible; + to.invisible = from.invisible; to.extra.pick_up_loot = from.extra.pick_up_loot; to.extra.main_hand = from.extra.main_hand.clone(); to.extra.off_hand = from.extra.off_hand.clone(); diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 3c2b34178..654371a3c 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -807,7 +807,11 @@ pub struct Mob { pub persistent: bool, /// `CustomName` (plain text) and `CustomNameVisible`. pub custom_name: Option, + /// The styled `CustomName`, when it came from a component. + pub custom_name_text: Option, pub name_visible: bool, + /// `Entity.DATA_SHARED_FLAGS_ID` bit 0x20: the model is hidden. + pub invisible: bool, pub random: LegacyRandom, pub ai: Box, pub extra: Extra, @@ -1518,7 +1522,9 @@ impl Mob { last_damage: None, removed: false, custom_name: None, + custom_name_text: None, name_visible: false, + invisible: false, anim: anim::AnimState::default(), rider: None, outbox: Vec::new(), From 71edc9d41ce51c555f4c80b630a6e7c3f533d1b8 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 13:18:54 +0000 Subject: [PATCH 27/59] Prepare with Minecraft's own Java 25 when no JDK is installed On a Mac without a JDK, preparing failed with "Java 25 is needed ... /usr/bin/javac -version printed no version: Unable to locate a Java Runtime": /usr/bin/javac is macOS's placeholder. Mojang's Java runtimes are whole JDKs, javac included (java-runtime-epsilon is 25.0.1 on every platform), and the official launcher has already downloaded one for anyone who played 26.3. - horizon-prepare: java::find also tries Minecraft's runtimes (/runtime///, jre.bundle on macOS) and the launcher's pick (Options::java_home), and names the macOS placeholder for what it is. - launcher: when no JDK is found, downloads the runtime the version JSON names (javaVersion.component) from Mojang into its own game folder, every file checked against its sha1, executables and links as the official launcher lays them out. A version's own preparer binary or Python script gets it through JAVA_HOME and the PATH. Checked for real on Linux: the download is 147 files, its javac 25.0.1 compiles and runs a class with --release 25. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01AxbYUJt4ShJFCdyLNCxF21 --- crates/horizon-prepare/src/java.rs | 96 ++++++++++++++++++++++-- crates/horizon-prepare/src/lib.rs | 9 ++- crates/horizon-prepare/src/main.rs | 1 + launcher/src/backend.rs | 97 +++++++++++++++++++----- launcher/src/mojang.rs | 116 +++++++++++++++++++++++++++++ launcher/src/mojang_tests.rs | 96 ++++++++++++++++++++++++ website/docs/install.md | 2 +- website/docs/troubleshooting.md | 2 +- 8 files changed, 390 insertions(+), 29 deletions(-) diff --git a/crates/horizon-prepare/src/java.rs b/crates/horizon-prepare/src/java.rs index d54ef0949..a159fb055 100644 --- a/crates/horizon-prepare/src/java.rs +++ b/crates/horizon-prepare/src/java.rs @@ -41,11 +41,19 @@ fn javac_major(javac: &Path) -> Result { .skip_while(|w| *w != "javac") .nth(1) .ok_or_else(|| { - format!( - "{} -version printed no version: {}", - javac.display(), - text.trim() - ) + // macOS ships /usr/bin/javac as a placeholder that only says no Java is installed. + if text.contains("Unable to locate a Java Runtime") { + format!( + "{} is macOS's placeholder (no Java installed)", + javac.display() + ) + } else { + format!( + "{} -version printed no version: {}", + javac.display(), + text.trim() + ) + } })?; let mut parts = version.split(['.', '-', '+', '_']); let first: u32 = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0); @@ -126,11 +134,38 @@ fn installed_jdks(parents: &[PathBuf], major: i64) -> Vec { homes } +/// The Java runtimes the official launcher downloaded into `runtime` (a game directory's +/// `runtime` folder: `///`, a macOS one in `jre.bundle`). Mojang's +/// runtimes are whole JDKs, javac included, so a player who has run Minecraft has one already. +pub fn minecraft_runtimes(runtime: &Path) -> Vec { + let children = |dir: &Path| -> Vec { + let mut paths: Vec = fs::read_dir(dir) + .map(|entries| entries.flatten().map(|e| e.path()).collect()) + .unwrap_or_default(); + paths.sort(); + paths + }; + let mut homes = Vec::new(); + for component in children(runtime) { + for platform in children(&component) { + let home = platform.join(component.file_name().unwrap_or_default()); + for home in [home.join("jre.bundle/Contents/Home"), home] { + if executable(&home.join("bin"), "javac").is_file() { + homes.push(home); + break; + } + } + } + } + homes +} + /// Finds a JDK with `javac` of at least `major`, the version research-lock.json pins: /// `JAVA_HOME` when it holds one, else `javac` and `java` on the PATH (as the Python preparer -/// ran them), else, on macOS, the JDK `/usr/libexec/java_home -v ` reports, else a JDK -/// in the folders installers put them in (`jdk_parents`). -pub fn find(major: i64) -> Result { +/// ran them), else, on macOS, the JDK `/usr/libexec/java_home -v ` reports, else the JDK +/// homes in `more` (the launcher's pick, Minecraft's own runtimes), else a JDK in the folders +/// installers put them in (`jdk_parents`). +pub fn find(major: i64, more: &[PathBuf]) -> Result { let need = format!( "Java {major} is needed (a JDK with javac, e.g. Eclipse Temurin {major}). \ Install it, or set JAVA_HOME to it, and try again." @@ -164,6 +199,14 @@ pub fn find(major: i64) -> Result { } } } + for home in more { + let bin = home.join("bin"); + candidates.push(( + executable(&bin, "javac"), + executable(&bin, "java"), + "Minecraft's Java", + )); + } for home in installed_jdks(&jdk_parents(), major) { let bin = home.join("bin"); candidates.push(( @@ -205,6 +248,15 @@ pub fn classpath<'a>(paths: impl IntoIterator) -> String { } impl Jdk { + /// The JDK's home, the folder above `bin` (what `JAVA_HOME` names). + pub fn home(&self) -> PathBuf { + self.javac + .parent() + .and_then(Path::parent) + .map(Path::to_path_buf) + .unwrap_or_default() + } + /// `javac --release -proc:none` with Python's `subprocess.run(..., check=True, /// stdout=log, stderr=STDOUT, timeout=3600)`. pub fn javac(&self, major: i64, args: &[String], log: &fs::File) -> Result<(), String> { @@ -301,4 +353,32 @@ mod tests { ); fs::remove_dir_all(&dir).unwrap(); } + + #[test] + fn minecraft_runtimes_are_found_in_the_launchers_layout() { + let dir = + std::env::temp_dir().join(format!("horizon-prepare-runtimes-{}", std::process::id())); + let _ = fs::remove_dir_all(&dir); + let make = |home: PathBuf, javac: bool| { + fs::create_dir_all(home.join("bin")).unwrap(); + if javac { + fs::write(executable(&home.join("bin"), "javac"), b"").unwrap(); + } + home + }; + let gamma = make( + dir.join("java-runtime-gamma/linux/java-runtime-gamma"), + true, + ); + let epsilon = make( + dir.join( + "java-runtime-epsilon/mac-os-arm64/java-runtime-epsilon/jre.bundle/Contents/Home", + ), + true, + ); + make(dir.join("jre-legacy/linux/jre-legacy"), false); + assert_eq!(minecraft_runtimes(&dir), [epsilon, gamma]); + assert!(minecraft_runtimes(&dir.join("missing")).is_empty()); + fs::remove_dir_all(&dir).unwrap(); + } } diff --git a/crates/horizon-prepare/src/lib.rs b/crates/horizon-prepare/src/lib.rs index 66ff671f9..861db254d 100644 --- a/crates/horizon-prepare/src/lib.rs +++ b/crates/horizon-prepare/src/lib.rs @@ -74,6 +74,9 @@ pub struct Options { pub minecraft_dir: Option, /// The pinned server jar the player downloaded (`--server-jar`, else HORIZON_SERVER_JAR). pub server_jar: Option, + /// The JDK to try after JAVA_HOME and the PATH (the launcher's pick, e.g. Minecraft's + /// own Java it downloaded from Mojang). + pub java_home: Option, } pub(crate) fn hex(bytes: &[u8]) -> String { @@ -402,7 +405,11 @@ pub fn prepare(options: &Options, log: Log) -> Result { .map_err(|e| format!("{}: {e}", options.root.display()))?; let lock = artifacts::Lock::read(root)?; // Java first: nothing below can finish without it, and the player should hear it at once. - let jdk = java::find(lock.java_major)?; + let mut homes: Vec = options.java_home.iter().cloned().collect(); + homes.extend(java::minecraft_runtimes( + &artifacts::minecraft_dir(options.minecraft_dir.as_deref()).join("runtime"), + )); + let jdk = java::find(lock.java_major, &homes)?; if options.import && !artifacts::reuse_imported(root, log)? { artifacts::import( root, diff --git a/crates/horizon-prepare/src/main.rs b/crates/horizon-prepare/src/main.rs index 71b7a40cc..0d3a5685d 100644 --- a/crates/horizon-prepare/src/main.rs +++ b/crates/horizon-prepare/src/main.rs @@ -62,6 +62,7 @@ fn main() -> ExitCode { import: false, minecraft_dir: None, server_jar: None, + java_home: None, }; let mut root = None; let mut args = std::env::args_os().skip(1).peekable(); diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index ba854730f..7fce7ce07 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -993,6 +993,61 @@ fn download_for_owner( } } +/// The home of a JDK of at least `major`: one horizon-prepare finds (JAVA_HOME, the PATH, an +/// installed JDK) or the Java the official launcher downloaded into one of the `games` +/// folders, else Minecraft's own Java downloaded from Mojang into Horizon's game folder, the +/// runtime the version JSON at `manifest` names (Mojang's runtimes are whole JDKs). +fn java( + major: i64, + games: &[PathBuf], + manifest: &Path, + log: &dyn Fn(String), +) -> Result { + let runtimes = || -> Vec { + let mut homes: Vec = games + .iter() + .flat_map(|game| horizon_prepare::java::minecraft_runtimes(&game.join("runtime"))) + .collect(); + homes.dedup(); + homes + }; + let missing = match horizon_prepare::java::find(major, &runtimes()) { + Ok(jdk) => return Ok(jdk.home()), + Err(e) => e, + }; + let component = read_json(manifest) + .and_then(|json| json["javaVersion"]["component"].as_str().map(String::from)) + .ok_or_else(|| missing.clone())?; + let fetch = |url: &str| -> Result, String> { + let mut body = Vec::new(); + get(url)? + .into_reader() + .read_to_end(&mut body) + .map_err(|e| e.to_string())?; + Ok(body) + }; + let runtime = data_dir().join("minecraft").join("runtime"); + let home = mojang::java_runtime(&component, &runtime, 8, &fetch, log).map_err(|e| { + format!("{missing}\n • Horizon also tried to download Minecraft's own Java from Mojang, but: {e}") + })?; + horizon_prepare::java::find(major, &[home]).map(|jdk| jdk.home()) +} + +/// Runs `cmd` with the JDK at `home`: JAVA_HOME names it and its `bin` leads the PATH, as the +/// versions' own preparers look for Java. +fn with_java(cmd: &mut Command, home: &Path) { + let mut path = vec![home.join("bin")]; + path.extend( + std::env::var_os("PATH") + .iter() + .flat_map(std::env::split_paths), + ); + cmd.env("JAVA_HOME", home); + if let Ok(path) = std::env::join_paths(path) { + cmd.env("PATH", path); + } +} + /// Checks what the preparation needs and picks how to run it. PLAY.txt describes the same /// steps: the player's own launcher install, the server jar from that version's own json, and /// Java (and Python, for versions before horizon-prepare). Also returns the Minecraft folder @@ -1006,6 +1061,7 @@ pub fn preparer( let version = game_version(tag); let dir = version_dir(tag); let reused = horizon_prepare::artifacts::reuse_imported(&dir, &|line| log(line.to_string()))?; + let chosen = minecraft.to_path_buf(); let minecraft = if reused { minecraft.to_path_buf() } else { @@ -1042,25 +1098,27 @@ pub fn preparer( .join(&version) .join(format!("{version}.json")); let binary = preparer_binary(&dir); - let python = if binary.is_some() { - // The JDK the version pins, found as horizon-prepare finds it, so a missing one is - // reported before the server jar is downloaded. - let major = read_json(&dir.join("research-lock.json")) - .and_then(|lock| lock["minecraft"]["java_major"].as_i64()) - .ok_or("The version's research-lock.json has no java_major")?; - horizon_prepare::java::find(major)?; - None - } else { - let python = python() - .ok_or("This version prepares with Python: Python 3.10 or newer is needed. Install it, or pick a newer version.")?; - if !found("java", "-version") { - return Err( - "Java 25 is needed (a JDK, e.g. Eclipse Temurin 25). Install it and try again." - .into(), - ); - } - Some(python) + let python = match binary { + Some(_) => None, + None => Some(python().ok_or( + "This version prepares with Python: Python 3.10 or newer is needed. Install it, or pick a newer version.", + )?), }; + // The JDK the version pins, found as horizon-prepare finds it, so a missing one is + // reported (or downloaded) before the server jar is downloaded. Versions from before + // java_major ran Java 25. + let major = read_json(&dir.join("research-lock.json")) + .and_then(|lock| lock["minecraft"]["java_major"].as_i64()) + .unwrap_or(25); + let mut games = vec![chosen, minecraft.clone(), data_dir().join("minecraft")]; + games.extend( + sources::Folders::current() + .map(|f| sources::known_folders(sources::Os::current(), &f)) + .unwrap_or_default() + .into_iter() + .map(|(_, dir)| dir), + ); + let java_home = java(major, &games, &manifest, log)?; let jar = data_dir() .join("server-jars") .join(format!("{version}.jar")); @@ -1092,10 +1150,12 @@ pub fn preparer( import: !reused, minecraft_dir: Some(minecraft.clone()), server_jar: (!reused).then_some(jar), + java_home: Some(java_home), }; return Ok((Preparer::InProcess(options), minecraft)); } let mut cmd = Command::new(binary); + with_java(&mut cmd, &java_home); cmd.current_dir(&dir).arg("--root").arg(&dir); if !reused { cmd.args(["--prepare", "--server-jar"]).arg(&jar); @@ -1104,6 +1164,7 @@ pub fn preparer( return Ok((Preparer::Process(cmd), minecraft)); } let mut cmd = Command::new(python.unwrap()); + with_java(&mut cmd, &java_home); cmd.current_dir(&dir) .args(["-u", "tools/prepare_native_client.py"]); if !reused { diff --git a/launcher/src/mojang.rs b/launcher/src/mojang.rs index dbe2aa7fb..070db43aa 100644 --- a/launcher/src/mojang.rs +++ b/launcher/src/mojang.rs @@ -13,6 +13,8 @@ use std::sync::Mutex; use std::time::Duration; const OBJECTS: &str = "https://resources.download.minecraft.net"; +/// The index of Mojang's Java runtimes, the one the official launcher reads. +const JAVA_RUNTIMES: &str = "https://launchermeta.mojang.com/v1/products/java-runtime/2ec0cc96c44e5a76b9c8b7c39df7210883d12871/all.json"; /// One file to download. struct File { @@ -84,6 +86,120 @@ pub fn download( Ok(()) } +/// Mojang's name for this system in its Java runtime index. +fn java_platform() -> Option<&'static str> { + Some(match (std::env::consts::OS, std::env::consts::ARCH) { + ("macos", "aarch64") => "mac-os-arm64", + ("macos", "x86_64") => "mac-os", + ("linux", "x86_64") => "linux", + ("linux", "x86") => "linux-i386", + ("windows", "x86_64") => "windows-x64", + ("windows", "aarch64") => "windows-arm64", + ("windows", "x86") => "windows-x86", + _ => return None, + }) +} + +/// Downloads Mojang's Java runtime `component` (the version JSON's `javaVersion.component`, e.g. +/// `java-runtime-epsilon`) into the game directory's `runtime` folder, as the official launcher +/// lays it out: `///`. Each file is checked against its sha1; +/// files already there and whole are kept. Mojang's runtimes are whole JDKs, javac included, +/// which is what the exporters need. +pub fn java_runtime( + component: &str, + runtime: &Path, + jobs: usize, + fetch: Fetch, + log: &dyn Fn(String), +) -> Result { + let platform = java_platform().ok_or("Mojang has no Java for this system")?; + let index: Value = serde_json::from_slice(&fetch(JAVA_RUNTIMES)?) + .map_err(|e| format!("Mojang's Java index: {e}"))?; + let entry = &index[platform][component][0]; + if entry.is_null() { + return Err(format!("Mojang has no {component} for {platform}")); + } + let manifest = &entry["manifest"]; + let manifest: Value = serde_json::from_slice(&fetch_checked( + fetch, + &text(manifest, "url")?, + &text(manifest, "sha1")?, + )?) + .map_err(|e| format!("Mojang's {component} manifest: {e}"))?; + let files = manifest["files"] + .as_object() + .ok_or_else(|| format!("Mojang's {component} manifest lists no files"))?; + let home = runtime.join(component).join(platform).join(component); + let mut downloads = Vec::new(); + let mut executables = Vec::new(); + let mut links = Vec::new(); + for (name, file) in files { + let path = home.join(relative(name)?); + match file["type"].as_str() { + Some("file") => { + let raw = &file["downloads"]["raw"]; + if file["executable"] == true { + executables.push(path.clone()); + } + downloads.push(File { + url: text(raw, "url")?, + sha1: text(raw, "sha1")?, + path, + }); + } + Some("link") => links.push((path, text(file, "target")?)), + _ => {} + } + } + let name = entry["version"]["name"].as_str().unwrap_or(component); + log(format!( + "Downloading Minecraft's Java {name} from Mojang ({} files)", + downloads.len() + )); + fetch_all(&downloads, jobs, fetch, log)?; + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + for path in &executables { + fs::set_permissions(path, fs::Permissions::from_mode(0o755)) + .map_err(|e| format!("{}: {e}", path.display()))?; + } + for (path, target) in &links { + if !link_stays_inside(name_in(&home, path), target) { + return Err(format!( + "Unsafe link {target:?} in Mojang's {component} manifest" + )); + } + let _ = fs::remove_file(path); + fs::create_dir_all(path.parent().unwrap()) + .and_then(|_| std::os::unix::fs::symlink(target, path)) + .map_err(|e| format!("{}: {e}", path.display()))?; + } + } + #[cfg(not(unix))] + let _ = (executables, links); + Ok(home) +} + +fn name_in<'a>(home: &Path, path: &'a Path) -> &'a Path { + path.strip_prefix(home).unwrap_or(path) +} + +/// Whether a link at `link` (relative to the runtime's home) pointing at `target` stays in the +/// home. +fn link_stays_inside(link: &Path, target: &str) -> bool { + let mut depth = link.components().count().saturating_sub(1); + for c in Path::new(target).components() { + match c { + Component::Normal(_) => depth += 1, + Component::CurDir => {} + Component::ParentDir if depth > 0 => depth -= 1, + _ => return false, + } + } + true +} + fn read_json(path: &Path) -> Result { let text = fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?; serde_json::from_str(&text).map_err(|e| format!("{}: {e}", path.display())) diff --git a/launcher/src/mojang_tests.rs b/launcher/src/mojang_tests.rs index b50a77a93..24ed80bca 100644 --- a/launcher/src/mojang_tests.rs +++ b/launcher/src/mojang_tests.rs @@ -230,3 +230,99 @@ fn version_file_paths_stay_in_the_folder() { assert!(relative(bad).is_err(), "{bad}"); } } + +#[test] +fn links_stay_inside_the_runtime() { + let at = |p: &str| PathBuf::from(p); + assert!(link_stays_inside( + &at("legal/java.compiler/LICENSE"), + "../java.base/LICENSE" + )); + assert!(link_stays_inside(&at("lib/a"), "b")); + assert!(!link_stays_inside(&at("lib/a"), "../../b")); + assert!(!link_stays_inside(&at("a"), "/etc/passwd")); +} + +#[cfg(all(target_os = "linux", target_arch = "x86_64"))] +#[test] +fn java_runtime_lays_out_mojangs_runtime_with_its_executables_and_links() { + const JAVAC: &[u8] = b"#!/bin/sh\necho javac 25.0.1\n"; + const LICENSE: &[u8] = b"a fake license"; + let manifest = serde_json::json!({"files": { + "bin": {"type": "directory"}, + "bin/javac": {"type": "file", "executable": true, "downloads": {"raw": + {"sha1": sha1_hex(JAVAC), "size": JAVAC.len(), "url": "https://piston-data.mojang.com/javac"}}}, + "legal/java.base/LICENSE": {"type": "file", "executable": false, "downloads": {"raw": + {"sha1": sha1_hex(LICENSE), "size": LICENSE.len(), "url": "https://piston-data.mojang.com/license"}}}, + "legal/java.compiler/LICENSE": {"type": "link", "target": "../java.base/LICENSE"}, + }}) + .to_string(); + let index = serde_json::json!({"linux": {"java-runtime-epsilon": [{ + "manifest": {"sha1": sha1_hex(manifest.as_bytes()), "url": "https://piston-meta.mojang.com/m.json"}, + "version": {"name": "25.0.1"}, + }]}}) + .to_string(); + let server = Server { + files: HashMap::from([ + (JAVA_RUNTIMES.to_string(), index.into_bytes()), + ( + "https://piston-meta.mojang.com/m.json".into(), + manifest.into_bytes(), + ), + ( + "https://piston-data.mojang.com/javac".into(), + JAVAC.to_vec(), + ), + ( + "https://piston-data.mojang.com/license".into(), + LICENSE.to_vec(), + ), + ]), + asked: Mutex::new(Vec::new()), + }; + let dir = scratch("java"); + let home = java_runtime( + "java-runtime-epsilon", + &dir, + 2, + &|url| server.fetch(url), + &|_| {}, + ) + .unwrap(); + assert_eq!( + home, + dir.join("java-runtime-epsilon/linux/java-runtime-epsilon") + ); + use std::os::unix::fs::PermissionsExt; + let mode = fs::metadata(home.join("bin/javac")) + .unwrap() + .permissions() + .mode(); + assert_eq!(mode & 0o111, 0o111); + assert_eq!( + fs::read(home.join("legal/java.compiler/LICENSE")).unwrap(), + LICENSE + ); + // horizon-prepare finds it where the official launcher would have put it. + assert_eq!(horizon_prepare::java::minecraft_runtimes(&dir), [home]); + // A second call keeps the files: only the index and manifest are asked again. + server.asked(); + java_runtime( + "java-runtime-epsilon", + &dir, + 2, + &|url| server.fetch(url), + &|_| {}, + ) + .unwrap(); + assert_eq!(server.asked().len(), 2); + assert!(java_runtime( + "java-runtime-zeta", + &dir, + 2, + &|url| server.fetch(url), + &|_| {} + ) + .is_err()); + fs::remove_dir_all(&dir).unwrap(); +} diff --git a/website/docs/install.md b/website/docs/install.md index b898d79de..8f0df0834 100644 --- a/website/docs/install.md +++ b/website/docs/install.md @@ -5,7 +5,7 @@ Download the launcher, let it install Horizon, then prepare the game from your o ## What you need - **Minecraft: Java Edition 26.3, played once.** Install it with the official Minecraft launcher (or Prism Launcher, MultiMC, the Modrinth App, ATLauncher or GDLauncher) and start 26.3 once, so it downloads its files. Horizon reads them from there and never copies them anywhere else. -- **Java 25, a JDK.** For example [Eclipse Temurin 25](https://adoptium.net/temurin/releases/?version=25). Only the one-time preparation uses it. The game itself needs no Java. +- **Java 25, a JDK**, for the one-time preparation only (the game itself needs no Java). Nothing to install: the launcher uses the Java the Minecraft launcher downloaded for 26.3, or downloads that same Java from Mojang. A JDK you installed yourself (for example [Eclipse Temurin 25](https://adoptium.net/temurin/releases/?version=25)) works too. - **A computer on the [supported list](/docs/#supported-systems).** On Linux and Windows that means a graphics card with Vulkan (or DirectX 12 on Windows). ## Download the launcher diff --git a/website/docs/troubleshooting.md b/website/docs/troubleshooting.md index b7dac8fe4..c62802186 100644 --- a/website/docs/troubleshooting.md +++ b/website/docs/troubleshooting.md @@ -30,7 +30,7 @@ The launcher's **Settings** page has a **Logs** row with an **Open** button. On - **The game does not start, or crashes straight away.** Update the launcher and Horizon, and your graphics drivers. On Windows, try **Graphics API: DirectX 12** (see [Settings](/docs/settings#graphics-api-on-windows)). - **"Not prepared" or "Minecraft 26.3 was not found".** Play 26.3 once in the official Minecraft launcher, or point the launcher at your Minecraft folder (**Choose…** next to Minecraft folder on the Play page), then choose **Prepare** again. -- **Preparation says Java 25 is needed.** Install a Java 25 JDK, for example Eclipse Temurin 25. +- **Preparation says Java 25 is needed.** Update the launcher: it then uses the Java the Minecraft launcher downloaded for 26.3, or downloads it from Mojang. If it still can't (no internet, say), install a Java 25 JDK, for example Eclipse Temurin 25. - **Slow or stuttering.** Lower the render distance, turn LOD off, or pick the **Performance** preset. The performance overlay (Video, Advanced, Overlay) shows what is slow. - **A resource or shader pack broke something.** Switch it off, or take it out of its folder. From a20ebde7ab2ad1fd88d8bd7577a862d614cab0c7 Mon Sep 17 00:00:00 2001 From: itspotatotime Date: Wed, 21 Oct 2026 23:51:38 +0300 Subject: [PATCH 28/59] fix(client): carry every server item component into tooltips to_stack kept only damage, dyed colour, map id and a head profile, so a server item's custom name, lore, enchantments and custom data never reached the inventory tooltip. Build the vanilla `components` compound from the decoded patch and run it through the same decoder saved item NBT uses, then show lore lines between the name and the details. Co-Authored-By: cairn-code (DeepSeek V4.1 Flash) --- crates/horizon-client/src/game/remote.rs | 163 ++++++++++++++-------- crates/horizon-client/src/item_tooltip.rs | 18 +++ 2 files changed, 122 insertions(+), 59 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index c3da8b903..a1e10576c 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -542,71 +542,116 @@ impl Game<'_> { let mut out = ItemStack { item: self.item_name(s.item), count: s.count.max(0) as u32, - damage: s.damage().max(0) as u32, + damage: 0, extra: None, }; - use horizon_protocol::item::{Component, component}; - if let Some(Component::Int(rgb)) = s.component(component::DYED_COLOR) { - out.data_mut().dyed_color = Some(*rgb); - } - if let Some(Component::Int(id)) = s.component(component::MAP_ID) { - out.data_mut().map_id = Some(*id); - } - if let Some(Component::Int(cost)) = s.component(component::REPAIR_COST) { - out.data_mut().repair_cost = (*cost).max(0) as u32; - } - if let Some(Component::Int(mode)) = s.component(component::MAP_POST_PROCESSING) { - out.data_mut().map_post_processing = Some((*mode).clamp(0, 1) as u8); - } - if let Some(Component::WritableBook(pages)) = s.component(component::WRITABLE_BOOK_CONTENT) - { - out.data_mut().writable_pages = pages.clone(); - } - if let Some(Component::WrittenBook(b)) = s.component(component::WRITTEN_BOOK_CONTENT) { - let lang = self - .remote - .as_ref() - .map(|r| r.lang.clone()) - .unwrap_or_default(); - out.data_mut().written = Some(horizon_client::item_data::WrittenBook { - title: b.title.clone(), - author: b.author.clone(), - generation: b.generation.clamp(0, 3) as u8, - pages: b.pages.iter().map(|p| plain(p, &lang)).collect(), - }); - } - if let Some(Component::Text(name)) = s.component(component::CUSTOM_NAME) { - let lang = self - .remote - .as_ref() - .map(|r| r.lang.clone()) - .unwrap_or_default(); - out.data_mut().custom_name = Some(plain(name, &lang)); - } - // The enchantments by the server's registry ids. - let levels = |list: &[(i32, i32)]| -> Vec<(Arc, u32)> { - let names = self.remote.as_ref().map(|r| &r.registries); - list.iter() - .filter_map(|(id, level)| { - let name = names?.name("minecraft:enchantment", *id)?; - Some((Arc::from(name), (*level).max(0) as u32)) - }) - .collect() - }; - if let Some(Component::Enchantments(list)) = s.component(component::ENCHANTMENTS) { - out.data_mut().enchantments = levels(list); - } - if let Some(Component::Enchantments(list)) = s.component(component::STORED_ENCHANTMENTS) { - out.data_mut().stored_enchantments = levels(list); + // A vanilla `components` compound, then the same decoder the saved + // and command item NBT use, so tooltips and models see every field. + let components = self.protocol_components(s); + let (damage, data) = horizon_client::item_data::decode_components(components.as_ref()); + out.damage = damage; + if let Some(data) = data { + *out.data_mut() = *data; } out.tidy(); - if let Some(Component::Profile(p)) = s.component(component::PROFILE) { - out.data_mut() - .other - .push(("minecraft:profile".into(), profile_tag(p))); - } Some(out) } + /// The item's patched components as vanilla's `components` compound. + fn protocol_components(&self, s: &Stack) -> Option { + use horizon_protocol::item::{Component, component}; + let r = self.remote.as_ref()?; + let name = |id: i32| r.builtin.get("minecraft:data_component_type")?.name(id); + let mut entries: Vec<(&str, Tag)> = Vec::new(); + for (kind, c) in &s.added { + let Some(key) = name(*kind) else { + continue; + }; + let value = match c { + Component::Int(v) if *kind == component::RARITY => { + let rarity = ["common", "uncommon", "rare", "epic"]; + Tag::String(rarity.get(*v as usize).copied().unwrap_or("common").into()) + } + Component::Int(v) => Tag::Int(*v), + Component::Unit => Tag::Compound(Default::default()), + Component::Bool(v) => Tag::Byte(i8::from(*v)), + Component::Text(t) | Component::Nbt(t) => t.clone(), + Component::Ident(v) => Tag::String(v.as_str().into()), + Component::Lore(lines) => Tag::List(lines.clone()), + Component::WritableBook(pages) => Tag::compound([( + "pages", + Tag::List( + pages + .iter() + .map(|p| Tag::String(p.as_str().into())) + .collect(), + ), + )]), + Component::WrittenBook(b) => Tag::compound([ + ("title", Tag::String(b.title.as_str().into())), + ("author", Tag::String(b.author.as_str().into())), + ("generation", Tag::Int(b.generation)), + ("pages", Tag::List(b.pages.clone())), + ("resolved", Tag::Byte(i8::from(b.resolved))), + ]), + Component::Enchantments(list) => { + let registry = r.builtin.get("minecraft:enchantment"); + let levels = list.iter().filter_map(|(id, level)| { + let name = registry?.name(*id)?; + Some((name, Tag::Int(*level))) + }); + Tag::compound(levels) + } + Component::AttackRange(v) => Tag::compound([ + ("min_reach", Tag::Float(v[0].to_bits())), + ("max_reach", Tag::Float(v[1].to_bits())), + ("min_attack_momentum", Tag::Float(v[2].to_bits())), + ("max_attack_momentum", Tag::Float(v[3].to_bits())), + ("hitbox_margin", Tag::Float(v[4].to_bits())), + ("mob_factor", Tag::Float(v[5].to_bits())), + ]), + Component::Profile(p) => profile_tag(p), + Component::CustomModelData { + floats, + flags, + strings, + colors, + } => Tag::compound([ + ( + "floats", + Tag::List(floats.iter().map(|f| Tag::Float(f.to_bits())).collect()), + ), + ( + "flags", + Tag::List(flags.iter().map(|b| Tag::Byte(i8::from(*b))).collect()), + ), + ( + "strings", + Tag::List( + strings + .iter() + .map(|s| Tag::String(s.as_str().into())) + .collect(), + ), + ), + ( + "colors", + Tag::List(colors.iter().map(|c| Tag::Int(*c)).collect()), + ), + ]), + Component::TooltipDisplay { hide, hidden } => { + let hidden = hidden + .iter() + .filter_map(|id| Some(Tag::String(name(*id)?.into()))); + Tag::compound([ + ("hide_tooltip", Tag::Byte(i8::from(*hide))), + ("hidden_components", Tag::List(hidden.collect())), + ]) + } + }; + entries.push((key, value)); + } + Some(Tag::compound(entries)) + } fn to_network(&self, s: &Option) -> Option { let s = s.as_ref()?; let mut stack = Stack::new(self.item_id(&s.item), s.count as i32); diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs index 0fc9910d1..bf398edfc 100644 --- a/crates/horizon-client/src/item_tooltip.rs +++ b/crates/horizon-client/src/item_tooltip.rs @@ -486,10 +486,28 @@ pub fn lines( translate: &dyn Fn(&str) -> Option, ) -> Vec { let mut lines = vec![name_line(stack, translate)]; + if TooltipDisplay::for_stack(stack).shows("minecraft:lore") { + lines.extend(lore_lines(stack)); + } lines.extend(detail_lines(stack, info, translate)); lines } +/// `LoreComponent.addToTooltip`: the saved component lines, as plain text. +fn lore_lines(stack: &ItemStack) -> Vec { + let Some(Tag::List(entries)) = stack.data().and_then(|d| d.other("minecraft:lore")) else { + return Vec::new(); + }; + entries + .iter() + .map(|entry| { + let json = crate::scoreboard::tag_to_json(entry); + let text = crate::component::to_text(&json, &mut |s| crate::text::Text::literal(s)); + text.plain() + }) + .collect() +} + #[cfg(test)] mod tests { use super::*; From 9f6d78178298609dd636725c891d72e591c592bd Mon Sep 17 00:00:00 2001 From: itspotatotime Date: Thu, 22 Oct 2026 13:33:58 +0300 Subject: [PATCH 29/59] fix(client): read empty-root component names through their extra spans Co-Authored-By: cairn-code (GLM-5.3-Flash Free) --- crates/horizon-client/src/item_data.rs | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs index 2ba8d39a9..1376dde98 100644 --- a/crates/horizon-client/src/item_data.rs +++ b/crates/horizon-client/src/item_data.rs @@ -302,7 +302,10 @@ fn filterable_text(t: &Tag) -> Option { fn read_text(t: &Tag) -> Option { match t { Tag::String(s) => Some(s.to_string_lossy()), - Tag::Compound(_) => t.get("text").and_then(string), + // A component's root `text` may be empty with the visible words in + // `extra` (every legacy display name ViaVersion produces looks like + // this), so flatten the whole component instead of reading one key. + Tag::Compound(_) => Some(crate::entity_nbt::name_text(t).plain()), _ => None, } } @@ -860,6 +863,26 @@ mod tests { assert_eq!(back.custom_name(), Some("Blade")); } + #[test] + fn custom_name_reads_the_extra_spans() { + let name = Tag::compound([ + ( + "extra", + Tag::List(vec![ + Tag::compound([("text", Tag::String("Games ".into()))]), + Tag::compound([("text", Tag::String("Right click".into()))]), + ]), + ), + ("text", Tag::String("".into())), + ]); + let components = Tag::compound([("minecraft:custom_name", name)]); + let (_, extra) = decode_components(Some(&components)); + assert_eq!( + extra.and_then(|d| d.custom_name.clone()).as_deref(), + Some("Games Right click") + ); + } + #[test] fn banner_layers_and_shield_base_round_trip() { let mut stack = ItemStack::new("minecraft:shield", 1); From ad676af5eb05ff4bc420aca53378dd1b1bd650c4 Mon Sep 17 00:00:00 2001 From: itspotatotime Date: Thu, 22 Oct 2026 17:04:38 +0300 Subject: [PATCH 30/59] fix(protocol): decode particle entity-data serializers so later slots survive Serializer 17 (particles) and 16 hit a catch-all that returned Ok(None), which stopped EntityData::read from walking the rest of the metadata list. On armor stands that carry a level-particle effect slot, slots 2 and 3 (CustomName text and visible flag) were silently discarded, so serverside holograms (Gamster's social-media panels and leaderboards) rendered as nothing. Implement both serializers as value-preserving decodes: a ParticleData enum covering every 26.3 particle shape (state varints for ids 1/2/36/121/125, colours, dust, dust_color_transition, effect/instant, scalar, shriek, trail, item, vibration and geyser variants) backed by a static minecraft:particle_type id table, with write_value arms for round-trips. Co-Authored-By: cairn-code (GLM-5.3-Flash Free) --- crates/horizon-protocol/src/entity_data.rs | 169 ++++++++++++++++++++- 1 file changed, 167 insertions(+), 2 deletions(-) diff --git a/crates/horizon-protocol/src/entity_data.rs b/crates/horizon-protocol/src/entity_data.rs index d0e977568..4c6879362 100644 --- a/crates/horizon-protocol/src/entity_data.rs +++ b/crates/horizon-protocol/src/entity_data.rs @@ -28,6 +28,51 @@ pub enum Value { Id(i32), /// Several VarInts (VillagerData). Ids(Vec), + /// A particle choice: the `minecraft:particle_type` id plus its data. + /// Rendered nowhere (the client spawns no world particles yet); decoded + /// so the rest of an entry list survives a particle slot. + Particle(Particle), +} +/// The optional data of one particle type (26.3 registry order). +#[derive(Clone, Debug, PartialEq)] +pub struct Particle { + pub id: i32, + pub data: Option, +} +#[derive(Clone, Debug, PartialEq)] +pub enum ParticleData { + /// Block state id (block, block_marker, falling_dust, dust_pillar, + /// block_crumble). + State(i32), + /// Geometry-wide or ARGB color (effect, entity_effect, tinted_leaves, + /// flash); flame family colors keep the top bits in one Int. + Color(#[allow(dead_code)] i32), + /// Dust family: color then scale. + ColorScale(i32, f32), + /// Dust color transition: from color, to color, scale. + ColorScale2(i32, i32, f32), + /// Effect family: color then power. + ColorPower(i32, f32), + /// A bare float (dragon_breath power, sculk_charge roll). + Scalar(f32), + /// Delay in ticks (shriek). + Delay(i32), + /// A position plus ticks (trail): 3 doubles, ARGB color, duration. + Trail([f64; 3], i32, i32), + /// An item stack (item). + Item(Option), + /// One generic Int (geyser water blocks) or Int then Float + /// (geyser_base, geyser_poof); plus the tick count of a vibration. + Ints(Vec), + /// Side effect: which registered particle carries which data shape. + Vibration { + #[allow(dead_code)] + source: i32, + #[allow(dead_code)] + eye: Option, + #[allow(dead_code)] + ticks: i32, + }, } /// Serializer ids in EntityDataSerializers registration order. pub mod serializer { @@ -113,6 +158,64 @@ fn read_value(kind: i32, r: &mut Reader) -> Result> { | PAINTING_VARIANT..=WEATHERING_COPPER_STATE | HUMANOID_ARM | DYE_COLOR => Value::Id(r.varint()?), + PARTICLE | PARTICLES => { + let id = r.varint()?; + // `minecraft:particle_type` registry order as of 26.3. + let data = match id { + 1 | 2 | 36 | 121 | 125 => Some(ParticleData::State(r.varint()?)), + 28 | 46 | 52 => Some(ParticleData::Color(r.i32()?)), + 21 => { + let color = r.i32()?; + let scale = r.f32()?; + Some(ParticleData::ColorScale(color, scale)) + } + 22 => { + let from = r.i32()?; + let to = r.i32()?; + let scale = r.f32()?; + Some(ParticleData::ColorScale2(from, to, scale)) + } + 23 | 56 => { + let color = r.i32()?; + let power = r.f32()?; + Some(ParticleData::ColorPower(color, power)) + } + 15 | 48 => Some(ParticleData::Scalar(r.f32()?)), + 115 => Some(ParticleData::Delay(r.varint()?)), + 59 => { + let x = r.f64()?; + let y = r.f64()?; + let z = r.f64()?; + let color = r.i32()?; + let duration = r.varint()?; + Some(ParticleData::Trail([x, y, z], color, duration)) + } + 57 => Some(ParticleData::Item(Slot::read(r)?)), + 58 => { + let source = r.varint()?; + let mut eye = None; + if source == 0 { + let _ = crate::buf::Pos::read(r)?; + } else { + let _ = r.varint()?; + eye = Some(r.f32()?); + } + let ticks = r.varint()?; + Some(ParticleData::Vibration { source, eye, ticks }) + } + 7..=10 => { + let mut ints = vec![r.i32()? as f32]; + if id == 8 || id == 9 { + ints.push(r.f32()?); + } + Some(ParticleData::Ints(ints)) + } + // Every other registered particle carries no data. + _ => None, + }; + // Not into Ok(Some(..)): the match arm is inside the outer Option. + Value::Particle(Particle { id, data }) + } _ => return Ok(None), })) } @@ -147,6 +250,53 @@ fn write_value(kind: i32, v: &Value, w: &mut Writer) { w.uuid(*u); } } + Value::Particle(p) => { + w.varint(p.id); + if let Some(data) = &p.data { + match data { + ParticleData::State(s) => w.varint(*s), + ParticleData::Color(c) => w.i32(*c), + ParticleData::ColorScale(c, s) => { + w.i32(*c); + w.f32(*s); + } + ParticleData::ColorScale2(a, b, s) => { + w.i32(*a); + w.i32(*b); + w.f32(*s); + } + ParticleData::ColorPower(c, p) => { + w.i32(*c); + w.f32(*p); + } + ParticleData::Scalar(f) => w.f32(*f), + ParticleData::Delay(d) => w.varint(*d), + ParticleData::Trail(at, c, d) => { + at.iter().for_each(|v| w.f64(*v)); + w.i32(*c); + w.varint(*d); + } + ParticleData::Item(s) => Slot::write(s, w), + ParticleData::Ints(ints) => { + let mut iter = ints.iter(); + if let Some(v) = iter.next() { + w.i32(*v as i32); + } + for v in iter { + w.f32(*v); + } + } + ParticleData::Vibration { source, eye, ticks } => { + w.varint(*source); + let _ = source; + if let Some(eye) = eye { + w.f32(*eye); + } + w.varint(*ticks); + } + } + } + } } let _ = kind; } @@ -208,10 +358,25 @@ mod tests { EntityData::read(&mut Reader::new(&w.data)).unwrap(), entries ); - // A particle (16) cannot be skipped: keep what came before. - let mut bytes = vec![0, 0, 7, 9, 16, 1, 2, 3]; + // Serializer 200 is unknown: the list stops there, earlier entries kept. + let mut bytes = vec![0, 0, 7, 9, 200, 1, 2, 3]; bytes.push(0xFF); let read = EntityData::read(&mut Reader::new(&bytes)).unwrap(); assert_eq!(read, vec![(0, 0, Value::Byte(7))]); + // A block particle decodes fully and round-trips. + let entries = vec![( + 10u8, + serializer::PARTICLE, + Value::Particle(Particle { + id: 1, + data: Some(ParticleData::State(2)), + }), + )]; + let mut w = Writer::new(); + EntityData::write(&entries, &mut w); + assert_eq!( + EntityData::read(&mut Reader::new(&w.data)).unwrap(), + entries + ); } } From 92d2e2b86daee54096cde44bc404c528e5e7af77 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:20:42 +0200 Subject: [PATCH 31/59] launcher: leave Java alone when the preparer finds one itself With a JDK installed, the launcher passed the preparation the home of the JDK horizon-prepare finds (javac/../..) as JAVA_HOME and on the PATH. Found through the PATH, that is often a stub: on macOS /usr/bin/javac gives JAVA_HOME=/usr, and `JAVA_HOME=/usr /usr/bin/javac -version` never returns (the stub calls itself), so the preparer subprocess hung on a Mac with Temurin installed. When horizon-prepare finds a JDK by itself, run the preparation as before, in an unchanged environment; only Minecraft's own Java (the official launcher's, or one downloaded from Mojang) is passed on. Also skip the Mojang download on x86-64 Linux without glibc's loader (NixOS without nix-ld, musl distributions): Mojang's Java can't start there, so say so instead of downloading 115 MB first. And keep each runtime home once (dedup only dropped neighbours). Co-Authored-By: Claude Opus 5.5 --- launcher/src/backend.rs | 59 ++++++++++++++++++++++++++++------------- 1 file changed, 40 insertions(+), 19 deletions(-) diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index 7fce7ce07..51ee81c5c 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -993,31 +993,45 @@ fn download_for_owner( } } -/// The home of a JDK of at least `major`: one horizon-prepare finds (JAVA_HOME, the PATH, an -/// installed JDK) or the Java the official launcher downloaded into one of the `games` -/// folders, else Minecraft's own Java downloaded from Mojang into Horizon's game folder, the -/// runtime the version JSON at `manifest` names (Mojang's runtimes are whole JDKs). +/// A JDK of at least `major` for the preparation. `None` when horizon-prepare finds one by +/// itself (JAVA_HOME, the PATH, an installed JDK): the preparation then runs as before, in an +/// unchanged environment (a JDK found on the PATH can be a stub such as macOS's +/// /usr/bin/javac, whose folder is no Java home: `JAVA_HOME=/usr` makes it call itself +/// forever). Else the home of the Java the official launcher downloaded into one of the +/// `games` folders, else of Minecraft's own Java downloaded from Mojang into Horizon's game +/// folder, the runtime the version JSON at `manifest` names (Mojang's runtimes are whole JDKs). fn java( major: i64, games: &[PathBuf], manifest: &Path, log: &dyn Fn(String), -) -> Result { - let runtimes = || -> Vec { - let mut homes: Vec = games - .iter() - .flat_map(|game| horizon_prepare::java::minecraft_runtimes(&game.join("runtime"))) - .collect(); - homes.dedup(); - homes - }; - let missing = match horizon_prepare::java::find(major, &runtimes()) { - Ok(jdk) => return Ok(jdk.home()), +) -> Result, String> { + if horizon_prepare::java::find(major, &[]).is_ok() { + return Ok(None); + } + let mut runtimes: Vec = Vec::new(); + for home in games + .iter() + .flat_map(|game| horizon_prepare::java::minecraft_runtimes(&game.join("runtime"))) + { + if !runtimes.contains(&home) { + runtimes.push(home); + } + } + let missing = match horizon_prepare::java::find(major, &runtimes) { + Ok(jdk) => return Ok(Some(jdk.home())), Err(e) => e, }; let component = read_json(manifest) .and_then(|json| json["javaVersion"]["component"].as_str().map(String::from)) .ok_or_else(|| missing.clone())?; + // Mojang builds its Linux Java for glibc: without glibc's loader (NixOS without nix-ld, + // musl distributions) it cannot start, so don't download it. + if cfg!(all(target_os = "linux", target_arch = "x86_64")) && !Path::new(GLIBC_LOADER).exists() { + return Err(format!( + "{missing}\n • Minecraft's own Java from Mojang needs glibc ({GLIBC_LOADER} is missing; on NixOS, enable programs.nix-ld), so install a JDK instead." + )); + } let fetch = |url: &str| -> Result, String> { let mut body = Vec::new(); get(url)? @@ -1030,9 +1044,12 @@ fn java( let home = mojang::java_runtime(&component, &runtime, 8, &fetch, log).map_err(|e| { format!("{missing}\n • Horizon also tried to download Minecraft's own Java from Mojang, but: {e}") })?; - horizon_prepare::java::find(major, &[home]).map(|jdk| jdk.home()) + horizon_prepare::java::find(major, &[home]).map(|jdk| Some(jdk.home())) } +/// The dynamic loader glibc programs on x86-64 Linux start through. +const GLIBC_LOADER: &str = "/lib64/ld-linux-x86-64.so.2"; + /// Runs `cmd` with the JDK at `home`: JAVA_HOME names it and its `bin` leads the PATH, as the /// versions' own preparers look for Java. fn with_java(cmd: &mut Command, home: &Path) { @@ -1150,12 +1167,14 @@ pub fn preparer( import: !reused, minecraft_dir: Some(minecraft.clone()), server_jar: (!reused).then_some(jar), - java_home: Some(java_home), + java_home: java_home.clone(), }; return Ok((Preparer::InProcess(options), minecraft)); } let mut cmd = Command::new(binary); - with_java(&mut cmd, &java_home); + if let Some(home) = &java_home { + with_java(&mut cmd, home); + } cmd.current_dir(&dir).arg("--root").arg(&dir); if !reused { cmd.args(["--prepare", "--server-jar"]).arg(&jar); @@ -1164,7 +1183,9 @@ pub fn preparer( return Ok((Preparer::Process(cmd), minecraft)); } let mut cmd = Command::new(python.unwrap()); - with_java(&mut cmd, &java_home); + if let Some(home) = &java_home { + with_java(&mut cmd, home); + } cmd.current_dir(&dir) .args(["-u", "tools/prepare_native_client.py"]); if !reused { From 41e6c3eca39afb2794eb7d30cb73c45151f425a1 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:23:59 +0200 Subject: [PATCH 32/59] release-flow: #releases shows every Nightly silently, pings only for Stable Co-Authored-By: Claude Opus 5.5 --- docs/release-flow.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/docs/release-flow.md b/docs/release-flow.md index 52a9d5596..45365e341 100644 --- a/docs/release-flow.md +++ b/docs/release-flow.md @@ -180,8 +180,10 @@ runs the game: GitHub's runners have neither a GPU worth the name nor the game f - `### Known issues`: the bullets of [docs/known-issues.md](known-issues.md); - thanks to outside contributors, how to install, the disclaimer. -Kira posts every published release in #releases and pings the releases role only when the notes have a -`### New` section. +Kira posts every release in Discord's #releases. A Nightly (a game pre-release) is posted silently: no ping and +Discord's @silent flag, so nobody gets a notification. When the same release becomes Stable it is posted again, and +that post pings the releases role when the notes have a `### New` section (at most once every 6 hours). Launcher +releases post without a ping. ### Channels @@ -193,8 +195,8 @@ Every game release is published as a **beta**, a GitHub pre-release, so GitHub's - **Nightly**: every beta as soon as it is built, many times a day; it can break. "Nightly" is a name, not a schedule. An open launcher looks for releases every 30 minutes on Nightly (4 hours on Stable). Launchers from before 0.2 had a "Beta builds" switch instead; on, it reads as Nightly. -`horizon-server update` installs stable builds (`--version ` takes one by name), and Kira announces a release -when it becomes stable: Discord's #releases only ever shows stable ones. +`horizon-server update` installs stable builds (`--version ` takes one by name). In Discord's #releases every +Nightly is posted silently and only Stable posts notify (above). `.github/workflows/promote.yml` runs `tools/release_channels.py promote` once a day at 20:00 UTC (21:00 in Paris in winter time, 22:00 in summer), with retries until 21:37 for a run GitHub starts late or skips. It promotes the newest From fe5e20507a4df6ef22f4a9f2dbf4ed6ee723e439 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:29:58 +0200 Subject: [PATCH 33/59] Website: docs match what ships (Mods page, shader packs page, dynamic lights, LAN workstations); the live ping is off The Mods page (launcher 0.17) replaces "a mod browser is planned"; the Horizon shader format is no longer called planned; Nightly-only things say Nightly. The "I'm playing" ping has no server (DEFAULT_ENDPOINT is None), so the FAQ and the privacy page say it is off instead of sent. The channel switch says it needs the launcher release after 0.17. The README says what deploys the site. Co-Authored-By: Claude Sonnet 5.5 --- website/README.md | 2 +- website/docs/faq.md | 2 +- website/docs/index.md | 2 +- website/docs/install.md | 2 ++ website/docs/modpacks.md | 2 +- website/docs/mods.md | 8 +++++++- website/docs/multiplayer.md | 2 ++ website/docs/settings.md | 8 ++++++-- website/docs/troubleshooting.md | 2 +- website/src/index.html | 3 ++- website/src/privacy.html | 14 +++++++------- 11 files changed, 31 insertions(+), 16 deletions(-) diff --git a/website/README.md b/website/README.md index 76d8ecaf0..b5a3ac51d 100644 --- a/website/README.md +++ b/website/README.md @@ -84,7 +84,7 @@ and characters per line, for 360 to 1920 px wide and a 1250×700 window. ## Railway -The service deploys the `website` branch and answers on https://playhorizon.dev. Its +The service deploys `main` (Railway's GitHub integration; there is no `website` branch any more) when `/website/**`, `README.md` or `launcher/links.json` change, and answers on https://playhorizon.dev. Its `*.up.railway.app` address redirects there with a 301 (the Caddyfile), so search engines index one URL; the page also names it as canonical, in its Open Graph tags and in `sitemap.xml`. Railway's healthcheck reaches `$PORT` under its own host name and is served normally. diff --git a/website/docs/faq.md b/website/docs/faq.md index bb810a42f..ee353a0c6 100644 --- a/website/docs/faq.md +++ b/website/docs/faq.md @@ -56,7 +56,7 @@ In part. Horizon runs the full-screen effects of Java shader packs, not their ge ## Does Horizon collect data? -Only if you say yes, and each kind has its own switch. Everything is off by default. The one thing sent without asking is an anonymous "I'm playing" ping, for the count of how many play right now: it holds a random number made each time the game starts, the version, your OS and whether a world is open to LAN, and nothing about you. See [Privacy](/privacy). +Only if you say yes, and each kind has its own switch. Everything is off by default. The game has an anonymous "I'm playing" ping for a live player count, but it is off today: no server receives it yet, so the game sends nothing. See [Privacy](/privacy). ## How often does it update? diff --git a/website/docs/index.md b/website/docs/index.md index 4e84a6591..1d3516836 100644 --- a/website/docs/index.md +++ b/website/docs/index.md @@ -7,7 +7,7 @@ Horizon is Minecraft: Java Edition 26.3 rewritten in Rust. You install it with a - **A new game program, not a mod.** Horizon is written from scratch in Rust. It reads the same worlds, plays by the same rules and generates the same terrain as the Java game. - **Checked against vanilla.** {{HARNESSES}} automated tests ("harnesses") feed the same inputs to Horizon and to the real game, then compare the results. Today every subsystem matches in every harness that compares it. That is {{PERCENT}} of what the harnesses compare, which is not proof that nothing else differs. The [status table](/#parity) lists what is covered. - **Light and fast.** It starts quickly, uses little memory and draws efficiently. See [Performance](/docs/performance) for what is measured and what is not. -- **A few things vanilla doesn't have.** Its own menus (vanilla's are one setting away), graphics presets, distant terrain, controller support, optional extras such as zoom and a minimap, and a server you can run without Java. +- **A few things vanilla doesn't have.** Its own menus (vanilla's are one setting away), graphics presets, distant terrain, controller support, optional extras such as zoom, a minimap and dynamic lights (dynamic lights are in Nightly builds for now), an invite code to play your world with friends, and a server you can run without Java. ## What Horizon is not diff --git a/website/docs/install.md b/website/docs/install.md index b898d79de..56ea15554 100644 --- a/website/docs/install.md +++ b/website/docs/install.md @@ -39,6 +39,8 @@ The game opens on Horizon's own title screen. Your worlds, options and logs live ## Stable and Nightly +> **Next launcher release.** The Updates switch below is merged but not in a launcher release yet. Launcher 0.17 has a **Beta builds** switch in Settings instead, which installs every new build at once, as Nightly does. + In **Settings**, **Updates** picks which builds install by themselves: - **Stable** (the default): a tested build about once a day. diff --git a/website/docs/modpacks.md b/website/docs/modpacks.md index 14455f1a4..a4396392b 100644 --- a/website/docs/modpacks.md +++ b/website/docs/modpacks.md @@ -8,7 +8,7 @@ Java mod jars do not run in Horizon. Instead, the launcher reads a modpack, tell Open **Modpacks** in the launcher. -1. **Import a pack.** Choose **Import a pack file…** for a Modrinth `.mrpack` or a CurseForge zip, or **Import an instance folder…** for a Prism, MultiMC or CurseForge instance. +1. **Import a pack.** Choose **Import a pack file…** for a Modrinth `.mrpack` or a CurseForge zip, or **Import an instance folder…** for a Prism, MultiMC or CurseForge instance. The **Mods** page can also find a Modrinth modpack and import it for you (see [Mods and data packs](/docs/mods#finding-resource-packs-shader-packs-and-modpacks)). 2. **Read the coverage report.** For every mod in the pack it says **Ported**, **Partial**, **Not yet** or **Not needed**, with the reason. You can filter the list by status. 3. **Port.** **Port N mods** gets the jars of the mods this computer can carry over today, and carries them over for the version you picked. It copies the jars from a folder you have, or downloads them from the pack's own links (or the same file from Modrinth's download network), and checks their hashes. Files that only CurseForge has need CurseForge's API key, so for those choose **Use jars from my instance…** and point it at your installed instance. 4. **Play.** **Play with N mods** starts the game as the pack's own profile, with its own saves and options, and those mods on. diff --git a/website/docs/mods.md b/website/docs/mods.md index 3e2721058..05dcaee2d 100644 --- a/website/docs/mods.md +++ b/website/docs/mods.md @@ -6,7 +6,7 @@ Horizon has its own mod system, written for Horizon and not compatible with Java Horizon mods are written in Rust, compiled to WebAssembly and run in a sandbox. A mod can only do what it asks for and you allow, and a mod that crashes is switched off without taking the game down. -> **Early.** The mod system is new. There is no mod store yet, and a mod browser in the launcher is planned. Mods you find are files to put in a folder. +> **Early.** The mod system is new. There is no store for Horizon mods yet: they are files to put in a folder. The launcher's **Mods** page (see below) finds resource packs, shader packs and modpacks, not `.hmod` mods. **Playing with mods** @@ -32,6 +32,12 @@ cargo horizon-mod run `run` builds the mod and starts the game with it. After an edit, `cargo horizon-mod build` rebuilds it and the running game reloads it. The full guide, with the API, the manifest and the roadmap, is [docs/mods.md](https://github.com/ludovic111/horizon/blob/main/docs/mods.md). What carries over from Java mods, and why jars cannot run, is in [the Java mod notes](https://github.com/ludovic111/horizon/blob/main/docs/research/java-mod-compat.md). +## Finding resource packs, shader packs and modpacks + +The launcher's **Mods** page (launcher 0.17 and newer) searches [Modrinth](https://modrinth.com) for what Horizon can load: resource packs, Java shader packs and modpacks. Each result says how well it runs in Horizon (**Works**, **Partly**, or **Doesn't run**), and by default the page shows only what runs. **Install** downloads the file, checks it against the checksum Modrinth lists and refuses anything that does not match, then puts it in the right folder, with the packs it needs. **Update** and **Remove** are there too. A resource pack still has to be turned on in the game's Resource Packs screen, and a shader pack in Video, Shader Packs. A modpack is imported on the [Modpacks page](/docs/modpacks). + +The page cannot search CurseForge yet. Java mod jars are never offered, because they do not run. The same things work from a terminal: `horizon-launcher mods search`, `install`, `update` and `remove`. + ## Data packs A world's data packs go in its `datapacks` folder, as folders or `.zip` files with a `pack.mcmeta`, as in vanilla. diff --git a/website/docs/multiplayer.md b/website/docs/multiplayer.md index 71e3f36cd..e33b01084 100644 --- a/website/docs/multiplayer.md +++ b/website/docs/multiplayer.md @@ -20,6 +20,8 @@ There is no Horizon server in the middle. The code holds the host's addresses an Guests join with the name their game uses. There is no account check, so only share the code with people you trust. +In Nightly builds, guests can also use the host's workstations: the crafter, loom, stonecutter, grindstone, anvil, smithing table, enchanting table, beacon, lectern and cartography table. Stable gets this once it has passed. + ## Open to LAN As in vanilla, **Open to LAN** in the pause menu lets people on the same network join your world. They see it in their server list. A vanilla 26.3 client can join a Horizon LAN world, and Horizon can join a vanilla one. LAN worlds are in offline mode. diff --git a/website/docs/settings.md b/website/docs/settings.md index 24d055d26..c01b99e74 100644 --- a/website/docs/settings.md +++ b/website/docs/settings.md @@ -46,12 +46,16 @@ The change applies at the next start. If Vulkan gives you trouble, try DirectX 1 Shader packs are **experimental**. Put a pack's folder in the `shaderpacks` folder of the game folder (see [Install](/docs/install#first-launch) for where that is), then choose it in **Options, Video, Shader Packs**. With no pack selected the game draws exactly what vanilla draws. A pack that fails to load shows why in red and leaves the normal picture on. -Horizon can run the full-screen effects of Java shader packs (OptiFine and Iris packs: colour grading, bloom, sky and fog effects). It does not run their geometry and shadow passes yet, so packs do not look as they do in Iris. Horizon's own shader format, in WGSL with hot reload, is planned. The details are in the [shader pack notes](https://github.com/ludovic111/horizon/blob/main/docs/shader-packs.md). +Horizon can run the full-screen effects of Java shader packs (OptiFine and Iris packs: colour grading, bloom, sky and fog effects). It does not run their geometry and shadow passes yet, so packs do not look as they do in Iris. Horizon also has its own shader pack format, in WGSL, with a `pack.toml` manifest, options and hot reload. It has full-screen passes too; stages that draw the world's terrain and shadows are planned. The details are in the [shader pack notes](https://github.com/ludovic111/horizon/blob/main/docs/shader-packs.md). + +In Nightly builds, the **Shader Packs** page shows the full path of the `shaderpacks` folder with an **Open Folder** button, then one switch per pack. Turning a pack on picks it, and turning it off gives the vanilla picture. Packs tested so far: BSL, Complementary Reimagined, Steadfast and Sildur's Vibrant Extreme draw their full-screen passes; Bliss, Bloop, Noble, Photon and Rethinking Voxels do not load yet. To find packs, the launcher's **Mods** page installs shader packs from Modrinth (see [Mods and data packs](/docs/mods#finding-resource-packs-shader-packs-and-modpacks)). ## Resource packs Java Edition resource packs work. Put the folder or `.zip` in the `resourcepacks` folder of the game folder and pick it on the **Resource Packs** screen, which is vanilla's screen. The game reloads every loader from the pack, as vanilla does. +The launcher's **Mods** page can download them from Modrinth (see [Mods and data packs](/docs/mods#finding-resource-packs-shader-packs-and-modpacks)). + [Resource packs: what works](https://github.com/ludovic111/horizon/blob/main/docs/resource-packs.md) lists everything a 26.3 resource pack can change and whether Horizon honours it. ## Controllers @@ -65,7 +69,7 @@ Horizon plays with PlayStation (DualShock 4 and DualSense), Xbox (360, One and S ## Extras -**Options, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, zoom, a minimap, an FPS counter, a keystroke display, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. +**Options, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, zoom, a minimap, an FPS counter, a keystroke display, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. In Nightly builds there is one more, **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. ## Where your settings are stored diff --git a/website/docs/troubleshooting.md b/website/docs/troubleshooting.md index b7dac8fe4..47c42d806 100644 --- a/website/docs/troubleshooting.md +++ b/website/docs/troubleshooting.md @@ -52,4 +52,4 @@ A Horizon bug is any place where it differs from vanilla 26.3, so "vanilla does ## Data the launcher can send -The launcher can send performance statistics, crash reports, bug reports and benchmarks, but only the kinds you allow, and everything is off until you say yes. The game also sends an anonymous "I'm playing" ping while it runs, for the live player count. See [Privacy](/privacy) for what is sent, how long it is kept and how to delete it. +The launcher can send performance statistics, crash reports, bug reports and benchmarks, but only the kinds you allow, and everything is off until you say yes. See [Privacy](/privacy) for what is sent, how long it is kept and how to delete it. diff --git a/website/src/index.html b/website/src/index.html index 7668951a7..270128d91 100644 --- a/website/src/index.html +++ b/website/src/index.html @@ -165,8 +165,9 @@
  • One-click install

    Pick a release and it installs the build for your platform into its own folder, then prepares the resources from your Java Edition 26.3 install.

  • Updates on its own

    It looks for a new Horizon release when it starts and every four hours, and updates itself from the launcher's own releases.

  • -
  • Client or server

    Start the client, or a dedicated server in a folder you choose, with a live console.

  • +
  • Client or server

    Start the client, or host a server from the Servers page: create it, start it, watch players and the console, change its settings and keep backups.

  • Your choice of menus

    Play with Horizon's own menus, shown here, or vanilla's classic screens.

  • +
  • Modpacks and packs

    The Modpacks page reads a Modrinth or CurseForge pack and carries over the mods Horizon can run. The Mods page installs resource packs, shader packs and modpacks from Modrinth.

Download the launcher diff --git a/website/src/privacy.html b/website/src/privacy.html index c6fa0610e..def61dcc9 100644 --- a/website/src/privacy.html +++ b/website/src/privacy.html @@ -17,8 +17,8 @@

PrivacyData collection

-

Nothing about you leaves without your yes.

-

The Horizon launcher can send a few things that help make the game faster and steadier. It asks first, each kind has its own switch, and every switch is off until you turn it on. The only thing sent without asking is an anonymous "I'm playing" ping, which says nothing about you.

+

Nothing leaves without your yes.

+

The Horizon launcher can send a few things that help make the game faster and steadier. It asks first, each kind has its own switch, and every switch is off until you turn it on.

What can be sent

Only the kinds you allow, from the launcher's first-run question or Settings → Data collection:

@@ -33,15 +33,15 @@

The launcher shows exactly what would be sent: Settings → Data collection → View what would be sent, or horizon-launcher data show. Every field is listed in docs/telemetry.md.

The "I'm playing" ping

-

While you play, the game sends an anonymous "I'm playing" ping once a minute, so the launcher can show how many people play Horizon right now. It is sent whatever the switches say, and the launcher says so next to them.

-

It holds: a random number made when the game starts and forgotten when it closes, the Horizon version, your operating system (Linux, macOS or Windows), and whether you have a world open to LAN or to friends. It doesn't hold: your account, your install ID, world or server names, your hardware or settings, or anything you do in the game. The random number changes every time you start the game, so two of your sessions can't be linked to each other or to you.

-

The server keeps the pings in memory only, never on disk, and not with the address they came from (that is used only to stop abuse, as below). A session counts while it pinged in the last two minutes and is then forgotten. What it shows is the number playing now, per version and with a world open, rounded.

+

The game has an anonymous "I'm playing" ping, so the launcher can show how many people play Horizon right now. It is off today: no server receives it yet, so the game sends nothing. This is what it would hold, so you know before it is ever switched on. It would be sent once a minute while you play, whatever the switches say.

+

It would hold: a random number made when the game starts and forgotten when it closes, the Horizon version, your operating system (Linux, macOS or Windows), and whether you have a world open to LAN or to friends. It would not hold: your account, your install ID, world or server names, your hardware or settings, or anything you do in the game. The random number changes every time you start the game, so two of your sessions can't be linked to each other or to you.

+

The server would keep the pings in memory only, never on disk, and not with the address they came from (that is used only to stop abuse, as below). A session would count while it pinged in the last two minutes and is then forgotten. What it would show is the number playing now, per version and with a world open, rounded.

Why

-

To find what is slow or crashes on which machines, and fix it. The ping shows players, and Horizon, how many people play right now. Benchmark uploads also show other players how Horizon runs on hardware like theirs. Nothing is sold, shared for advertising, or used to identify you.

+

To find what is slow or crashes on which machines, and fix it. If it is switched on, the ping shows players, and Horizon, how many people play right now. Benchmark uploads also show other players how Horizon runs on hardware like theirs. Nothing is sold, shared for advertising, or used to identify you.

On what basis

-

For the switches: your consent (Article 6(1)(a) of the EU's General Data Protection Regulation). It is given kind by kind, recorded on your computer with the version of the question you answered and when, and withdrawn at any time with the same switches. Withdrawing deletes what was waiting to be sent. When what is collected changes, the launcher asks again, and nothing new is sent until you answer. The ping holds nothing that identifies you; the address it comes from is used only to limit how often one address may send, kept in memory for an hour at most and never stored.

+

For the switches: your consent (Article 6(1)(a) of the EU's General Data Protection Regulation). It is given kind by kind, recorded on your computer with the version of the question you answered and when, and withdrawn at any time with the same switches. Withdrawing deletes what was waiting to be sent. When what is collected changes, the launcher asks again, and nothing new is sent until you answer. The ping would hold nothing that identifies you; the address it comes from would be used only to limit how often one address may send, kept in memory for an hour at most and never stored.

Where and how long

Items wait on your computer (telemetry/ in the game folder) and are sent compressed when the launcher starts or closes, to Horizon's own server at Railway. The server keeps them for 180 days, then deletes them. What stays after that are anonymous totals per day, Horizon version, operating system, GPU maker and render distance (for example "120 sessions on macOS with Apple GPUs at render distance 12"). They hold no install ID, and groups too small to be anonymous are never shown.

From 97edfec91491825e44c10d8bb754347b95daa146 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:46:39 +0100 Subject: [PATCH 34/59] perf: reuse decoded aquifer neighborhoods during terrain fill --- .../src/worldgen/aquifer/noise_based.rs | 106 +++++++++++------- docs/aquifer-cache-benchmark.md | 56 +++++++++ 2 files changed, 124 insertions(+), 38 deletions(-) create mode 100644 docs/aquifer-cache-benchmark.md diff --git a/crates/horizon-world/src/worldgen/aquifer/noise_based.rs b/crates/horizon-world/src/worldgen/aquifer/noise_based.rs index 30181686b..3f3c7dc2c 100644 --- a/crates/horizon-world/src/worldgen/aquifer/noise_based.rs +++ b/crates/horizon-world/src/worldgen/aquifer/noise_based.rs @@ -120,6 +120,7 @@ pub struct NoiseBasedAquifer { statuses: Vec>, locations: Vec, surfaces: HashMap, + neighborhood: Option<([i32; 3], [(usize, BlockPos); 12])>, skip_above_y: i32, schedule: bool, } @@ -180,6 +181,7 @@ impl NoiseBasedAquif statuses, locations, surfaces: HashMap::new(), + neighborhood: None, skip_above_y: 0, schedule: false, }; @@ -479,48 +481,76 @@ impl NoiseBasedAquif y.wrapping_add(1).div_euclid(12), z.wrapping_sub(5) >> 4, ]; - let mut distances = [i32::MAX; 4]; - let mut indices = [0usize; 4]; - for dx in 0..=1i32 { - for dy in -1..=1i32 { - for dz in 0..=1i32 { - let cell = [ - grid[0].wrapping_add(dx), - grid[1].wrapping_add(dy), - grid[2].wrapping_add(dz), - ]; - let index = self.grid_index(cell)?; - if self.locations[index] == i64::MAX { - let mut random = self.random.at(BlockPos::new(cell[0], cell[1], cell[2])); - let px = cell[0] - .wrapping_shl(4) - .wrapping_add(random.next_int_bound(10).expect("positive bound")); - let py = cell[1] - .wrapping_mul(12) - .wrapping_add(random.next_int_bound(9).expect("positive bound")); - let pz = cell[2] - .wrapping_shl(4) - .wrapping_add(random.next_int_bound(10).expect("positive bound")); - self.locations[index] = BlockPos::new(px, py, pz).pack(); - } - let point = BlockPos::unpack(self.locations[index]); - let ax = point.x.wrapping_sub(x); - let ay = point.y.wrapping_sub(y); - let az = point.z.wrapping_sub(z); - let distance = ax - .wrapping_mul(ax) - .wrapping_add(ay.wrapping_mul(ay)) - .wrapping_add(az.wrapping_mul(az)); - if let Some(slot) = distances.iter().position(|old| distance <= *old) { - for i in (slot + 1..4).rev() { - distances[i] = distances[i - 1]; - indices[i] = indices[i - 1]; + // Fill in the original cell order, publishing only after checked traversal + // succeeds. Failed traversal keeps the last complete neighborhood. + if self.neighborhood.as_ref().map(|(key, _)| *key) != Some(grid) { + let mut entries = [(0, BlockPos::default()); 12]; + let mut next = 0; + for dx in 0..=1i32 { + for dy in -1..=1i32 { + for dz in 0..=1i32 { + let cell = [ + grid[0].wrapping_add(dx), + grid[1].wrapping_add(dy), + grid[2].wrapping_add(dz), + ]; + let index = self.grid_index(cell)?; + if self.locations[index] == i64::MAX { + let mut random = + self.random.at(BlockPos::new(cell[0], cell[1], cell[2])); + let px = cell[0] + .wrapping_shl(4) + .wrapping_add(random.next_int_bound(10).expect("positive bound")); + let py = cell[1] + .wrapping_mul(12) + .wrapping_add(random.next_int_bound(9).expect("positive bound")); + let pz = cell[2] + .wrapping_shl(4) + .wrapping_add(random.next_int_bound(10).expect("positive bound")); + self.locations[index] = BlockPos::new(px, py, pz).pack(); } - distances[slot] = distance; - indices[slot] = index; + entries[next] = (index, BlockPos::unpack(self.locations[index])); + next += 1; } } } + self.neighborhood = Some((grid, entries)); + } + let mut distances = [i32::MAX; 4]; + let mut indices = [0usize; 4]; + for &(index, point) in &self + .neighborhood + .as_ref() + .expect("populated neighborhood") + .1 + { + let ax = point.x.wrapping_sub(x); + let ay = point.y.wrapping_sub(y); + let az = point.z.wrapping_sub(z); + let distance = ax + .wrapping_mul(ax) + .wrapping_add(ay.wrapping_mul(ay)) + .wrapping_add(az.wrapping_mul(az)); + // Equal distances insert before existing entries, as in vanilla. + if distance <= distances[0] { + distances = [distance, distances[0], distances[1], distances[2]]; + indices = [index, indices[0], indices[1], indices[2]]; + } else if distance <= distances[1] { + distances[3] = distances[2]; + distances[2] = distances[1]; + distances[1] = distance; + indices[3] = indices[2]; + indices[2] = indices[1]; + indices[1] = index; + } else if distance <= distances[2] { + distances[3] = distances[2]; + distances[2] = distance; + indices[3] = indices[2]; + indices[2] = index; + } else if distance <= distances[3] { + distances[3] = distance; + indices[3] = index; + } } let a = self.status(context, indices[0])?; let s01 = similarity(distances[0], distances[1]); diff --git a/docs/aquifer-cache-benchmark.md b/docs/aquifer-cache-benchmark.md new file mode 100644 index 000000000..09ce2558b --- /dev/null +++ b/docs/aquifer-cache-benchmark.md @@ -0,0 +1,56 @@ +# Aquifer neighborhood cache benchmark + +Caching the most recently used aquifer grid neighborhood reduces complete Overworld proto-generation plus decoration by a median **4.152% with one worker** and **2.377% with four workers** at the primary site. A second site improves **3.865% / 3.275%**. All 20 measured Overworld pairs improve. The implementation changes only `worldgen/aquifer/noise_based.rs`. + +## Implementation and scope + +Keep the twelve decoded cell positions and indices for the current grid in vanilla traversal order. Publish a replacement neighborhood only after every checked grid access succeeds; location entries initialized before an error remain visible in their original order. Reuse the neighborhood while its grid key matches. The existing location/status/surface caches retain their behavior. Explicit four-slot nearest insertion preserves later-cell distance ties (`<=`), wrapping distance arithmetic, random draw order, sampler/error order and fluid-update scheduling. Pinned 26.3 `Aquifer.NoiseBasedAquifer.computeSubstance` bytecode was inspected before implementation. + +No overlap with open aquifer work was found on 2026-10-22. The excluded Perlin, climate, feature-region, ore, biome-temperature and chunk-bookkeeping mechanisms are unchanged. Baseline `753c071c` includes the accepted saved-palette optimization; both variants contain that same loading code. These generation results measure only the aquifer change. + +## Measurements + +AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM; Linux 7.2.11-zen1-1-zen; Rust 1.99.0; release optimization, thin LTO, one codegen unit. Boost stayed enabled with the powersave governor and ordinary desktop activity. Resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Both executables were rebuilt from accepted sources with identical benchmark source (SHA256 `f404feb7ec526f12735d11b15af36254fd585f39b975cdbdc71905d87f10f8cc`), dependencies, resources and flags. Builds, tests and profiling did not overlap qualification timing. + +Every row uses one discarded process pair, then five measured pairs alternating baseline/candidate order. All 84 processes produced 256 proto chunks and 196 interior decorations. Warmup generates/discards an offset 9×9 region before fresh measured workers. Primary seed/center: 12345/(0,0); second: -1/(32,-32). Values are process-median **milliseconds for the complete 256-input-chunk batch**, without a thread multiplier. Stage medians need not sum to the combined median. Reductions are medians/ranges of per-pair reductions, so they need not equal the ratio of the independently reported medians. + +| Workload | Proto baseline → candidate | Decoration baseline → candidate | Combined baseline → candidate | Paired combined reduction (range) | +| --- | ---: | ---: | ---: | ---: | +| Primary Overworld, 1 worker | 2224.363 → 2135.304 | 442.671 → 438.347 | 2667.810 → 2575.518 | 4.152% (3.324–5.131%) | +| Primary Overworld, 4 workers | 733.644 → 716.328 | 131.039 → 128.976 | 864.363 → 844.938 | 2.377% (0.736–2.800%) | +| Second Overworld, 1 worker | 1994.369 → 1913.935 | 233.564 → 230.780 | 2230.391 → 2143.154 | 3.865% (3.552–4.144%) | +| Second Overworld, 4 workers | 572.673 → 551.555 | 68.164 → 67.669 | 640.836 → 618.820 | 3.275% (2.561–4.469%) | +| Nether, 1 worker | 969.751 → 962.970 | 87.048 → 85.903 | 1058.483 → 1048.873 | 0.730% (-2.406–1.096%) | +| End, 1 worker | 211.710 → 211.837 | 15.689 → 16.119 | 227.650 → 228.151 | -0.175% (-1.801–1.859%) | +| Primary Overworld, non-warmed, 1 worker | 4361.328 → 4256.020 | 442.196 → 437.629 | 4804.541 → 4691.376 | 2.177% (1.743–4.552%) | + +The non-warmed row retains lazy generator initialization. Resource loading remains outside the generation brackets; whole-process duration was also recorded and its non-warmed paired median improves 1.733%. Nether/End show ordinary variation, including a 0.175% End combined slowdown (about 0.5 ms per batch); no material regression is established there. + +Five alternating streaming pairs after a discarded pair use four workers, radius 4, seed 12345, a three-second flight at speed 4 and 120 Hz. Median fill is 1.21 → 1.19 s with identical 81 generated chunks/504 meshed sections. Flight produces identical 121 chunks/1,704 sections. Fill update p99 is unchanged at 0.041 ms; flight p99 is 0.200 → 0.208 ms and maximum update is 0.28 → 0.23 ms. All twelve runs have zero nearby unlit frames. This short route checks responsiveness and output counts; it is not a long-travel throughput claim. + +## Footprint + +The twelve-entry cache field occupies 312 bytes on this platform, inline in the existing aquifer object, and adds no allocation calls or independently growing buffer. It enlarges the existing transient aquifer object, which is discarded after generation; resident and saved chunk representations are unchanged. Peak RSS medians are 732,032 → 732,088 KiB (primary one-worker) and 756,724 → 759,768 KiB (four-worker). Paired RSS ranges span increases and decreases; the four-worker median difference is about 0.4% of process RSS. The release executable text grows by 3,872 bytes (about 0.075%). + +## Correctness + +- Fresh authenticated vanilla 26.3 aquifer oracle: **379 fixtures, 389,804 exact lines per client/server JAR**. Covers modern/legacy factories, repeated/reversed queries, negative/wrapped coordinates, nonfinite inputs, sampler/picker traces, fluid scheduling, location/status/surface caches, bounds failures and all 18 injected sampler failure/retry cases. +- Fresh terrain-fill oracle: **114 fixtures, 200 fills, 7,950,873 exact lines per JAR**, including 61 noise-aquifer fixtures, 24 structure-density fixtures, repeated/prefilled/clipped fills, raw blocks, WG heightmaps and ordered fluid postprocessing. +- Fresh material-stage oracle: **79 fixtures, 106 surface builds, 42 generated-carving passes, 6,733,382 exact lines per JAR**, including real biome neighborhoods, aquifer traces, carving masks, top-material queries, complete sections, heightmaps and postprocessing. +- **36/36 exact baseline/candidate phase snapshots match**: three dimensions × three seeds/sites × one/four workers × before/after decoration. Each region retains 81 chunks and decorates 49 interior chunks, totaling 1,458 retained chunks per phase and 882 decorations. Seeds/sites are 12345/(0,0), -1/(-32,32), and 81985529216486895/(1874990,-1874990). Snapshots include resident palettes/words and public block reads, quart biomes, all six heightmaps, ordered postprocessing, structure summaries, binary-NBT entities/block entities, complete scheduled ticks, stage/decorated/retrogen metadata and actual non-air counts. Temporary diagnostic source was removed. A final production-only rebuild with the original package feature graph is byte-identical to the measured candidate executable (SHA256 `3b4e07bd9189270c7e0a4521bd25e156f932014d976b1c4208cde4769d5fd8ea`). + +These checks establish unchanged output for the declared cases. Complete world/gameplay parity and cold physical I/O are outside this comparison. + +## Reproduction and evidence + +Private/generated artifacts are outside Git at `/srv/bob-data/horizon-chunk-campaign-41055168/aquifer-qualification/`: preserved binaries/sources and hashes, build logs, `pairs.py`, `matrix-raw.json`, `matrix-summary.json`, every process log, streaming runner/raw/summary, snapshot source/runner/outputs, and fresh oracle reports/inputs/outputs. Oracle runners retain the repository's corpus/comparison/authentication logic, with isolated output storage and absolute hash-map keys; the worldgen runner selects only `noise_aquifer_corpus`. + +```sh +CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-target cargo build --locked --release -p horizon-world --example chunkgen_bench -p horizon-client --no-default-features --example streaming_bench +python3 /srv/bob-data/horizon-chunk-campaign-41055168/aquifer-qualification/pairs.py +python3 /srv/bob-data/horizon-chunk-campaign-41055168/aquifer-qualification/streaming.py +``` + +The standard warmed generation command is `chunkgen_bench RESOURCES --seed 12345 --size 16 --threads 1 --warmup --json --no-map`; use four workers for the parallel row and `--seed -1 --center 32 -32` for the second site. + +Repository quick self-check passes: `CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-check-target python3 tools/pr_ready.py --quick --base origin/main` (4 min 23 s). Public-tree validation, workspace rustfmt, clippy with warnings denied, **1,442 client/core/world tests** and the doc-test step pass. The quick check lists affected parity harnesses; the three fresh relevant oracle suites above were executed separately. Full log: `aquifer-qualification/pr-ready.txt`. From a648622b9232023b106c6b1eb4f26b46b1f5fb6f Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:46:40 +0100 Subject: [PATCH 35/59] bench: report exact warmed generation wall timings --- .../horizon-world/examples/chunkgen_bench.rs | 38 ++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/crates/horizon-world/examples/chunkgen_bench.rs b/crates/horizon-world/examples/chunkgen_bench.rs index 4992515c5..23360b637 100644 --- a/crates/horizon-world/examples/chunkgen_bench.rs +++ b/crates/horizon-world/examples/chunkgen_bench.rs @@ -3,6 +3,7 @@ //! chunkgen_bench [--seed S] [--size N] [--threads T] //! [--center CX CZ] [--verify ] [--no-decorate] //! [--dimension overworld|the_nether|the_end] +//! [--warmup] [--json] [--no-map] use horizon_core::position::ChunkPos; use horizon_world::{ DATA_VERSION, @@ -275,6 +276,7 @@ fn main() -> Result<(), Error> { let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0)); let mut parity = None; let mut decorate = true; + let (mut warmup, mut json, mut map) = (false, false, true); let mut dimension = String::from("minecraft:overworld"); let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None; while let Some(arg) = args.next() { @@ -286,6 +288,9 @@ fn main() -> Result<(), Error> { "--center" => center = (next().parse()?, next().parse()?), "--verify" => parity = Some(PathBuf::from(next())), "--no-decorate" => decorate = false, + "--warmup" => warmup = true, + "--json" => json = true, + "--no-map" => map = false, "--dimension" => { let d = next(); dimension = if d.contains(':') { @@ -326,6 +331,16 @@ fn main() -> Result<(), Error> { dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?; return Ok(()); } + if warmup { + let mut worker = generator.worker(); + for z in -4..=4 { + for x in -4..=4 { + std::hint::black_box( + worker.generate_proto(ChunkPos::new(center.0 + 64 + x, center.1 + 64 + z))?, + ); + } + } + } let (x0, z0) = (center.0 - size / 2, center.1 - size / 2); let count = (size * size) as usize; let next = AtomicUsize::new(0); @@ -353,6 +368,7 @@ fn main() -> Result<(), Error> { handles.into_iter().try_for_each(|h| h.join().unwrap()) })?; let elapsed = start.elapsed(); + let cpu_elapsed = cpu_seconds() - cpu; println!( "generated {count} proto chunks with {threads} threads in {elapsed:.2?}: {:.1} chunks/s ({:.1} ms/chunk/thread)", count as f64 / elapsed.as_secs_f64(), @@ -360,7 +376,7 @@ fn main() -> Result<(), Error> { ); println!( " cpu time {:.1} ms/chunk", - (cpu_seconds() - cpu) * 1000. / count as f64 + cpu_elapsed * 1000. / count as f64 ); let timings = timings.into_inner().unwrap(); let per_chunk = |f: fn(&StageTimings) -> std::time::Duration| { @@ -379,6 +395,16 @@ fn main() -> Result<(), Error> { per_chunk(|t| t.surface), per_chunk(|t| t.carvers) ); + if json { + println!( + "BENCH {}", + serde_json::json!({"phase": "proto", "chunks": count, + "threads": threads, "wall_s": elapsed.as_secs_f64(), "cpu_s": cpu_elapsed, + "biomes_ms_chunk": per_chunk(|t| t.biomes), "noise_ms_chunk": per_chunk(|t| t.noise), + "structures_ms_chunk": per_chunk(|t| t.structures), + "surface_ms_chunk": per_chunk(|t| t.surface), "carvers_ms_chunk": per_chunk(|t| t.carvers)}) + ); + } let mut chunks: Vec> = slots .into_iter() .map(|slot| slot.into_inner().unwrap()) @@ -441,6 +467,13 @@ fn main() -> Result<(), Error> { } } let elapsed = start.elapsed(); + if json { + println!( + "BENCH {}", + serde_json::json!({"phase": "decorate", "chunks": decorated, + "wall_s": elapsed.as_secs_f64()}) + ); + } let totals = totals.into_inner().unwrap(); println!( "decorated {decorated} chunks in {elapsed:.2?}: {:.1} chunks/s; feature roots placed {}, unsupported {}, failed {}", @@ -492,6 +525,9 @@ fn main() -> Result<(), Error> { } } } + if !map { + return Ok(()); + } let mut legend = BTreeMap::>::new(); let step = (size * 16 / 96).max(1); for bz in (0..size * 16).step_by(step as usize) { From 5eb224a909ca1a1b99c9342ed979faf3cc729c0a Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:17:33 +0200 Subject: [PATCH 36/59] Rename the Nightly update channel to Alpha The whole of Horizon is in beta, so the channel that installs every build as soon as it is built is called Alpha; Stable keeps its name. The launcher's Settings, the update-channel command, the MCP tool, the release notes footer and the docs say Alpha. update_channel is saved as "alpha"; "nightly" and the old beta_builds switch still read as Alpha. Co-Authored-By: Claude Sonnet 5.5 --- .github/workflows/promote.yml | 2 +- .github/workflows/release.yml | 2 +- docs/release-flow.md | 29 ++++++++------- docs/security.md | 6 +-- docs/versioning.md | 6 +-- launcher/README.md | 10 ++--- launcher/src/backend.rs | 67 ++++++++++++++++++---------------- launcher/src/cli.rs | 4 +- launcher/src/main.rs | 6 +-- launcher/src/mcp.rs | 6 +-- tests/test_release_channels.py | 6 +-- tools/release_channels.py | 2 +- tools/release_train.py | 4 +- website/docs/faq.md | 2 +- website/docs/index.md | 2 +- website/docs/install.md | 8 ++-- website/docs/multiplayer.md | 2 +- website/docs/settings.md | 4 +- 18 files changed, 88 insertions(+), 80 deletions(-) diff --git a/.github/workflows/promote.yml b/.github/workflows/promote.yml index 389d99712..3966f571b 100644 --- a/.github/workflows/promote.yml +++ b/.github/workflows/promote.yml @@ -1,7 +1,7 @@ name: promote # Beta game releases become stable once a day (docs/release-flow.md, "Channels"): at 20:00 UTC (21:00 in Paris in # winter time, 22:00 in summer) tools/release_channels.py promotes the newest beta that had been out 6 hours by then, -# passed its release smoke test and isn't covered by an issue labelled release-blocker. Launchers on the Nightly +# passed its release smoke test and isn't covered by an issue labelled release-blocker. Launchers on the Alpha # channel install every beta when it is published; Stable gets the day's promotion. The later runs of the evening are # retries for a run GitHub starts late or skips: they promote the same beta, so stable still moves once. # By hand, from GitHub's app too (Actions > promote > Run workflow): diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 6c1ecf422..b19ba9ce5 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -349,7 +349,7 @@ jobs: run: | signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig) smoke=(); [[ -f dist/smoke-test.json ]] && smoke=(dist/smoke-test.json) - # A beta (pre-release), the Nightly channel's: promote.yml makes it stable and latest in its daily promotion + # A beta (pre-release), the Alpha channel's: promote.yml makes it stable and latest in its daily promotion # (docs/release-flow.md). gh release create "$TAG" --target "${{ needs.decide.outputs.head }}" --title "$(cat notes/title.txt)" \ --notes-file notes/body.md --prerelease --latest=false dist/horizon-linux-x86_64.tar.gz \ diff --git a/docs/release-flow.md b/docs/release-flow.md index 45365e341..6cc4bcd3c 100644 --- a/docs/release-flow.md +++ b/docs/release-flow.md @@ -2,9 +2,9 @@ How a change gets from a pull request to players: the checks a pull request passes, how it merges, and the automatic releases that follow. Releases are automatic and frequent so the latest Horizon is always playable. -Each one goes out as a **beta**, which launchers on the **Nightly** channel install at once, and becomes **stable** in +Each one goes out as an **alpha** build, which launchers on the **Alpha** channel install at once, and becomes **stable** in the next daily promotion unless something holds it back ([Channels](#channels)): launchers and servers install -stable builds unless their owner picks Nightly. +stable builds unless their owner picks Alpha. ## Pull request checks @@ -101,8 +101,8 @@ flowchart LR windows["Windows x64
GitHub windows-latest"] mac["macOS arm64
Mac mini runner
+ offscreen game run"] end - build --> publish["publish vX.Y.Z as a beta
notes from the merged PRs"] - publish --> beta(["launchers on Nightly install it"]) + build --> publish["publish vX.Y.Z as an alpha
notes from the merged PRs"] + publish --> alpha(["launchers on Alpha install it"]) publish --> promote{"promote.yml, daily at 20:00 UTC:
6 h old by then, smoke test, no release-blocker"} promote --> stable["stable and latest
notes since the last stable"] stable --> launcher(["every launcher and server installs it"]) @@ -121,7 +121,7 @@ commits) since the last **published** game release: - It releases when at least one pull request counts and the newest of them merged at least 5 minutes ago, so a wave of merges becomes one release; if merges never pause, it releases once the oldest has waited 20 minutes. There is no minimum time between releases: every settled player-facing change ships, limited only by the release already - building. That is the Nightly channel, many releases a day. + building. That is the Alpha channel, many releases a day. - A pull request labelled `release-now` (a crash or a blocker) releases at once. - A pull request labelled `skip-release` (work players don't see) doesn't count and isn't listed in the notes. - One release at a time (concurrency group `game-release`); a run that finds nothing new does nothing. @@ -180,23 +180,26 @@ runs the game: GitHub's runners have neither a GPU worth the name nor the game f - `### Known issues`: the bullets of [docs/known-issues.md](known-issues.md); - thanks to outside contributors, how to install, the disclaimer. -Kira posts every release in Discord's #releases. A Nightly (a game pre-release) is posted silently: no ping and +Kira posts every release in Discord's #releases. An Alpha build (a game pre-release) is posted silently: no ping and Discord's @silent flag, so nobody gets a notification. When the same release becomes Stable it is posted again, and that post pings the releases role when the notes have a `### New` section (at most once every 6 hours). Launcher releases post without a ping. ### Channels -Every game release is published as a **beta**, a GitHub pre-release, so GitHub's *latest* release stays the last +Every game release is published as an **alpha** build, a GitHub pre-release (the workflows, tools and labels +call it a *beta*: `release-blocker` holds every beta), so GitHub's *latest* release stays the last **stable** one. The launcher's Settings has an **Updates** choice of two channels (`update_channel` in its `settings.json`, `horizon-launcher update-channel`): -- **Stable**, the default: a tested build about once a day, the betas promoted below. -- **Nightly**: every beta as soon as it is built, many times a day; it can break. "Nightly" is a name, not a - schedule. An open launcher looks for releases every 30 minutes on Nightly (4 hours on Stable). Launchers from before 0.2 had a "Beta builds" switch instead; on, it reads as Nightly. +- **Stable**, the default: a tested build about once a day, the alpha builds promoted below. +- **Alpha**: every alpha build as soon as it is built, many times a day; it can break. "Alpha" is the project's + word for builds that are still being tested (the whole of Horizon is in beta); Stable is the tested ones. An open + launcher looks for releases every 30 minutes on Alpha (4 hours on Stable). Launchers from before 0.2 had a "Beta + builds" switch instead; on, it reads as Alpha. -`horizon-server update` installs stable builds (`--version ` takes one by name). In Discord's #releases every -Nightly is posted silently and only Stable posts notify (above). +`horizon-server update` installs stable builds (`--version ` takes an alpha build by name). In Discord's #releases every +Alpha is posted silently and only Stable posts notify (above). `.github/workflows/promote.yml` runs `tools/release_channels.py promote` once a day at 20:00 UTC (21:00 in Paris in winter time, 22:00 in summer), with retries until 21:37 for a run GitHub starts late or skips. It promotes the newest @@ -231,7 +234,7 @@ gh workflow run promote -f tag=v0.2.3 -f force=true # even blocked or without gh workflow run promote -f dry_run=true # what would be promoted now ``` -A beta's notes cover only what changed since the release before it (beta or stable), and say it is a nightly build. +An alpha build's notes cover only what changed since the release before it (alpha or stable), and say it is an alpha build. `release_train.py decide` counts pull requests from the newest release of either channel, so betas don't release the same changes again. diff --git a/docs/security.md b/docs/security.md index d61198ec2..175e5d21d 100644 --- a/docs/security.md +++ b/docs/security.md @@ -38,7 +38,7 @@ and some are waiting for Ludovic: | Private vulnerability reporting | **Live** (see the end of this page). | | Signed checksums on releases | **Live** for new releases (#1011): the `release` environment holds the key, and its public half is in `release-keys.txt` (#1023). Releases from before then are unsigned. | | Launchers and servers checking signatures | **Not yet**: #1014 waits as a draft until a signed stable game release and a signed launcher release exist. Until then they trust GitHub's checksum, as before. | -| Beta, then stable | **Live** (#1012): every release is first a beta. The launcher's Updates setting picks Stable (the default) or Nightly (the betas). | +| Alpha, then stable | **Live** (#1012): every release is first an alpha build. The launcher's Updates setting picks Stable (the default) or Alpha (the pre-releases). | | Reports marked suspicious | **Partly**: the scan of Discord for agents does it. Kira's issues do it once its pull request merges. | | Code owners' review of the pipeline | **Not yet**: `.github/CODEOWNERS` and its protection (#1015) wait for the App, below. Until then pipeline changes merge like any other once `verify` passes. | | Agents on their own GitHub App | **Not yet**: prepared, waiting for Ludovic to create it. Agents still use his account. | @@ -53,11 +53,11 @@ and some are waiting for Ludovic: - **`verify` always runs.** Labels no longer start the checks, and the required `verify` job has no condition, so the only `verify` a change can have is one that ran. Main requires it, from GitHub Actions only, for everyone, admins included. -- **Beta, then stable.** Every release is first a **beta**. It becomes **stable**, the version launchers and +- **Alpha, then stable.** Every release is first an **alpha** build (a GitHub pre-release). It becomes **stable**, the version launchers and servers install by themselves, in the daily promotion (20:00 UTC), only after it has been out 6 hours and passed its smoke test (the game started and drew a world on the Mac mini), and only while no issue labelled `release-blocker` is open. If a beta misses a promotion it was due for, an issue says so. Players who want the newest builds at once - pick **Nightly** under Updates in the launcher's Settings. Discord announces stable releases only. + pick **Alpha** under Updates in the launcher's Settings. Discord announces stable releases only. - **Signed updates.** Each release carries a list of its files' checksums, signed with Horizon's release key. The launcher (for the game and for itself) and `horizon-server update` check that signature against the public key built into them, then check the download against the list. Anything unsigned, signed with another key, signed diff --git a/docs/versioning.md b/docs/versioning.md index 4481e72f6..6032b54a1 100644 --- a/docs/versioning.md +++ b/docs/versioning.md @@ -22,8 +22,8 @@ game and the launcher of the 0.2 line. 0.2. A `feature` label no longer bumps anything: it only lists the change under **New**. - **Patch releases** are every release the train makes: the patch after the newest release tagged on the line, game and launcher counted separately (the game releases more often, so `v0.2.14` can go with `launcher@0.2.3`). -- **Betas** are not separate tags. As before, every game release is published as a GitHub pre-release (a beta, what - the launcher's Nightly channel installs) under its final tag and promoted in place to stable in the daily +- **Alpha builds** are not separate tags. As before, every game release is published as a GitHub pre-release (an alpha build, what + the launcher's Alpha channel installs) under its final tag and promoted in place to stable in the daily promotion at 20:00 UTC, once it has been out 6 hours ([Channels](release-flow.md#channels)). `v0.2.4` is the same build whether it is still a beta or already stable. - **Pre-release tags** (`v0.3.0-rc.1`, `v0.3.0-beta.2`) are semver's and are reserved for a hand-made preview of a @@ -126,7 +126,7 @@ Run by the orchestrator, in this order. Until step 3, nothing is published. makes it *latest*. Do not force it (`promote` with `force=true`): it carries about 43 player-facing pull requests from the freeze and needs its beta like any release. Check it is *latest*: `gh api repos/ludovic111/horizon/releases/latest --jq .tag_name`. -5. Only then merge the update channels pull request (the launcher's Stable and Nightly, the daily promotion), then +5. Only then merge the update channels pull request (the launcher's Stable and Alpha, the daily promotion), then mark the switch pull request (#1132) ready and merge it (`.github/release-line.txt` = `0.2`, and the docs that talk about 0.2). On the next run, about 10 minutes, the train publishes `v0.2.0` as a beta and `launcher@0.2.0`, both "the first release of 0.2", built from the same code as the bridges plus that pull request. diff --git a/launcher/README.md b/launcher/README.md index c1935c7cf..08ec11f98 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -83,11 +83,11 @@ page `servers.json` (the list), `servers//` (the servers created there) an the game's menu style, the game's extra command-line arguments, and the launcher's own version and update state. - **Updates**: **Stable** (the default) installs a tested build about once a day, the betas that - `promote.yml` makes stable; **Nightly** installs every release as soon as it is built, several + `promote.yml` makes stable; **Alpha** installs every release as soon as it is built, several times a day, and can break (docs/release-flow.md, "Channels"). While it is open, the launcher - looks for new releases every 4 hours on Stable and every 30 minutes on Nightly. Kept as `update_channel` in - `settings.json`; a `beta_builds: true` from launchers before 0.2 reads as Nightly. - `horizon-launcher update-channel [stable|nightly]` shows or sets it. The **Versions** page + looks for new releases every 4 hours on Stable and every 30 minutes on Alpha. Kept as `update_channel` in + `settings.json`; a `beta_builds: true` from launchers before 0.2 reads as Alpha (so does a `nightly` from the channel's first name). + `horizon-launcher update-channel [stable|alpha]` shows or sets it. The **Versions** page shows each release's channel. The launcher's own updates don't depend on it. - **Game arguments**: extra arguments added to the game's command line (for example `--server-thread`), one line where quotes group a word with spaces. They are appended after the @@ -140,7 +140,7 @@ The same binary is a command-line tool; without a subcommand it opens the window horizon-launcher notes [] patch notes as plain text horizon-launcher links the Discord, sponsor and website links horizon-launcher menu-style [horizon|classic] show or set the game's menu style - horizon-launcher update-channel [stable|nightly] show or set which releases install by themselves + horizon-launcher update-channel [stable|alpha] show or set which releases install by themselves horizon-launcher game-args [] show or set the extra arguments the game starts with horizon-launcher update [--check] Horizon and the launcher horizon-launcher logs [--lines N] [--crash] the end of the game's log, or its newest crash report diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index ba854730f..8cbc6be2f 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -346,7 +346,7 @@ pub fn latest(releases: &[Release]) -> Option<&Release> { releases.iter().find(|r| r.asset.is_some()) } -/// The releases a launcher installs by itself: stable ones, and betas too on the Nightly channel. +/// The releases a launcher installs by itself: stable ones, and betas too on the Alpha channel. pub fn channel(releases: &[Release], channel: UpdateChannel) -> Vec { releases .iter() @@ -362,15 +362,17 @@ pub enum UpdateChannel { /// A tested build about once a day: the betas promote.yml makes stable. #[default] Stable, - /// Every release as soon as it is built, betas included. - Nightly, + /// Every release as soon as it is built, pre-releases included. It was called "nightly" + /// while the channels were new: that name is still read. + #[serde(alias = "nightly")] + Alpha, } impl UpdateChannel { pub fn name(self) -> &'static str { match self { UpdateChannel::Stable => "stable", - UpdateChannel::Nightly => "nightly", + UpdateChannel::Alpha => "alpha", } } @@ -378,36 +380,36 @@ impl UpdateChannel { pub fn label(self) -> &'static str { match self { UpdateChannel::Stable => "Stable", - UpdateChannel::Nightly => "Nightly", + UpdateChannel::Alpha => "Alpha", } } pub fn parse(name: &str) -> Option { match name { "stable" => Some(UpdateChannel::Stable), - "nightly" => Some(UpdateChannel::Nightly), + "alpha" | "nightly" => Some(UpdateChannel::Alpha), _ => None, } } - /// Whether this channel installs `release`: betas only reach Nightly. + /// Whether this channel installs `release`: betas only reach Alpha. pub fn takes(self, release: &Release) -> bool { - self == UpdateChannel::Nightly || !release.beta + self == UpdateChannel::Alpha || !release.beta } - /// How often a launcher left open looks for new releases: Nightly's come many times a day, + /// How often a launcher left open looks for new releases: Alpha's come many times a day, /// Stable's once. pub fn check_every(self) -> std::time::Duration { std::time::Duration::from_secs(match self { UpdateChannel::Stable => 4 * 3600, - UpdateChannel::Nightly => 30 * 60, + UpdateChannel::Alpha => 30 * 60, }) } - /// The channel a release is on when it is listed: betas are Nightly's only. + /// The channel a release is on when it is listed: betas are Alpha's only. pub fn of(release: &Release) -> Self { if release.beta { - UpdateChannel::Nightly + UpdateChannel::Alpha } else { UpdateChannel::Stable } @@ -2214,7 +2216,7 @@ pub struct Settings { #[serde(default, skip_serializing_if = "String::is_empty")] pub game_args: String, /// Which releases install by themselves: Stable by default. Launchers before 0.2 had a "Beta - /// builds" switch instead; [`Settings::parse`] reads its `beta_builds: true` as Nightly. + /// builds" switch instead; [`Settings::parse`] reads its `beta_builds: true` as Alpha. #[serde(default)] pub update_channel: UpdateChannel, /// The player has read what the "I'm playing" ping holds (`telemetry::PING`): on the @@ -2232,11 +2234,11 @@ impl Settings { return Self::default(); }; if let Some(fields) = value.as_object_mut() { - // The switch from before 0.2: on meant every release at once, the Nightly channel. + // The switch from before 0.2: on meant every release at once, the Alpha channel. if fields.remove("beta_builds") == Some(serde_json::Value::Bool(true)) { fields .entry("update_channel") - .or_insert_with(|| UpdateChannel::Nightly.name().into()); + .or_insert_with(|| UpdateChannel::Alpha.name().into()); } // A channel this launcher doesn't know is Stable, not a reason to lose every setting. if fields @@ -2458,10 +2460,10 @@ mod tests { assert_eq!(offered(&["v2026.10.15.1", "v2026.10.14"]), None); } - /// Betas (GitHub pre-releases) install by themselves only on the Nightly channel; Stable waits + /// Betas (GitHub pre-releases) install by themselves only on the Alpha channel; Stable waits /// for promote.yml's daily promotion (docs/release-flow.md, "Channels"). #[test] - fn updates_follow_the_stable_channel_unless_nightly_is_picked() { + fn updates_follow_the_stable_channel_unless_alpha_is_picked() { let asset = ASSET.unwrap_or("horizon-linux-x86_64.tar.gz"); let list = serde_json::json!([ {"tag_name": "v2026.10.19.02", "prerelease": true, "assets": [{"name": asset, "browser_download_url": "b", "size": 1}]}, @@ -2472,10 +2474,10 @@ mod tests { releases.iter().map(|r| r.beta).collect::>(), [true, false] ); - let offered = |nightly: bool, installed: &[&str]| { + let offered = |alpha: bool, installed: &[&str]| { let installed: Vec = installed.iter().map(|t| t.to_string()).collect(); - let on = if nightly { - UpdateChannel::Nightly + let on = if alpha { + UpdateChannel::Alpha } else { UpdateChannel::Stable }; @@ -2491,12 +2493,12 @@ mod tests { assert_eq!(offered(false, &["v2026.10.19.02"]), None); assert_eq!( releases.iter().map(UpdateChannel::of).collect::>(), - [UpdateChannel::Nightly, UpdateChannel::Stable] + [UpdateChannel::Alpha, UpdateChannel::Stable] ); } #[test] - fn the_update_channel_is_stored_by_name_and_the_old_beta_switch_reads_as_nightly() { + fn the_update_channel_is_stored_by_name_and_the_old_beta_switch_reads_as_alpha() { let read = |text: &str| Settings::parse(text).update_channel; assert_eq!(read(""), UpdateChannel::Stable); assert_eq!(read("{}"), UpdateChannel::Stable); @@ -2504,12 +2506,15 @@ mod tests { read(r#"{"update_channel": "stable"}"#), UpdateChannel::Stable ); + assert_eq!(read(r#"{"update_channel": "alpha"}"#), UpdateChannel::Alpha); + // The channel's first name, from launchers built while it was called Nightly. assert_eq!( read(r#"{"update_channel": "nightly"}"#), - UpdateChannel::Nightly + UpdateChannel::Alpha ); - // Launchers before 0.2: "Beta builds" on is Nightly, off is Stable. - assert_eq!(read(r#"{"beta_builds": true}"#), UpdateChannel::Nightly); + assert_eq!(UpdateChannel::parse("nightly"), Some(UpdateChannel::Alpha)); + // Launchers before 0.2: "Beta builds" on is Alpha, off is Stable. + assert_eq!(read(r#"{"beta_builds": true}"#), UpdateChannel::Alpha); assert_eq!(read(r#"{"beta_builds": false}"#), UpdateChannel::Stable); // Once a channel is picked, it wins over a switch left behind. let both = r#"{"beta_builds": true, "update_channel": "stable"}"#; @@ -2522,19 +2527,19 @@ mod tests { // Saved as a name, without the old switch. let mut settings = Settings::parse(r#"{"selected": "v0.2.0", "beta_builds": true}"#); let saved = serde_json::to_value(&settings).unwrap(); - assert_eq!(saved["update_channel"], "nightly"); + assert_eq!(saved["update_channel"], "alpha"); assert!(saved.get("beta_builds").is_none()); assert_eq!(saved["selected"], "v0.2.0"); settings.update_channel = UpdateChannel::Stable; let text = serde_json::to_string(&settings).unwrap(); assert_eq!(read(&text), UpdateChannel::Stable); - for c in [UpdateChannel::Stable, UpdateChannel::Nightly] { + for c in [UpdateChannel::Stable, UpdateChannel::Alpha] { assert_eq!(UpdateChannel::parse(c.name()), Some(c)); } - // An open launcher looks again every 4 hours on Stable, every 30 minutes on Nightly. + // An open launcher looks again every 4 hours on Stable, every 30 minutes on Alpha. let minutes = |c: UpdateChannel| c.check_every().as_secs() / 60; assert_eq!(minutes(UpdateChannel::Stable), 240); - assert_eq!(minutes(UpdateChannel::Nightly), 30); + assert_eq!(minutes(UpdateChannel::Alpha), 30); } #[test] @@ -2665,8 +2670,8 @@ mod tests { let releases = parse_releases(&list, Some(asset), is_game_tag); let installed = ["v2026.10.19.15".to_string(), "v2026.10.12".to_string()]; let offered = |on| horizon_update(&channel(&releases, on), &installed).map(|r| r.tag); - // A beta 0.2.0 reaches launchers on Nightly; Stable ones wait for its promotion. - assert_eq!(offered(UpdateChannel::Nightly), Some("v0.2.0".into())); + // A beta 0.2.0 reaches launchers on Alpha; Stable ones wait for its promotion. + assert_eq!(offered(UpdateChannel::Alpha), Some("v0.2.0".into())); assert_eq!(offered(UpdateChannel::Stable), None); let mut sorted = vec![ "v2026.10.19.15".to_string(), diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs index a3903bf2f..e498fed2b 100644 --- a/launcher/src/cli.rs +++ b/launcher/src/cli.rs @@ -278,10 +278,10 @@ enum Cmd { style: Option, }, /// Show or set which Horizon releases install by themselves: stable (a tested build about once - /// a day) or nightly (every release as soon as it is built; can break) + /// a day) or alpha (every release as soon as it is built; can break) UpdateChannel { /// Omit to show the current channel - #[arg(value_parser = ["stable", "nightly"])] + #[arg(value_parser = ["stable", "alpha"])] channel: Option, }, /// Show or set the extra arguments the game starts with (for example --server-thread); diff --git a/launcher/src/main.rs b/launcher/src/main.rs index ec418a213..15cfb79ac 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -1830,11 +1830,11 @@ impl Launcher { cx.notify(); }), ); - use backend::UpdateChannel::{Nightly, Stable}; + use backend::UpdateChannel::{Alpha, Stable}; let this = cx.entity().downgrade(); let update_channel = segments( "update-channel", - &[(Stable, Stable.label()), (Nightly, Nightly.label())], + &[(Stable, Stable.label()), (Alpha, Alpha.label())], self.settings.update_channel, &t, move |picked, _, cx| { @@ -2011,7 +2011,7 @@ impl Launcher { .flex_col() .child("Stable: a tested build about once a day.") .child( - "Nightly: every change as soon as it is built, several times a day; can break.", + "Alpha: every change as soon as it is built, several times a day; can break.", ) .into_any_element(), ), diff --git a/launcher/src/mcp.rs b/launcher/src/mcp.rs index 0d77c3545..42af1c5d3 100644 --- a/launcher/src/mcp.rs +++ b/launcher/src/mcp.rs @@ -51,8 +51,8 @@ fn tools() -> Value { { "name": "links", "description": "The Horizon links: the Discord invite, the GitHub Sponsors page and the website (an empty one is not offered).", "inputSchema": none }, { "name": "menu_style", "description": "Show or set the game's menu style. \"horizon\" is Horizon's own menus, \"classic\" is vanilla's screens, which have no way back inside the game. The game reads it when it starts.", "inputSchema": { "type": "object", "properties": { "style": { "type": "string", "enum": ["horizon", "classic"], "description": "Omit to show the current style." } } } }, - { "name": "update_channel", "description": "Show or set which Horizon releases install by themselves. \"stable\" (the default) is a tested build about once a day; \"nightly\" is every release as soon as it is built, several times a day, and can break. Only when the player asks to change it.", - "inputSchema": { "type": "object", "properties": { "channel": { "type": "string", "enum": ["stable", "nightly"], "description": "Omit to show the current channel." } } } }, + { "name": "update_channel", "description": "Show or set which Horizon releases install by themselves. \"stable\" (the default) is a tested build about once a day; \"alpha\" is every release as soon as it is built, several times a day, and can break. Only when the player asks to change it.", + "inputSchema": { "type": "object", "properties": { "channel": { "type": "string", "enum": ["stable", "alpha"], "description": "Omit to show the current channel." } } } }, { "name": "logs", "description": "Read the game's log: the last lines of logs/latest.log in the game folder, or with crash the newest crash report (what the game wrote when it last crashed). Read-only.", "inputSchema": { "type": "object", "properties": { "lines": { "type": "integer", "minimum": 1, "maximum": 5000, "description": "How many lines of latest.log (default 100)." }, "crash": { "type": "boolean", "description": "Return the newest crash report instead." } } } }, { "name": "accounts", "description": "The Microsoft accounts signed in to the launcher (names and UUIDs, never tokens), which one the game plays as (none = offline), and how a sign-in started with sign_in is going.", "inputSchema": none }, @@ -291,7 +291,7 @@ impl Session { let mut settings = backend::Settings::load(); if let Some(name) = arg_str(args, "channel") { settings.update_channel = backend::UpdateChannel::parse(name) - .ok_or("channel is \"stable\" or \"nightly\"")?; + .ok_or("channel is \"stable\" or \"alpha\"")?; settings.save(); } Ok(format!( diff --git a/tests/test_release_channels.py b/tests/test_release_channels.py index ed183afed..288fa7939 100644 --- a/tests/test_release_channels.py +++ b/tests/test_release_channels.py @@ -137,10 +137,10 @@ class ReleaseChannelTests(unittest.TestCase): pr = {"number": 1, "title": "Fix a thing", "labels": [], "paths": ["crates/x.rs"], "issues": [], "author": "ludovic111"} _, beta = train.notes("game", "v2026.10.19", [pr], [], beta=True) _, stable = train.notes("game", "v2026.10.19", [pr], [], beta=False) - self.assertIn("This is a nightly build: launchers on the Nightly channel", beta) - self.assertNotIn("nightly", stable.lower()) + self.assertIn("This is an alpha build: launchers on the Alpha channel", beta) + self.assertNotIn("alpha", stable.lower()) _, launcher = train.notes("launcher", "launcher-v0.9.0", [pr], [], beta=True) - self.assertNotIn("nightly", launcher.lower()) + self.assertNotIn("alpha", launcher.lower()) if __name__ == "__main__": diff --git a/tools/release_channels.py b/tools/release_channels.py index be0f2ca73..869127c5c 100644 --- a/tools/release_channels.py +++ b/tools/release_channels.py @@ -6,7 +6,7 @@ python3 tools/release_channels.py promote --tag v2026.10.19.03 --force # even if blocked or untested python3 tools/release_channels.py promote --dry-run # say what would happen, change nothing -Every game release goes out as a beta (a GitHub pre-release): launchers on the Nightly channel install it at once. +Every game release goes out as a beta (a GitHub pre-release): launchers on the Alpha channel install it at once. Stable moves once a day, at PROMOTE_AT (20:00 UTC). A beta is due for stable when: - it is newer than the stable release (GitHub's "latest", which launchers and servers install by default), - it had been out PROMOTE_AFTER (6 hours) at the day's promotion time, so every run until the next one picks the diff --git a/tools/release_train.py b/tools/release_train.py index 5f6239edc..0cc37eef7 100644 --- a/tools/release_train.py +++ b/tools/release_train.py @@ -37,7 +37,7 @@ import sys ROOT = Path(__file__).resolve().parents[1] REPO = os.environ.get("GITHUB_REPOSITORY", "ludovic111/horizon") -# Nightly builds ship constantly: a merge starts a release within minutes, once its wave of merges has settled. +# Alpha builds ship constantly: a merge starts a release within minutes, once its wave of merges has settled. DEBOUNCE = dt.timedelta(minutes=5) MAX_WAIT = dt.timedelta(minutes=20) # Kept as typed in release titles, where the clauses after the first are lowercased. @@ -72,7 +72,7 @@ LAUNCHER_IGNORED = ["launcher/links.json", "launcher/docs/", "launcher/tests/"] FOOTER = { "game": "Install or update it from the Horizon launcher: it installs new versions by itself. " "New here? Get the launcher at https://playhorizon.dev. You need your own copy of Minecraft: Java Edition.", - "beta": "This is a nightly build: launchers on the Nightly channel (Settings, Updates) install it now; Stable gets it " + "beta": "This is an alpha build: launchers on the Alpha channel (Settings, Updates) install it now; Stable gets it " "in the next daily update if it holds up.", "launcher": "Your launcher updates itself. New here? Download the archive for your system below, extract it, " "and run `horizon-launcher`. Website: https://playhorizon.dev", diff --git a/website/docs/faq.md b/website/docs/faq.md index ee353a0c6..3bde1e7ea 100644 --- a/website/docs/faq.md +++ b/website/docs/faq.md @@ -60,7 +60,7 @@ Only if you say yes, and each kind has its own switch. Everything is off by defa ## How often does it update? -Often. Every change players can see is released automatically after it is merged, so new versions can come out several times a day. On the **Nightly** channel the launcher installs each one as soon as it is built; on **Stable**, the default, it installs a tested build about once a day. See [Install](/docs/install#updating). +Often. Every change players can see is released automatically after it is merged, so new versions can come out several times a day. On the **Alpha** channel the launcher installs each one as soon as it is built; on **Stable**, the default, it installs a tested build about once a day. See [Install](/docs/install#updating). ## How do I report a bug? diff --git a/website/docs/index.md b/website/docs/index.md index 1d3516836..4acdd49d0 100644 --- a/website/docs/index.md +++ b/website/docs/index.md @@ -7,7 +7,7 @@ Horizon is Minecraft: Java Edition 26.3 rewritten in Rust. You install it with a - **A new game program, not a mod.** Horizon is written from scratch in Rust. It reads the same worlds, plays by the same rules and generates the same terrain as the Java game. - **Checked against vanilla.** {{HARNESSES}} automated tests ("harnesses") feed the same inputs to Horizon and to the real game, then compare the results. Today every subsystem matches in every harness that compares it. That is {{PERCENT}} of what the harnesses compare, which is not proof that nothing else differs. The [status table](/#parity) lists what is covered. - **Light and fast.** It starts quickly, uses little memory and draws efficiently. See [Performance](/docs/performance) for what is measured and what is not. -- **A few things vanilla doesn't have.** Its own menus (vanilla's are one setting away), graphics presets, distant terrain, controller support, optional extras such as zoom, a minimap and dynamic lights (dynamic lights are in Nightly builds for now), an invite code to play your world with friends, and a server you can run without Java. +- **A few things vanilla doesn't have.** Its own menus (vanilla's are one setting away), graphics presets, distant terrain, controller support, optional extras such as zoom, a minimap and dynamic lights (dynamic lights are in Alpha builds for now), an invite code to play your world with friends, and a server you can run without Java. ## What Horizon is not diff --git a/website/docs/install.md b/website/docs/install.md index 56ea15554..77a1d0171 100644 --- a/website/docs/install.md +++ b/website/docs/install.md @@ -37,16 +37,16 @@ The game opens on Horizon's own title screen. Your worlds, options and logs live - **Horizon.** The launcher looks for a new release when it starts and every four hours while it is open. With **Install new versions automatically** on (the default), it installs one and moves you to it if you were on the newest. New releases come out many times a day, and old versions stay installed until you remove them on the **Versions** page. - **The launcher.** It updates itself from its own releases, then shows **Restart** in its footer. -## Stable and Nightly +## Stable and Alpha -> **Next launcher release.** The Updates switch below is merged but not in a launcher release yet. Launcher 0.17 has a **Beta builds** switch in Settings instead, which installs every new build at once, as Nightly does. +> **Next launcher release.** The Updates switch below is merged but not in a launcher release yet. Launcher 0.17 has a **Beta builds** switch in Settings instead, which installs every new build at once, as Alpha does. In **Settings**, **Updates** picks which builds install by themselves: - **Stable** (the default): a tested build about once a day. -- **Nightly**: every change as soon as it is built, several times a day. It can break. A launcher left open looks for new builds every 30 minutes, instead of every four hours. +- **Alpha**: every change as soon as it is built, several times a day. It can break. A launcher left open looks for new builds every 30 minutes, instead of every four hours. -Every new release is a Nightly build first. Once a day (20:00 UTC, 21:00 in Paris in winter), the newest one that has been out for six hours, passed its smoke test and has no known blocker becomes Stable. "Nightly" is just the name: it updates many times a day, not once a night. The **Versions** page shows each version's channel, and you can install any of them by hand. +Every new release is an Alpha build first. Once a day (20:00 UTC, 21:00 in Paris in winter), the newest one that has been out for six hours, passed its smoke test and has no known blocker becomes Stable. Alpha builds come out many times a day, and Horizon as a whole is still in beta; Stable is the tested ones. The **Versions** page shows each version's channel, and you can install any of them by hand. ## The Versions page diff --git a/website/docs/multiplayer.md b/website/docs/multiplayer.md index e33b01084..ddd490aab 100644 --- a/website/docs/multiplayer.md +++ b/website/docs/multiplayer.md @@ -20,7 +20,7 @@ There is no Horizon server in the middle. The code holds the host's addresses an Guests join with the name their game uses. There is no account check, so only share the code with people you trust. -In Nightly builds, guests can also use the host's workstations: the crafter, loom, stonecutter, grindstone, anvil, smithing table, enchanting table, beacon, lectern and cartography table. Stable gets this once it has passed. +In Alpha builds, guests can also use the host's workstations: the crafter, loom, stonecutter, grindstone, anvil, smithing table, enchanting table, beacon, lectern and cartography table. Stable gets this once it has passed. ## Open to LAN diff --git a/website/docs/settings.md b/website/docs/settings.md index c01b99e74..53d2011a2 100644 --- a/website/docs/settings.md +++ b/website/docs/settings.md @@ -48,7 +48,7 @@ Shader packs are **experimental**. Put a pack's folder in the `shaderpacks` fold Horizon can run the full-screen effects of Java shader packs (OptiFine and Iris packs: colour grading, bloom, sky and fog effects). It does not run their geometry and shadow passes yet, so packs do not look as they do in Iris. Horizon also has its own shader pack format, in WGSL, with a `pack.toml` manifest, options and hot reload. It has full-screen passes too; stages that draw the world's terrain and shadows are planned. The details are in the [shader pack notes](https://github.com/ludovic111/horizon/blob/main/docs/shader-packs.md). -In Nightly builds, the **Shader Packs** page shows the full path of the `shaderpacks` folder with an **Open Folder** button, then one switch per pack. Turning a pack on picks it, and turning it off gives the vanilla picture. Packs tested so far: BSL, Complementary Reimagined, Steadfast and Sildur's Vibrant Extreme draw their full-screen passes; Bliss, Bloop, Noble, Photon and Rethinking Voxels do not load yet. To find packs, the launcher's **Mods** page installs shader packs from Modrinth (see [Mods and data packs](/docs/mods#finding-resource-packs-shader-packs-and-modpacks)). +In Alpha builds, the **Shader Packs** page shows the full path of the `shaderpacks` folder with an **Open Folder** button, then one switch per pack. Turning a pack on picks it, and turning it off gives the vanilla picture. Packs tested so far: BSL, Complementary Reimagined, Steadfast and Sildur's Vibrant Extreme draw their full-screen passes; Bliss, Bloop, Noble, Photon and Rethinking Voxels do not load yet. To find packs, the launcher's **Mods** page installs shader packs from Modrinth (see [Mods and data packs](/docs/mods#finding-resource-packs-shader-packs-and-modpacks)). ## Resource packs @@ -69,7 +69,7 @@ Horizon plays with PlayStation (DualShock 4 and DualSense), Xbox (360, One and S ## Extras -**Options, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, zoom, a minimap, an FPS counter, a keystroke display, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. In Nightly builds there is one more, **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. +**Options, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, zoom, a minimap, an FPS counter, a keystroke display, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. In Alpha builds there is one more, **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. ## Where your settings are stored From 0eaa13020cc16264f6e0488da7e7108f013750cd Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:18:39 +0100 Subject: [PATCH 37/59] perf: load uniform saved light without expanding nibble layers --- crates/horizon-client/src/save.rs | 214 +++++++++++++++++++++++++- docs/saved-light-loading-benchmark.md | 44 ++++++ 2 files changed, 256 insertions(+), 2 deletions(-) create mode 100644 docs/saved-light-loading-benchmark.md diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 2e1eb8455..0cfe3c585 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -1305,8 +1305,73 @@ pub fn load_light(tag: &Tag, chunk: &mut Chunk, sky_light: bool) { }; layers[si as usize] = (layer("SkyLight"), layer("BlockLight")); } - let above = [if sky_light { 15 } else { 0 }; 256]; - crate::light::light_from_layers(chunk, &layers, above, sky_light); + // Uniform saved layers need no expanded allocation. Both nibbles of + // each byte must match, not merely the bytes across the layer. + let uniform_layer = |layer: &[u8]| { + let first = layer[0]; + (first & 15 == first >> 4 && layer.iter().all(|&v| v == first)).then_some(first & 15) + }; + let mut above = [if sky_light { 15 } else { 0 }; 256]; + for (si, (sky, block)) in layers.into_iter().enumerate().rev() { + let sky = sky.filter(|_| sky_light); + let sky_uniform = sky.map_or_else( + || above.iter().all(|&v| v == above[0]).then_some(above[0]), + uniform_layer, + ); + let block_uniform = block.map_or(Some(0), uniform_layer); + let section = Arc::make_mut(&mut chunk.sections[si]); + if let (Some(s), Some(b)) = (sky_uniform, block_uniform) { + section.light = Light::Uniform(s << 4 | b); + above.fill(s); + } else { + let mut data = Box::new([0u8; 4096]); + match (sky, block) { + (Some(sky), Some(block)) => { + for ((pair, &s), &b) in + data.as_chunks_mut::<2>().0.iter_mut().zip(sky).zip(block) + { + pair[0] = s << 4 | (b & 15); + pair[1] = (s & 0xf0) | (b >> 4); + } + } + (Some(sky), None) => { + for (pair, &s) in data.as_chunks_mut::<2>().0.iter_mut().zip(sky) { + pair[0] = s << 4; + pair[1] = s & 0xf0; + } + } + (None, Some(block)) => { + for (i, (pair, &b)) in data + .as_chunks_mut::<2>() + .0 + .iter_mut() + .zip(block) + .enumerate() + { + pair[0] = above[(i * 2) & 255] << 4 | (b & 15); + pair[1] = above[(i * 2 + 1) & 255] << 4 | (b >> 4); + } + } + (None, None) => { + for layer in data.as_chunks_mut::<256>().0 { + for (v, &s) in layer.iter_mut().zip(&above) { + *v = s << 4; + } + } + } + } + if let Some(sky) = sky { + for (pair, &s) in above.as_chunks_mut::<2>().0.iter_mut().zip(sky) { + pair[0] = s & 15; + pair[1] = s >> 4; + } + } + section.light = Light::Full(data); + } + section.compact(); + } + chunk.lit = true; + chunk.light_loaded = true; } type RegionCache = Mutex>>>>; @@ -3892,6 +3957,151 @@ mod tests { assert!(!unlit.lit && !unlit.light_loaded); } #[test] + fn saved_light_matches_reference_for_layers_and_metadata() { + fn reference(tag: &Tag, chunk: &mut Chunk, sky_light: bool) { + if tag.get("isLightOn") != Some(&Tag::Byte(1)) { + return; + } + let Some(Tag::List(sections)) = tag.get("sections") else { + return; + }; + let mut layers: Vec<(Option<&[u8]>, Option<&[u8]>)> = vec![(None, None); SECTIONS]; + for section in sections { + let Some(y) = number(section.get("Y")) else { + continue; + }; + let si = y as i32 - (MIN_Y >> 4); + if !(0..SECTIONS as i32).contains(&si) { + continue; + } + let layer = |name: &str| match section.get(name) { + Some(Tag::ByteArray(a)) if a.len() == 2048 => Some(&a[..]), + _ => None, + }; + layers[si as usize] = (layer("SkyLight"), layer("BlockLight")); + } + let above = [if sky_light { 15 } else { 0 }; 256]; + crate::light::light_from_layers(chunk, &layers, above, sky_light); + } + + let section = |y: Tag, sky: Option, block: Option| { + let mut entries = vec![("Y", y)]; + if let Some(v) = sky { + entries.push(("SkyLight", v)); + } + if let Some(v) = block { + entries.push(("BlockLight", v)); + } + Tag::compound(entries) + }; + let root = |sections| { + Tag::compound([ + ("isLightOn", Tag::Byte(1)), + ("sections", Tag::List(sections)), + ]) + }; + let check = |tag: &Tag| { + for sky_light in [false, true] { + let mut expected = Chunk::empty(-3, 5); + let s = Arc::make_mut(&mut expected.sections[0]); + s.light = Light::Full(Box::new([0xab; 4096])); + s.blocks.set(0, 1); + s.blocks.set(0, 0); + s.biomes.set(0, 1); + s.biomes.set(0, 0); + let mut actual = expected.clone(); + reference(tag, &mut expected, sky_light); + load_light(tag, &mut actual, sky_light); + assert_eq!( + (actual.lit, actual.light_loaded), + (expected.lit, expected.light_loaded) + ); + for (a, b) in actual.sections.iter().zip(&expected.sections) { + assert_eq!( + std::mem::discriminant(&a.light), + std::mem::discriminant(&b.light) + ); + assert_eq!( + format!("{:?}", a.blocks.to_wire()), + format!("{:?}", b.blocks.to_wire()) + ); + assert_eq!( + format!("{:?}", a.biomes.to_wire()), + format!("{:?}", b.biomes.to_wire()) + ); + for i in 0..4096 { + assert_eq!(a.light(i), b.light(i), "index {i}, sky {sky_light}"); + } + } + } + }; + for tag in [ + Tag::compound(Vec::<(&str, Tag)>::new()), + Tag::compound([("isLightOn", Tag::Byte(0))]), + Tag::compound([("isLightOn", Tag::Byte(2))]), + Tag::compound([("isLightOn", Tag::Int(1)), ("sections", Tag::List(vec![]))]), + Tag::compound([("isLightOn", Tag::Byte(1)), ("sections", Tag::Int(0))]), + root(vec![]), + ] { + check(&tag); + } + // Cover every repeated byte, including 0xF0/0x0F: a uniform byte + // array need not hold uniform nibbles. + for byte in 0..=255u8 { + check(&root(vec![section( + Tag::Byte(19), + Some(Tag::ByteArray(vec![byte; 2048])), + Some(Tag::ByteArray(vec![255 - byte; 2048])), + )])); + } + // Every pair of uniform sky/block nibble values, with missing + // sections below inheriting the stored bottom row. + for sky in 0..16u8 { + for block in 0..16u8 { + check(&root(vec![section( + Tag::Byte(1), + Some(Tag::ByteArray(vec![sky * 17; 2048])), + Some(Tag::ByteArray(vec![block * 17; 2048])), + )])); + } + } + for length in [0, 1, 2047, 2048, 2049] { + for invalid in [ + Tag::Int(1), + Tag::List(vec![]), + Tag::ByteArray(vec![0xf0; length]), + ] { + check(&root(vec![section( + Tag::Byte(-4), + Some(invalid.clone()), + Some(invalid), + )])); + } + } + let varied: Vec = (0..2048) + .map(|i| (i as u8).wrapping_mul(73).wrapping_add(31)) + .collect(); + check(&root(vec![ + section(Tag::Byte(-5), Some(Tag::ByteArray(varied.clone())), None), + section(Tag::Byte(20), Some(Tag::ByteArray(varied.clone())), None), + section( + Tag::String("19".into()), + Some(Tag::ByteArray(varied.clone())), + None, + ), + section(Tag::Byte(19), Some(Tag::ByteArray(varied.clone())), None), + section(Tag::Byte(17), None, Some(Tag::ByteArray(varied.clone()))), + section(Tag::Byte(-4), Some(Tag::ByteArray(varied.clone())), None), + // Last duplicate wins, even when its arrays have wrong types. + section( + Tag::Byte(-4), + Some(Tag::Int(15)), + Some(Tag::ByteArray(vec![7; 2047])), + ), + section(Tag::Byte(0), None, Some(Tag::ByteArray(varied))), + ])); + } + #[test] fn level_round_trips_through_the_vanilla_files() { let dir = std::env::temp_dir().join(format!("horizon-level-{}", std::process::id())); let _ = fs::remove_dir_all(&dir); diff --git a/docs/saved-light-loading-benchmark.md b/docs/saved-light-loading-benchmark.md new file mode 100644 index 000000000..f11d72443 --- /dev/null +++ b/docs/saved-light-loading-benchmark.md @@ -0,0 +1,44 @@ +# Saved-light loading benchmark + +Saved-light reconstruction reduces complete saved-chunk loading by a median **6.179% on the normal world** and **10.981% on the flat world**, incremental to the accepted palette-loading optimization. Every measured process pair improves. The implementation changes only `save.rs::load_light` and its tests. + +## Implementation and scope + +Detect uniform stored nibble layers before allocating expanded resident light. Both nibbles must match: repeated bytes such as `0xF0` and `0x0F` remain nonuniform. Decode two resident light values per stored byte for remaining layers. Preserve section compaction, low-nibble-first indexing, missing-block darkness, missing-sky bottom-row inheritance, skyless behavior, section bounds, last duplicate section, invalid array handling, and loaded flags. Pinned Minecraft 26.3 `DataLayer` and `SkyLightSectionStorage.repeatFirstLayer` bytecode was inspected first. No saved-light optimization overlap was found among the 34 open PRs checked on 2026-10-22. + +## Measurements + +Baseline `411c5574` includes accepted palette loading and aquifer changes; the candidate differs only in saved-light reconstruction. Both loader executables were rebuilt from those sources using identical benchmark source (SHA256 `b6f5042731d7c9d5622758043f7c1e125a3f7d098c57ee0501012474c2df7325`), dependencies, resources and flags. Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM; Linux 7.2.11-zen1-1-zen; Rust 1.99.0. Release optimization, thin LTO, one codegen unit, client default features disabled; CPU boost enabled, powersave governor, ordinary desktop activity. No builds, tests or profiles overlapped timing. + +Each corpus uses one discarded process pair followed by five measured pairs in alternating baseline/candidate order. Each observation is a process's median of five rounds loading the same sorted 256 full chunks. Checksumming and setup are outside timing; allocation/destruction and region reads/decompression/NBT/native decode/saved light are inside complete loading. Storage is warm. Reductions are medians/ranges of paired reductions; independently reported medians need not give the same ratio. Separate stage loops do not sum to a timing breakdown. + +| Corpus | Complete load, baseline → candidate | Paired reduction (range) | Inflate/NBT, baseline → candidate | Native decode, baseline → candidate | +| --- | ---: | ---: | ---: | ---: | +| Normal vanilla 26.3, seed 12345 | 50.036 → 47.005 ms | 6.179% (5.217–6.836%) | 22.187 → 22.087 ms | 20.464 → 21.621 ms | +| Flat vanilla 26.3 | 12.030 → 10.688 ms | 10.981% (10.423–11.751%) | 4.562 → 4.549 ms | 4.076 → 4.183 ms | + +Values are milliseconds per complete 256-chunk batch. The separate native-decode loop slows by a paired median 4.644% on normal and 3.185% on flat; the flat observations are variable. Its source is unchanged, and the cause of this separate-loop change was not isolated. Complete `SaveDir::load`, which includes native decode and saved light, improves in all ten measured pairs. The earlier two-pair normal pilot improved 5.894% and 6.553%; final-source qualification was repeated after the iterator syntax change. All timed compressed-record and block/biome/light hashes agree. Normal compressed records: `ff9bf9e822e334e117e3d6ba5c26a88b7698456ec6d83bdbe4355ad0af1d6f55`; block/biome/light: `661dd26eed78b051afeca11d8ba69222162b5da72e5d1572a12ce2a3b3a4f764`. + +## Correctness + +All 20 save unit tests pass. The new differential test compares the original loader with the candidate for every repeated packed byte, all 256 pairs of uniform sky/block nibble values, nonuniform inherited rows, missing/wrong layer types and lengths, skyless dimensions, out-of-range/invalid section Y values and duplicate sections. It compares every resident light value, uniform/full representation, block/biome storage and loaded flags. + +A fresh pinned Java 26.3 oracle uses `DataLayer.get` and `SkyLightSectionStorage.repeatFirstLayer` over all 256 repeated byte patterns in both sky modes. Baseline and candidate exactly match all **50,331,648 light values** plus flags (SHA256 `608bab077edc713110f827740cb5d9baf2af9c1a251ea2458441e2d981f25920`). + +The same comprehensive snapshot harness runs on the actual accepted-source baseline and final candidate: **400 normal chunks, 289 flat chunks, and two synthetic unknown-NBT/nonempty-tick cases**. All 691 outputs match byte-for-byte. It covers resident blocks/biomes/light, complete reencoded NBT, heightmaps, block entities and their saved sources/order, structures, unknown NBT, ticks, postprocessing, entities, names and loaded/arrival flags. Light representation is additionally covered by the unit test. Temporary diagnostic sources were removed. + +The final source uses the fixed-size chunk iterator syntax required by Clippy. Its rebuilt executable (SHA256 `40d7031e7d3efe785815b1286af05553807bbc59f66a9275a5f89191f0ecda7e`) is the one used for final qualification; snapshot/oracle harnesses use the same production source. Earlier pilot artifacts are retained separately: section extraction normalized ELF metadata (original timed SHA256 `eb28209fd54b6deedab1ff701c291ae36b8116b2ba52a02d1ec82600b57e427f`; normalized SHA256 `78f2092b2661655fdea8d0fa2247389ccc8f48f37dd9abfbb8d8864867187297`). Those earlier artifacts are superseded by the final-source qualification. + +The required repository quick self-check passes: public-tree validation, formatting, Clippy with warnings denied, **1,443 client/core/world tests**, and the doc-test step. Command: `RUST_TEST_THREADS=1 CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-check-target python3 tools/pr_ready.py --quick --base origin/main` (11 min 15 s). Tests were serialized after an initial client-test process SIGSEGV; the failed log is retained as `pr-ready-attempt1.txt`. Relevant oracle checks were run separately; `--quick` lists other affected parity harnesses for CI. + +## Reproduction and evidence + +Private/generated evidence: `/srv/bob-data/horizon-chunk-campaign-41055168/saved-light/`. Preserved baseline/candidate sources and executables, source/binary hashes, open-PR catalog, pinned bytecode, build logs, `final-pairs.py`, `final-raw.json`, final qualification logs and `final-summary.json`; earlier pilot/qualification artifacts are retained there. Resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Normal corpus: `/srv/bob-data/horizon-chunk-campaign-41055168/vanilla-normal/world/dimensions/minecraft/overworld`; flat: `/srv/bob-data/horizon/.local/locator-bar-parity/generate/world/dimensions/minecraft/overworld`. + +```sh +CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-target cargo build --locked --release -p horizon-client --no-default-features --example load_bench +load_bench RESOURCES DIMENSION_DIR --rounds 5 --limit 256 --checksum +python3 /srv/bob-data/horizon-chunk-campaign-41055168/saved-light/final-pairs.py final 5 +``` + +These results cover the declared warm saved-load workloads. Cold physical I/O, remote chunk streams and complete gameplay parity are outside this comparison. From 756cf4af07901f18d4e5b8e95a7d293b7f144231 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:18:40 +0100 Subject: [PATCH 38/59] bench: measure read-only saved chunk loading --- crates/horizon-client/examples/load_bench.rs | 153 +++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 crates/horizon-client/examples/load_bench.rs diff --git a/crates/horizon-client/examples/load_bench.rs b/crates/horizon-client/examples/load_bench.rs new file mode 100644 index 000000000..5c30a71ff --- /dev/null +++ b/crates/horizon-client/examples/load_bench.rs @@ -0,0 +1,153 @@ +//! Read-only saved chunk benchmark. All timings exclude resource/corpus setup. +//! +//! load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum] +//! Add --profile-worker when a sampling collector cannot sample the main thread. +//! Reports warm filesystem SaveDir::load (read, inflate, NBT, decode and light), +//! plus isolated inflate/NBT and native decode. No files in the save are changed. +use horizon_client::{ + assets::Assets, + biome::Biomes, + blocks::BlockFacts, + save::{SaveDir, SaveTables, decode_with}, +}; +use horizon_world::{nbt::Limits, region::RegionFile}; +use sha2::{Digest, Sha256}; +use std::{hint::black_box, path::PathBuf, sync::Arc, time::Instant}; + +type Result = std::result::Result>; + +fn main() -> Result<()> { + if std::env::args().any(|a| a == "--profile-worker") { + std::thread::spawn(|| run().map_err(|e| e.to_string())) + .join() + .expect("benchmark worker") + .map_err(Into::into) + } else { + run() + } +} + +fn run() -> Result<()> { + let args: Vec = std::env::args().skip(1).collect(); + let usage = "load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum]"; + let root = PathBuf::from(args.first().ok_or(usage)?); + let dimension = PathBuf::from(args.get(1).ok_or(usage)?); + let flag = |name: &str, default: usize| -> Result { + Ok(match args.iter().position(|a| a == name) { + Some(i) => args.get(i + 1).ok_or(usage)?.parse()?, + None => default, + }) + }; + let rounds = flag("--rounds", 5)?; + let limit = flag("--limit", 256)?; + if rounds == 0 || limit == 0 { + return Err("rounds and limit must be positive".into()); + } + let assets = Assets::load(&root)?; + let facts = BlockFacts::load(&root, assets.registry)?; + let biomes = Biomes::load(&root)?; + let tables = Arc::new(SaveTables::new(&assets).with_block_entities(&facts)); + let source = SaveDir::new(dimension.clone()); + let _ = source.tables.set(tables.clone()); + let mut paths: Vec<_> = std::fs::read_dir(dimension.join("region"))? + .map(|e| e.map(|e| e.path())) + .collect::>()?; + paths.retain(|p| p.extension().is_some_and(|e| e == "mca")); + paths.sort(); + let mut corpus = Vec::new(); + 'regions: for path in paths { + let mut region = RegionFile::open(path)?; + let mut positions: Vec<_> = region.chunks().map(|(pos, _)| pos).collect(); + positions.sort_by_key(|p| (p.x, p.z)); + for pos in positions { + let record = region.read(pos)?.ok_or("missing record")?; + let tag = record.nbt(Limits::default())?; + if decode_with(&tag, assets.registry, &biomes, Some(&tables)).is_none() { + continue; + } + corpus.push((pos, record, tag)); + if corpus.len() == limit { + break 'regions; + } + } + } + if corpus.is_empty() { + return Err("no full chunks in corpus".into()); + } + let mut records_hash = Sha256::new(); + for (pos, record, _) in &corpus { + records_hash.update(pos.x.to_le_bytes()); + records_hash.update(pos.z.to_le_bytes()); + records_hash.update((record.compressed.len() as u64).to_le_bytes()); + records_hash.update(&record.compressed); + } + println!( + "{}", + serde_json::json!({"corpus": dimension, "chunks": corpus.len(), "rounds": rounds, + "compressed_records_sha256": format!("{:x}", records_hash.finalize()), + "compressed_bytes": corpus.iter().map(|(_, r, _)| r.compressed.len()).sum::()}) + ); + // Prime SaveDir's region handles and the filesystem cache before measurement. + for (pos, _, _) in &corpus { + black_box( + source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?, + ); + } + for round in 0..rounds { + let started = Instant::now(); + for (pos, _, _) in &corpus { + black_box( + source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?, + ); + } + let load_s = started.elapsed().as_secs_f64(); + let started = Instant::now(); + for (_, record, _) in &corpus { + black_box(record.nbt(Limits::default())?); + } + let nbt_s = started.elapsed().as_secs_f64(); + let started = Instant::now(); + for (_, _, tag) in &corpus { + black_box( + decode_with(tag, assets.registry, &biomes, Some(&tables)).ok_or("decode failed")?, + ); + } + let decode_s = started.elapsed().as_secs_f64(); + println!( + "{}", + serde_json::json!({"round": round, "load_s": load_s, + "inflate_nbt_s": nbt_s, "decode_s": decode_s}) + ); + } + if args.iter().any(|a| a == "--checksum") { + let mut hash = Sha256::new(); + let mut light_loaded = 0; + for (pos, _, _) in &corpus { + let chunk = source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?; + hash.update(pos.x.to_le_bytes()); + hash.update(pos.z.to_le_bytes()); + light_loaded += usize::from(chunk.light_loaded); + for section in &chunk.sections { + for i in 0..4096 { + hash.update(section.get(i).to_le_bytes()); + hash.update([section.light(i)]); + } + for i in 0..64 { + hash.update(section.biomes.get(i).to_le_bytes()); + } + } + } + println!( + "{}", + serde_json::json!({"blocks_biomes_light_sha256": format!("{:x}", hash.finalize()), + "light_loaded": light_loaded}) + ); + } + Ok(()) +} From 5b44452284e8f347db31a64252640e846b322e1c Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:35:42 +0200 Subject: [PATCH 39/59] fix(protocol): read PARTICLES as a list; keep every particle's data Review fixes on top of the particle serializers: - PARTICLES (17) is List: a VarInt count, then each particle. Reading it as one particle only worked for empty lists, so a living entity with effect particles (LivingEntity.DATA_EFFECT_PARTICLES) misread everything after it. Value::Particles holds the list. - Item particles use ItemStackTemplate.STREAM_CODEC (item, count, patch), not the optional slot codec. - Vibration keeps its position source (block position or entity id and y offset) so it writes back the bytes it read; geyser data keeps its Int exactly instead of going through f32. - Enchantment names come from the server's synced registry, not the builtin report (enchantment is data-driven). - Armor stands: 26.3's DEFAULT_DEPTH_CLEAR_VALUE is 0.0 (bytecode dconst_0), so a marker's empty box falls back to a range of 4 and a visible marker stand draws; restore that. Holograms stay hidden through the invisible flag. Test: particles_round_trip covers every data shape, a PARTICLES list and the entry after it. Co-Authored-By: Claude Opus 5.5 --- .../horizon-client/src/game/armor_stands.rs | 9 +- crates/horizon-client/src/game/remote.rs | 6 +- crates/horizon-protocol/src/entity_data.rs | 326 +++++++++++------- 3 files changed, 210 insertions(+), 131 deletions(-) diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs index 018c3d7ab..9fd41bb55 100644 --- a/crates/horizon-client/src/game/armor_stands.rs +++ b/crates/horizon-client/src/game/armor_stands.rs @@ -432,10 +432,11 @@ impl Game<'_> { (false, false) => (0.5, 1.975), }; let edge = (width + height + width) / 3.0 * 4.0; - // A marker's empty box gives a range of zero: vanilla's - // `distance < 0` never holds, so marker stands never draw. - let edge = if edge == 1.0 { 4.0 } else { edge }; - let range = edge * 64.0; + // 26.3 compares the size with RenderSystem.DEFAULT_DEPTH_CLEAR_VALUE, + // which is 0.0 (reverse Z; the bytecode is `dconst_0`): an empty + // marker box falls back to 4, so a visible marker stand draws. + // Holograms stay hidden through the invisible flag instead. + let range = if edge == 0.0 { 4.0 } else { edge } * 64.0; let dragon = a.equipment[5] .as_ref() .is_some_and(|i| &*i.item == "minecraft:dragon_head"); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index a1e10576c..ea8137776 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -594,9 +594,11 @@ impl Game<'_> { ("resolved", Tag::Byte(i8::from(b.resolved))), ]), Component::Enchantments(list) => { - let registry = r.builtin.get("minecraft:enchantment"); + // Enchantments are a synced (data-driven) registry: the + // ids index the server's RegistryData, not the builtin + // report, so a datapack enchantment names correctly. let levels = list.iter().filter_map(|(id, level)| { - let name = registry?.name(*id)?; + let name = r.registries.name("minecraft:enchantment", *id)?; Some((name, Tag::Int(*level))) }); Tag::compound(levels) diff --git a/crates/horizon-protocol/src/entity_data.rs b/crates/horizon-protocol/src/entity_data.rs index 4c6879362..574afd300 100644 --- a/crates/horizon-protocol/src/entity_data.rs +++ b/crates/horizon-protocol/src/entity_data.rs @@ -5,7 +5,7 @@ use crate::{ Result, buf::{Codec, Reader, Writer}, - item::{Slot, Stack}, + item::{Slot, Stack, Template}, }; use horizon_world::nbt::Tag; @@ -32,8 +32,11 @@ pub enum Value { /// Rendered nowhere (the client spawns no world particles yet); decoded /// so the rest of an entry list survives a particle slot. Particle(Particle), + /// A particle list (PARTICLES: a VarInt count, then each particle). + Particles(Vec), } -/// The optional data of one particle type (26.3 registry order). +/// One `ParticleTypes.STREAM_CODEC` value: the `minecraft:particle_type` id, +/// then the data its type carries (26.3 registry order). #[derive(Clone, Debug, PartialEq)] pub struct Particle { pub id: i32, @@ -44,35 +47,131 @@ pub enum ParticleData { /// Block state id (block, block_marker, falling_dust, dust_pillar, /// block_crumble). State(i32), - /// Geometry-wide or ARGB color (effect, entity_effect, tinted_leaves, - /// flash); flame family colors keep the top bits in one Int. - Color(#[allow(dead_code)] i32), - /// Dust family: color then scale. + /// ARGB color (entity_effect, tinted_leaves, flash). + Color(i32), + /// Dust: color then scale. ColorScale(i32, f32), /// Dust color transition: from color, to color, scale. ColorScale2(i32, i32, f32), - /// Effect family: color then power. + /// Spell (effect, instant_effect): color then power. ColorPower(i32, f32), /// A bare float (dragon_breath power, sculk_charge roll). Scalar(f32), /// Delay in ticks (shriek). Delay(i32), - /// A position plus ticks (trail): 3 doubles, ARGB color, duration. + /// Trail: target (3 doubles), ARGB color, duration. Trail([f64; 3], i32, i32), - /// An item stack (item). - Item(Option), - /// One generic Int (geyser water blocks) or Int then Float - /// (geyser_base, geyser_poof); plus the tick count of a vibration. - Ints(Vec), - /// Side effect: which registered particle carries which data shape. - Vibration { - #[allow(dead_code)] - source: i32, - #[allow(dead_code)] - eye: Option, - #[allow(dead_code)] - ticks: i32, - }, + /// An item (ItemStackTemplate: item, count, patch). + Item(Stack), + /// Geyser and geyser_plume: water blocks. + Geyser(i32), + /// Geyser_base and geyser_poof: water blocks, then the burst impulse. + GeyserBase(i32, f32), + /// Vibration: where it travels to, then its arrival time in ticks. + Vibration { source: PositionSource, ticks: i32 }, +} +/// `PositionSource.STREAM_CODEC`: a `minecraft:position_source_type` id +/// (block 0, entity 1), then that type's data. +#[derive(Clone, Debug, PartialEq)] +pub enum PositionSource { + Block([i32; 3]), + Entity { id: i32, y_offset: f32 }, +} +impl Particle { + pub fn read(r: &mut Reader) -> Result { + let id = r.varint()?; + // `minecraft:particle_type` registry order as of 26.3. + let data = match id { + 1 | 2 | 36 | 121 | 125 => Some(ParticleData::State(r.varint()?)), + 28 | 46 | 52 => Some(ParticleData::Color(r.i32()?)), + 21 => { + let color = r.i32()?; + Some(ParticleData::ColorScale(color, r.f32()?)) + } + 22 => { + let from = r.i32()?; + let to = r.i32()?; + Some(ParticleData::ColorScale2(from, to, r.f32()?)) + } + 23 | 56 => { + let color = r.i32()?; + Some(ParticleData::ColorPower(color, r.f32()?)) + } + 15 | 48 => Some(ParticleData::Scalar(r.f32()?)), + 115 => Some(ParticleData::Delay(r.varint()?)), + 59 => { + let at = [r.f64()?, r.f64()?, r.f64()?]; + let color = r.i32()?; + Some(ParticleData::Trail(at, color, r.varint()?)) + } + 57 => Some(ParticleData::Item(Template::read(r)?)), + 58 => { + let source = match r.varint()? { + 0 => PositionSource::Block(crate::buf::Pos::read(r)?), + 1 => { + let id = r.varint()?; + PositionSource::Entity { + id, + y_offset: r.f32()?, + } + } + kind => return Err(crate::Error::new(format!("position source type {kind}"))), + }; + Some(ParticleData::Vibration { + source, + ticks: r.varint()?, + }) + } + 7 | 10 => Some(ParticleData::Geyser(r.i32()?)), + 8 | 9 => { + let water = r.i32()?; + Some(ParticleData::GeyserBase(water, r.f32()?)) + } + // Every other registered particle carries no data. + _ => None, + }; + Ok(Particle { id, data }) + } + pub fn write(&self, w: &mut Writer) { + w.varint(self.id); + let Some(data) = &self.data else { return }; + match data { + ParticleData::State(s) | ParticleData::Delay(s) => w.varint(*s), + ParticleData::Color(c) | ParticleData::Geyser(c) => w.i32(*c), + ParticleData::ColorScale(c, f) + | ParticleData::ColorPower(c, f) + | ParticleData::GeyserBase(c, f) => { + w.i32(*c); + w.f32(*f); + } + ParticleData::ColorScale2(a, b, f) => { + w.i32(*a); + w.i32(*b); + w.f32(*f); + } + ParticleData::Scalar(f) => w.f32(*f), + ParticleData::Trail(at, c, d) => { + at.iter().for_each(|v| w.f64(*v)); + w.i32(*c); + w.varint(*d); + } + ParticleData::Item(s) => Template::write(s, w), + ParticleData::Vibration { source, ticks } => { + match source { + PositionSource::Block(pos) => { + w.varint(0); + crate::buf::Pos::write(pos, w); + } + PositionSource::Entity { id, y_offset } => { + w.varint(1); + w.varint(*id); + w.f32(*y_offset); + } + } + w.varint(*ticks); + } + } + } } /// Serializer ids in EntityDataSerializers registration order. pub mod serializer { @@ -158,63 +257,14 @@ fn read_value(kind: i32, r: &mut Reader) -> Result> { | PAINTING_VARIANT..=WEATHERING_COPPER_STATE | HUMANOID_ARM | DYE_COLOR => Value::Id(r.varint()?), - PARTICLE | PARTICLES => { - let id = r.varint()?; - // `minecraft:particle_type` registry order as of 26.3. - let data = match id { - 1 | 2 | 36 | 121 | 125 => Some(ParticleData::State(r.varint()?)), - 28 | 46 | 52 => Some(ParticleData::Color(r.i32()?)), - 21 => { - let color = r.i32()?; - let scale = r.f32()?; - Some(ParticleData::ColorScale(color, scale)) - } - 22 => { - let from = r.i32()?; - let to = r.i32()?; - let scale = r.f32()?; - Some(ParticleData::ColorScale2(from, to, scale)) - } - 23 | 56 => { - let color = r.i32()?; - let power = r.f32()?; - Some(ParticleData::ColorPower(color, power)) - } - 15 | 48 => Some(ParticleData::Scalar(r.f32()?)), - 115 => Some(ParticleData::Delay(r.varint()?)), - 59 => { - let x = r.f64()?; - let y = r.f64()?; - let z = r.f64()?; - let color = r.i32()?; - let duration = r.varint()?; - Some(ParticleData::Trail([x, y, z], color, duration)) - } - 57 => Some(ParticleData::Item(Slot::read(r)?)), - 58 => { - let source = r.varint()?; - let mut eye = None; - if source == 0 { - let _ = crate::buf::Pos::read(r)?; - } else { - let _ = r.varint()?; - eye = Some(r.f32()?); - } - let ticks = r.varint()?; - Some(ParticleData::Vibration { source, eye, ticks }) - } - 7..=10 => { - let mut ints = vec![r.i32()? as f32]; - if id == 8 || id == 9 { - ints.push(r.f32()?); - } - Some(ParticleData::Ints(ints)) - } - // Every other registered particle carries no data. - _ => None, - }; - // Not into Ok(Some(..)): the match arm is inside the outer Option. - Value::Particle(Particle { id, data }) + PARTICLE => Value::Particle(Particle::read(r)?), + PARTICLES => { + let n = r.count(65536)?; + let mut list = Vec::with_capacity(n.min(64)); + for _ in 0..n { + list.push(Particle::read(r)?); + } + Value::Particles(list) } _ => return Ok(None), })) @@ -250,52 +300,10 @@ fn write_value(kind: i32, v: &Value, w: &mut Writer) { w.uuid(*u); } } - Value::Particle(p) => { - w.varint(p.id); - if let Some(data) = &p.data { - match data { - ParticleData::State(s) => w.varint(*s), - ParticleData::Color(c) => w.i32(*c), - ParticleData::ColorScale(c, s) => { - w.i32(*c); - w.f32(*s); - } - ParticleData::ColorScale2(a, b, s) => { - w.i32(*a); - w.i32(*b); - w.f32(*s); - } - ParticleData::ColorPower(c, p) => { - w.i32(*c); - w.f32(*p); - } - ParticleData::Scalar(f) => w.f32(*f), - ParticleData::Delay(d) => w.varint(*d), - ParticleData::Trail(at, c, d) => { - at.iter().for_each(|v| w.f64(*v)); - w.i32(*c); - w.varint(*d); - } - ParticleData::Item(s) => Slot::write(s, w), - ParticleData::Ints(ints) => { - let mut iter = ints.iter(); - if let Some(v) = iter.next() { - w.i32(*v as i32); - } - for v in iter { - w.f32(*v); - } - } - ParticleData::Vibration { source, eye, ticks } => { - w.varint(*source); - let _ = source; - if let Some(eye) = eye { - w.f32(*eye); - } - w.varint(*ticks); - } - } - } + Value::Particle(p) => p.write(w), + Value::Particles(list) => { + w.varint(list.len() as i32); + list.iter().for_each(|p| p.write(w)); } } let _ = kind; @@ -379,4 +387,72 @@ mod tests { entries ); } + + /// Every particle data shape (26.3 codecs) round-trips, and a PARTICLES + /// list is a VarInt count then each particle, so the entry after it + /// still decodes. + #[test] + fn particles_round_trip() { + let all = [ + (1, Some(ParticleData::State(2))), + (7, Some(ParticleData::Geyser(5))), + (8, Some(ParticleData::GeyserBase(3, 0.5))), + (15, Some(ParticleData::Scalar(1.0))), + (21, Some(ParticleData::ColorScale(0xff0000, 1.5))), + (22, Some(ParticleData::ColorScale2(1, 2, 0.75))), + (23, Some(ParticleData::ColorPower(-1, 2.0))), + (28, Some(ParticleData::Color(0x7f00ff00))), + ( + 57, + Some(ParticleData::Item(Stack { + item: 42, + count: 3, + added: Vec::new(), + removed: vec![7], + })), + ), + ( + 58, + Some(ParticleData::Vibration { + source: PositionSource::Block([-12, 64, 300]), + ticks: 20, + }), + ), + ( + 58, + Some(ParticleData::Vibration { + source: PositionSource::Entity { + id: 99, + y_offset: 1.25, + }, + ticks: 8, + }), + ), + (59, Some(ParticleData::Trail([1.5, -2.0, 3.25], 9, 40))), + (115, Some(ParticleData::Delay(6))), + (0, None), + ] + .map(|(id, data)| Particle { id, data }); + let mut entries: Vec<_> = all + .iter() + .map(|p| (10u8, serializer::PARTICLE, Value::Particle(p.clone()))) + .collect(); + entries.push((11, serializer::PARTICLES, Value::Particles(all.to_vec()))); + entries.push((12, serializer::BYTE, Value::Byte(4))); + let mut w = Writer::new(); + EntityData::write(&entries, &mut w); + assert_eq!( + EntityData::read(&mut Reader::new(&w.data)).unwrap(), + entries + ); + // Wire shape: an empty list is one 0 byte, then the next entry. + let bytes = [11, serializer::PARTICLES as u8, 0, 12, 0, 4, 0xFF]; + assert_eq!( + EntityData::read(&mut Reader::new(&bytes)).unwrap(), + vec![ + (11, serializer::PARTICLES, Value::Particles(Vec::new())), + (12, serializer::BYTE, Value::Byte(4)), + ] + ); + } } From 05400438c7f034a380815b6ed606b181bb3bdb3b Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:44:32 +0100 Subject: [PATCH 40/59] perf(client): cache weather column direction table --- crates/horizon-client/src/weather.rs | 40 ++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/weather.rs b/crates/horizon-client/src/weather.rs index 3eb39e14c..ba15de9ae 100644 --- a/crates/horizon-client/src/weather.rs +++ b/crates/horizon-client/src/weather.rs @@ -114,10 +114,15 @@ pub fn snow_column( /// The constructor's 32x32 table of horizontal column half-widths, indexed /// relative to the camera block. The camera's own column divides 0 by 0. fn column_size(index: usize) -> (f32, f32) { - let delta_x = (index % 32) as f32 - 16.0; - let delta_z = (index / 32) as f32 - 16.0; - let distance = f64::from(delta_x * delta_x + delta_z * delta_z).sqrt() as f32; - (-delta_z / distance, delta_x / distance) + static SIZES: std::sync::LazyLock<[(f32, f32); 32 * 32]> = std::sync::LazyLock::new(|| { + std::array::from_fn(|index| { + let delta_x = (index % 32) as f32 - 16.0; + let delta_z = (index / 32) as f32 - 16.0; + let distance = f64::from(delta_x * delta_x + delta_z * delta_z).sqrt() as f32; + (-delta_z / distance, delta_x / distance) + }) + }); + SIZES[index] } /// `prepareInstances` for one column: rain uses `max_alpha` 1, snow 0.8. @@ -219,6 +224,27 @@ fn pieces(a: f32, b: f32) -> impl Iterator { mod tests { use super::*; + #[test] + fn column_size_table_matches_original_arithmetic() { + for z in 0..32 { + for x in 0..32 { + let delta_x = x as f32 - 16.0; + let delta_z = z as f32 - 16.0; + let distance = f64::from(delta_x * delta_x + delta_z * delta_z).sqrt() as f32; + let expected = [-delta_z / distance, delta_x / distance]; + let actual = column_size(z * 32 + x); + for (actual, expected) in [actual.0, actual.1].into_iter().zip(expected) { + if x == 16 && z == 16 { + assert!(expected.is_nan()); + assert!(actual.is_nan()); + } else { + assert_eq!(actual.to_bits(), expected.to_bits(), "column ({x}, {z})"); + } + } + } + } + } + #[test] fn rain_repeats_every_four_blocks() { let column = Column { @@ -282,6 +308,10 @@ mod tests { light_coords: 0, }; let quad = column_quad(&column, [0.5, 70.0, 0.5], 1.0, 10, 1.0); - assert!(quad[0].pos[0].is_nan()); + for vertex in quad { + assert!(vertex.pos[0].is_nan()); + assert!(vertex.pos[2].is_nan()); + assert!(vertex.pos[1].is_finite()); + } } } From 92b8cd692da2ffb244b4c81bb1a965d4608f956a Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:50:29 +0100 Subject: [PATCH 41/59] perf(client): retain the End sky mesh on the GPU --- crates/horizon-client/src/game.rs | 11 +- crates/horizon-client/src/game/end.rs | 45 +-- crates/horizon-client/src/gfx.rs | 25 +- crates/horizon-client/src/gfx/end_sky.rs | 84 +++++ .../horizon-client/src/gfx/end_sky/tests.rs | 330 ++++++++++++++++++ 5 files changed, 447 insertions(+), 48 deletions(-) create mode 100644 crates/horizon-client/src/gfx/end_sky.rs create mode 100644 crates/horizon-client/src/gfx/end_sky/tests.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..ccc838bbb 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9812,8 +9812,8 @@ impl Game<'_> { { // Camera.doesMobEffectBlockSky: no sun, moon or stars. self.celestial_geometry(&sky) - } else if self.dim == Dim::End { - (self.end_sky_geometry(), None) + } else if self.dim == Dim::End && self.settings.horizon.sky { + (self.end_flash_geometry(), None) } else { (Vec::new(), None) }; @@ -9860,6 +9860,12 @@ impl Game<'_> { title: title && !live, skybox: self.dim == Dim::Overworld && self.settings.horizon.sky, end_sky: self.dim == Dim::End && self.settings.horizon.sky, + end_sky_sprite: self + .gui + .atlas + .sprites + .get("environment/end_sky") + .map(|r| [r.u0, r.v0, r.u1, r.v1]), environment_fog: (self.dim == Dim::Nether).then_some((sky.fog_start, sky.fog_end)), cave_culling, water_fog, @@ -12363,6 +12369,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> { title: true, skybox: false, end_sky: false, + end_sky_sprite: None, environment_fog: None, water_fog: [0.0; 3], fog: None, diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index a7813c767..98a595f76 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -138,47 +138,12 @@ impl Game<'_> { } } - /// SkyRenderer.buildEndSky: six faces of end_sky.png tiled 16 times, - /// tinted 0x282828. The atlas does not wrap, so each face is 16×16 quads. - pub(super) fn end_sky_geometry(&self) -> Vec { - let mut out = Vec::with_capacity(6 * 256 * 4); - let Some(r) = self.gui.atlas.sprites.get("environment/end_sky").copied() else { + /// SkyRenderer.renderEndFlash, drawn after the renderer's resident sky mesh. + pub(super) fn end_flash_geometry(&self) -> Vec { + let mut out = Vec::new(); + // The old combined sky/flash draw also skipped the flash without a sky sprite. + if !self.gui.atlas.sprites.contains_key("environment/end_sky") { return out; - }; - use std::f32::consts::FRAC_PI_2; - let faces = [ - glam::Mat4::IDENTITY, - glam::Mat4::from_rotation_x(FRAC_PI_2), - glam::Mat4::from_rotation_x(-FRAC_PI_2), - glam::Mat4::from_rotation_x(std::f32::consts::PI), - glam::Mat4::from_rotation_z(FRAC_PI_2), - glam::Mat4::from_rotation_z(-FRAC_PI_2), - ]; - let step = 200.0 / 16.0; - for pose in faces { - for a in 0..16 { - for b in 0..16 { - let (x0, z0) = (-100.0 + step * a as f32, -100.0 + step * b as f32); - let (x1, z1) = (x0 + step, z0 + step); - let corners = [ - (x0, z0, [r.u0, r.v0]), - (x0, z1, [r.u0, r.v1]), - (x1, z1, [r.u1, r.v1]), - (x1, z0, [r.u1, r.v0]), - ]; - for (x, z, uv) in corners { - let p = pose.transform_point3(glam::Vec3::new(x, -100.0, z)); - out.push(Vertex { - normal: [0; 4], - pos: p.to_array(), - uv, - layer: 2, - color: 0xFF28_2828, - light: 0, - }); - } - } - } } // SkyRenderer.renderEndFlash: the end_flash sprite at height 100, scale 60. let intensity = self.end.flash.intensity(self.clock.fraction() as f32); diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..fb1cd322e 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -61,6 +61,7 @@ pub fn outline_vertices(edges: &[[f64; 6]], camera: glam::DVec3) -> Vec<[f32; 6] mod arena; mod cull; +mod end_sky; mod flat; mod java_stages; mod lod; @@ -163,8 +164,10 @@ pub struct Frame<'a> { pub title: bool, /// Dimensions without a skybox (the Nether) clear to the fog colour. pub skybox: bool, - /// The End: clear to black and draw `celestial` (the End sky box) behind the world. + /// The End: clear to black and draw the resident sky box behind the world. pub end_sky: bool, + /// End sky atlas bounds (u0, v0, u1, v1); absent when the sprite is missing. + pub end_sky_sprite: Option<[f32; 4]>, /// Environmental fog start/end (Nether 10..96), if any. pub environment_fog: Option<(f32, f32)>, pub water_fog: [f32; 3], @@ -197,8 +200,8 @@ pub struct Frame<'a> { pub additive: &'a [Vertex], /// Name tags over everything, without depth (`TEXT_SEE_THROUGH`). pub see_through: &'a [Vertex], - /// Camera-relative sun and moon, or the End sky box (drawn behind - /// everything, additive). + /// Camera-relative sun and moon, or the animated End flash (additive, + /// behind everything and after the resident End sky box). pub celestial: &'a [Vertex], /// The stars, drawn from their static buffer after the sun and moon: /// the sky's rotation (camera-relative world from star space) and the @@ -337,6 +340,7 @@ pub struct Renderer { see_through_pipeline: wgpu::RenderPipeline, celestial_pipeline: wgpu::RenderPipeline, celestial_buffer: wgpu::Buffer, + end_sky: end_sky::EndSky, stars: stars::Stars, panorama: panorama::Panorama, /// `RenderPipelines.WORLD_BORDER` and its buffers. @@ -2113,6 +2117,7 @@ impl Renderer { see_through_pipeline, celestial_pipeline, celestial_buffer, + end_sky: end_sky::EndSky::default(), stars, panorama, border_pipeline, @@ -3310,6 +3315,9 @@ impl Renderer { ); } let celestial_vertices = frame.celestial.len().min(2048 * 4); + if frame.end_sky && !frame.title { + self.end_sky.prepare(&self.device, frame.end_sky_sprite); + } if celestial_vertices > 0 { self.uploads.buffer( &mut encoder, @@ -3510,12 +3518,17 @@ impl Renderer { if frame.title { self.panorama.draw(&mut pass); pass.set_bind_group(0, &self.group, &[]); - } else if celestial_vertices > 0 { + } else if celestial_vertices > 0 || frame.end_sky { pass.set_pipeline(&self.celestial_pipeline); pass.set_bind_group(0, &self.entity_group, &[]); pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); - pass.set_vertex_buffer(0, self.celestial_buffer.slice(..)); - pass.draw_indexed(0..(celestial_vertices as u32 / 4) * 6, 0, 0..1); + if frame.end_sky { + self.end_sky.draw(&mut pass); + } + if celestial_vertices > 0 { + pass.set_vertex_buffer(0, self.celestial_buffer.slice(..)); + pass.draw_indexed(0..(celestial_vertices as u32 / 4) * 6, 0, 0..1); + } pass.set_bind_group(0, &self.group, &[]); } if !frame.title && frame.stars.is_some() { diff --git a/crates/horizon-client/src/gfx/end_sky.rs b/crates/horizon-client/src/gfx/end_sky.rs new file mode 100644 index 000000000..15e9001fc --- /dev/null +++ b/crates/horizon-client/src/gfx/end_sky.rs @@ -0,0 +1,84 @@ +//! The End sky's six tiled faces, retained for the lifetime of the renderer's atlas. +use crate::mesher::Vertex; +use wgpu::util::DeviceExt; + +const VERTICES: u32 = 6 * 16 * 16 * 4; + +#[derive(Default)] +pub(super) struct EndSky { + mesh: Option<([f32; 4], wgpu::Buffer)>, +} + +impl EndSky { + /// Called only when the End sky is enabled. Rebuild on atlas UV changes; + /// resource reload and device recreation also replace the owning renderer. + pub(super) fn prepare(&mut self, device: &wgpu::Device, uv: Option<[f32; 4]>) { + let Some(uv) = uv else { + self.mesh = None; + return; + }; + if self.mesh.as_ref().is_some_and(|(old, _)| *old == uv) { + return; + } + let vertices = vertices(uv); + let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some("End sky vertices"), + contents: bytemuck::cast_slice(&vertices), + usage: wgpu::BufferUsages::VERTEX, + }); + self.mesh = Some((uv, buffer)); + } + + /// The celestial pipeline, atlas bind group and quad indices are already bound. + pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>) { + if let Some((_, buffer)) = &self.mesh { + pass.set_vertex_buffer(0, buffer.slice(..)); + pass.draw_indexed(0..VERTICES / 4 * 6, 0, 0..1); + } + } +} + +/// SkyRenderer.buildEndSky: six faces of end_sky.png tiled 16 times, +/// tinted 0x282828. The atlas does not wrap, so each face is 16×16 quads. +fn vertices(uv: [f32; 4]) -> Vec { + let mut out = Vec::with_capacity(VERTICES as usize); + use std::f32::consts::FRAC_PI_2; + let faces = [ + glam::Mat4::IDENTITY, + glam::Mat4::from_rotation_x(FRAC_PI_2), + glam::Mat4::from_rotation_x(-FRAC_PI_2), + glam::Mat4::from_rotation_x(std::f32::consts::PI), + glam::Mat4::from_rotation_z(FRAC_PI_2), + glam::Mat4::from_rotation_z(-FRAC_PI_2), + ]; + let step = 200.0 / 16.0; + for pose in faces { + for a in 0..16 { + for b in 0..16 { + let (x0, z0) = (-100.0 + step * a as f32, -100.0 + step * b as f32); + let (x1, z1) = (x0 + step, z0 + step); + let corners = [ + (x0, z0, [uv[0], uv[1]]), + (x0, z1, [uv[0], uv[3]]), + (x1, z1, [uv[2], uv[3]]), + (x1, z0, [uv[2], uv[1]]), + ]; + for (x, z, uv) in corners { + let p = pose.transform_point3(glam::Vec3::new(x, -100.0, z)); + out.push(Vertex { + normal: [0; 4], + pos: p.to_array(), + uv, + layer: 2, + color: 0xFF28_2828, + light: 0, + }); + } + } + } + } + out +} + +#[cfg(test)] +mod tests; diff --git a/crates/horizon-client/src/gfx/end_sky/tests.rs b/crates/horizon-client/src/gfx/end_sky/tests.rs new file mode 100644 index 000000000..d01fca18c --- /dev/null +++ b/crates/horizon-client/src/gfx/end_sky/tests.rs @@ -0,0 +1,330 @@ +use super::*; +use crate::gfx::{Globals, Renderer}; +use bytemuck::Zeroable; +use glam::Mat4; + +#[test] +fn geometry_matches_pre_residency_vertex_snapshots() { + use sha2::{Digest, Sha256}; + // Captured from game/end.rs at 34c3c1cf for full, tiled and non-binary UVs. + // Quantize positions only, avoiding platform sin/cos rounding differences; + // quad order, UVs, tint, material and light retain their exact byte values. + for (uv, expected) in [ + ( + [0.0, 0.0, 1.0, 1.0], + "f7ee23457fc557b33ecf09c9afaf858f3d8907e108abf06055f627523f733536", + ), + ( + [0.125, 0.25, 0.375, 0.5], + "f74c4b8d23ec2b7c11b5752821d0733851bf11358f1b26f9448226ff62a6a318", + ), + ( + [0.13, 0.27, 0.41, 0.59], + "f0aaa39c5b22168bdc7c6c329acb4d3598a2feb61ff7b6f2850b644682749b39", + ), + ] { + let mut mesh = vertices(uv); + assert_eq!(mesh.len(), VERTICES as usize); + for vertex in &mut mesh { + vertex.pos = vertex.pos.map(|x| { + let n = (x * 1024.0).round() / 1024.0; + if n == 0.0 { 0.0 } else { n } + }); + } + assert_eq!( + format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh))), + expected + ); + } +} + +fn device() -> Option<(wgpu::Device, wgpu::Queue)> { + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?; + eprintln!("End sky test adapter: {:?}", adapter.get_info()); + pollster::block_on(adapter.request_device(&Default::default())).ok() +} + +#[test] +fn resident_buffer_survives_frames_and_refreshes_with_the_atlas() { + let Some((device, _)) = device() else { + eprintln!("no GPU adapter: skipped"); + return; + }; + let mut sky = EndSky::default(); + let uv = [0.125, 0.25, 0.375, 0.5]; + sky.prepare(&device, Some(uv)); + let first = sky.mesh.as_ref().unwrap().1.clone(); + assert_eq!( + first.size(), + u64::from(VERTICES) * size_of::() as u64 + ); + // Immutable: steady-state frames cannot upload into this buffer. + assert_eq!(first.usage(), wgpu::BufferUsages::VERTEX); + for _ in 0..600 { + sky.prepare(&device, Some(uv)); + assert_eq!(sky.mesh.as_ref().unwrap().1, first); + } + let moved = [0.5, 0.5, 0.75, 0.75]; + sky.prepare(&device, Some(moved)); + assert_ne!(sky.mesh.as_ref().unwrap().1, first); + assert_eq!(sky.mesh.as_ref().unwrap().0, moved); + sky.prepare(&device, None); + assert!(sky.mesh.is_none()); + sky.prepare(&device, Some(uv)); + assert_ne!(sky.mesh.as_ref().unwrap().1, first); + // A resource reload/device recreation starts a new renderer-owned cache, + // even if the replacement atlas happens to use exactly the same UVs. + let mut replacement = EndSky::default(); + replacement.prepare(&device, Some(uv)); + assert_ne!( + replacement.mesh.as_ref().unwrap().1, + sky.mesh.as_ref().unwrap().1 + ); +} + +/// The actual entity shader and celestial blend, comparing the old combined +/// vertex stream with a resident sky draw followed by a separate flash draw. +#[test] +fn separate_draws_match_combined_celestial_pixels() { + let Some((device, queue)) = device() else { + eprintln!("no GPU adapter: skipped"); + return; + }; + let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("End sky differential shader"), + source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()), + }); + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; + let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("End sky differential pipeline"), + layout: None, + vertex: wgpu::VertexState { + module: &shader, + entry_point: Some("vs_entity"), + compilation_options: Default::default(), + buffers: &[Some(wgpu::VertexBufferLayout { + array_stride: size_of::() as u64, + step_mode: wgpu::VertexStepMode::Vertex, + attributes: &attributes, + })], + }, + primitive: wgpu::PrimitiveState { + cull_mode: None, + ..Default::default() + }, + depth_stencil: None, + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &shader, + entry_point: Some("fs_celestial"), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format: wgpu::TextureFormat::Rgba8Unorm, + blend: Some(wgpu::BlendState { + color: wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::SrcAlpha, + dst_factor: wgpu::BlendFactor::One, + operation: wgpu::BlendOperation::Add, + }, + alpha: wgpu::BlendComponent::OVER, + }), + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }); + let texture = |pixels: &[u8], width, height| { + device.create_texture_with_data( + &queue, + &wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width, + height, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }, + wgpu::util::TextureDataOrder::LayerMajor, + pixels, + ) + }; + // Asymmetric, translucent texels expose UV/winding and blend-order errors. + let pixels: Vec = (0..16 * 16) + .flat_map(|i| { + [ + (i * 17) as u8, + (i * 31) as u8, + (i * 7) as u8, + (80 + i % 176) as u8, + ] + }) + .collect(); + let atlas = texture(&pixels, 16, 16).create_view(&Default::default()); + let lightmap = texture(&[255; 4], 1, 1).create_view(&Default::default()); + let sampler = device.create_sampler(&Default::default()); + let uniform = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: size_of::() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &pipeline.get_bind_group_layout(0), + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: uniform.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&atlas), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::Sampler(&sampler), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::TextureView(&lightmap), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: wgpu::BindingResource::Sampler(&sampler), + }, + ], + }); + let indices = Renderer::quad_indices(&device, VERTICES / 4 + 1); + let mut resident = EndSky::default(); + let uv = [0.125, 0.25, 0.375, 0.5]; + resident.prepare(&device, Some(uv)); + let first = resident.mesh.as_ref().unwrap().1.clone(); + let render = |sky: &EndSky, flash: &[Vertex], combined: bool| { + let target = device.create_texture(&wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: 64, + height: 64, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC, + view_formats: &[], + }); + let view = target.create_view(&Default::default()); + let mut vertices = if combined { vertices(uv) } else { Vec::new() }; + vertices.extend_from_slice(flash); + let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: None, + contents: bytemuck::cast_slice(&vertices), + usage: wgpu::BufferUsages::VERTEX, + }); + let readback = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: 64 * 64 * 4, + usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ, + mapped_at_creation: false, + }); + let mut encoder = device.create_command_encoder(&Default::default()); + { + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: &view, + depth_slice: None, + resolve_target: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(wgpu::Color::BLACK), + store: wgpu::StoreOp::Store, + }, + })], + ..Default::default() + }); + pass.set_pipeline(&pipeline); + pass.set_bind_group(0, &group, &[]); + pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32); + if !combined { + sky.draw(&mut pass); + } + if !vertices.is_empty() { + pass.set_vertex_buffer(0, buffer.slice(..)); + pass.draw_indexed(0..vertices.len() as u32 / 4 * 6, 0, 0..1); + } + } + encoder.copy_texture_to_buffer( + target.as_image_copy(), + wgpu::TexelCopyBufferInfo { + buffer: &readback, + layout: wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(256), + rows_per_image: Some(64), + }, + }, + target.size(), + ); + queue.submit([encoder.finish()]); + readback + .slice(..) + .map_async(wgpu::MapMode::Read, |r| r.unwrap()); + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + readback.slice(..).get_mapped_range().unwrap().to_vec() + }; + let mut cases = 0; + let mut visible_flash_cases = 0; + for yaw in [0.0_f32, 45.0, 90.0, 180.0, 270.0] { + for pitch in [-85.0_f32, -30.0, 0.0, 45.0, 85.0] { + let mut globals = Globals::zeroed(); + globals.view_proj = (Mat4::perspective_rh(90_f32.to_radians(), 1.0, 0.05, 1024.0) + * Mat4::from_rotation_x(pitch.to_radians()) + * Mat4::from_rotation_y(yaw.to_radians())) + .to_cols_array_2d(); + queue.write_buffer(&uniform, 0, bytemuck::bytes_of(&globals)); + let no_flash = render(&resident, &[], true); + for level in [0_u32, 1, 127, 255] { + let flash: Vec<_> = if level == 0 { + Vec::new() + } else { + // Same flash size/height, with an arbitrary EndFlashState pose. + let pose = Mat4::from_rotation_y(1.3) * Mat4::from_rotation_x(-1.6); + [(-60.0, -60.0), (60.0, -60.0), (60.0, 60.0), (-60.0, 60.0)] + .map(|(x, z)| Vertex { + pos: pose.transform_point3(glam::vec3(x, 100.0, z)).to_array(), + uv: [0.75 + x / 480.0, 0.75 + z / 480.0], + layer: 2, + color: level * 0x01010101, + light: 0, + normal: [0; 4], + }) + .to_vec() + }; + resident.prepare(&device, Some(uv)); + let expected = render(&resident, &flash, true); + let actual = render(&resident, &flash, false); + visible_flash_cases += usize::from(expected != no_flash); + assert_eq!(actual, expected, "yaw={yaw} pitch={pitch} flash={level}"); + assert!( + actual.chunks_exact(4).any(|p| p[..3] != [0; 3]), + "empty frame" + ); + assert_eq!(resident.mesh.as_ref().unwrap().1, first); + cases += 1; + } + } + } + assert!( + visible_flash_cases > 0, + "the flash must affect the comparison" + ); + eprintln!("{cases} combined/resident framebuffer cases matched exactly"); +} From 93bde90aaf1918f0b245f907901fe1cea2b2af0d Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:51:51 +0200 Subject: [PATCH 42/59] Launcher: Microsoft sign-in says "Coming soon" while the build has no client ID Co-Authored-By: Claude Opus 5.5 --- docs/microsoft-account.md | 2 +- launcher/src/account.rs | 3 ++- launcher/src/main.rs | 7 +++++-- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/docs/microsoft-account.md b/docs/microsoft-account.md index 61b402211..380aa0785 100644 --- a/docs/microsoft-account.md +++ b/docs/microsoft-account.md @@ -7,7 +7,7 @@ they are. This note is the design, the status of each part and what Ludovic has ## What Ludovic registers (needs his accounts) Nothing below can be done by an agent: the app registrations belong to Ludovic. Until the client ID -is set, the launcher's sign-in shows "Microsoft sign-in is not configured yet" and everything else +is set, the launcher's sign-in shows "Coming soon" ("Microsoft sign-in is coming soon") and everything else works as before. 1. **Azure app registration** (https://portal.azure.com → Microsoft Entra ID → App registrations → diff --git a/launcher/src/account.rs b/launcher/src/account.rs index 44fa96cb6..8958fb3d4 100644 --- a/launcher/src/account.rs +++ b/launcher/src/account.rs @@ -16,7 +16,8 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH}; pub const SERVICE: &str = "dev.playhorizon.launcher"; const SCOPE: &str = "XboxLive.signin offline_access"; pub const NOT_CONFIGURED: &str = - "Microsoft sign-in is not configured yet in this build of the launcher (no client ID)."; + "Microsoft sign-in is coming soon. Until then the game plays offline: single player, \ + LAN and servers in offline mode work."; const SIGN_IN_AGAIN: &str = "Your Microsoft sign-in expired. Sign in again."; /// The Minecraft token is renewed when it has less than this left. const RENEW_BEFORE: u64 = 3600; diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 15cfb79ac..c1184fe10 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -2262,7 +2262,8 @@ impl Launcher { .child(div().child(account::NO_KEYCHAIN)) }; let action = if !configured { - None + // No client ID in this build: the button says what's coming and does nothing. + Some(button("sign-in", "Coming soon", Kind::Ghost, &t).into_any_element()) } else if let Some(SignInState::Code(code)) = &self.sign_in_state { let (uri, user_code) = (code.verification_uri.clone(), code.user_code.clone()); Some( @@ -2309,7 +2310,9 @@ impl Launcher { ) }; n += 1; - let title = if self.accounts.accounts.is_empty() { + let title = if !configured { + "Microsoft account (coming soon)" + } else if self.accounts.accounts.is_empty() { "Microsoft account" } else { "Another account" From fa14833b41782f59ef6087cce092081e813620e5 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:56:23 +0100 Subject: [PATCH 43/59] perf(client): retain seeded lightning bolt geometry --- crates/horizon-client/src/entity.wgsl | 7 + crates/horizon-client/src/game.rs | 26 +- crates/horizon-client/src/game/lightning.rs | 85 +-- crates/horizon-client/src/gfx.rs | 52 +- crates/horizon-client/src/gfx/lightning.rs | 211 ++++++++ .../src/gfx/lightning/tests/mod.rs | 495 ++++++++++++++++++ 6 files changed, 790 insertions(+), 86 deletions(-) create mode 100644 crates/horizon-client/src/gfx/lightning.rs create mode 100644 crates/horizon-client/src/gfx/lightning/tests/mod.rs diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index 2c6af26f9..3b5dd9dcc 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -109,6 +109,13 @@ fn entity_vertex(position: vec3, uv: vec2, @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, @location(5) normal: vec4) -> Out { return entity_vertex(position, uv, overlay, color, light, normal); } +// Retained bolt-local geometry, translated using the same f64 camera +// subtraction as the former CPU path before adding each local f32 position. +@vertex fn vs_lightning(@location(0) position: vec3, @location(1) uv: vec2, + @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, @location(5) normal: vec4, + @location(6) offset: vec3) -> Out { + return entity_vertex(offset + position, uv, overlay, color, light, normal); +} struct CloudInfo { offset: vec4, colors: array, 4>, diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..c2d3b37e8 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9782,15 +9782,17 @@ impl Game<'_> { self.entity_geometry(camera, alpha, entities) }); } + let bolts = if title { + Vec::new() + } else { + self.bolt_instances() + }; let mut additive = Vec::new(); - if !title { - self.bolt_geometry(camera, &mut additive); - if self.dim == Dim::End { - let mut dragon = Vec::new(); - self.dragon_geometry(camera, alpha, &mut dragon, &mut additive); - self.dragon_fireball_geometry(camera, alpha, &mut dragon); - entities.extend(dragon); - } + if !title && self.dim == Dim::End { + let mut dragon = Vec::new(); + self.dragon_geometry(camera, alpha, &mut dragon, &mut additive); + self.dragon_fireball_geometry(camera, alpha, &mut dragon); + entities.extend(dragon); } // A Java pack's `clouds` replaces the cloud option (`renderClouds`: // "false", "fast", "true"), as Iris overrides `getCloudsType`. @@ -9902,6 +9904,13 @@ impl Game<'_> { }), entities: &entities, dynamic_lights: &self.dynamic_lights, + lightning: horizon_client::gfx::lightning::Input { + bolts: &bolts, + uv: [ + self.gui.atlas.font.white().u0, + self.gui.atlas.font.white().v0, + ], + }, additive: &additive, see_through: &see_through, celestial: if self.settings.horizon.sky || title { @@ -12377,6 +12386,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> { entities: &[], dynamic_lights: &[], clouds: None, + lightning: Default::default(), additive: &[], see_through: &[], celestial: &[], diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 6c4dd933f..0f43c4c54 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -5,14 +5,8 @@ //! witches, mooshroom colours, turtles, burnt items), lightning rods, the sky //! flash, the sounds and the branching additive bolt. use super::Game; -use horizon_client::{ - mesher::Vertex, - mobs::{Damage, DamageKind, MobEvent, SpawnSetup, Species}, -}; -use horizon_core::{ - position::BlockPos, - random::{LegacyRandom, RandomSource}, -}; +use horizon_client::mobs::{Damage, DamageKind, MobEvent, SpawnSetup, Species}; +use horizon_core::{position::BlockPos, random::RandomSource}; pub(super) struct Bolt { at: [f64; 3], @@ -349,71 +343,14 @@ impl Game<'_> { || e.stack.item.contains("netherite") }); } - /// `LightningBoltRenderer`: 4 layers of a trunk and two branches, 8 - /// segments of 16 blocks, from the bolt's seed. - pub(super) fn bolt_geometry(&self, camera: glam::DVec3, out: &mut Vec) { - let white = self.gui.atlas.font.white(); - let uv = [white.u0, white.v0]; - // ARGB 0.45, 0.45, 0.5 at 0.3 alpha, packed RGBA. - let color = (76u32 << 24) | (127 << 16) | (114 << 8) | 114; - for b in &self.bolts { - let o = (glam::DVec3::from_array(b.at) - camera).as_vec3(); - let mut random = LegacyRandom::new(b.seed); - let (mut xs, mut zs) = ([0f32; 8], [0f32; 8]); - let (mut x_off, mut z_off) = (0f32, 0f32); - for i in (0..8).rev() { - xs[i] = x_off; - zs[i] = z_off; - x_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; - z_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; - } - for layer in 0..4 { - let mut random = LegacyRandom::new(b.seed); - for branch in 0..3 { - let trunk = branch == 0; - let start = 7 - branch; - let end = if trunk { 0 } else { start - 3 + 1 }; - let mut sx = xs[start] - x_off; - let mut sz = zs[start] - z_off; - for segment in (end..=start).rev() { - let (ex, ez) = (sx, sz); - let spread = if trunk { 11 } else { 31 }; - sx += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; - sz += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; - let mut top = 0.1 + layer as f32 * 0.2; - let mut bottom = top; - if trunk { - top *= segment as f32 * 0.1 + 1.0; - bottom *= (segment as f32 - 1.0) * 0.1 + 1.0; - } - for (rx, rz, lx, lz) in [ - (false, false, true, false), - (true, false, true, true), - (true, true, false, true), - (false, true, false, false), - ] { - let s = |p: bool, r: f32| if p { r } else { -r }; - let y0 = segment as f32 * 16.0; - let corners = [ - [sx + s(rx, bottom), y0, sz + s(rz, bottom)], - [ex + s(rx, top), y0 + 16.0, ez + s(rz, top)], - [ex + s(lx, top), y0 + 16.0, ez + s(lz, top)], - [sx + s(lx, bottom), y0, sz + s(lz, bottom)], - ]; - for c in corners { - out.push(Vertex { - normal: [0; 4], - pos: (o + glam::Vec3::from_array(c)).to_array(), - uv, - layer: 2, - color, - light: 240 | 240 << 8, - }); - } - } - } - } - } - } + /// Simulation-order render inputs; seeded geometry lives in the renderer. + pub(super) fn bolt_instances(&self) -> Vec { + self.bolts + .iter() + .map(|b| horizon_client::gfx::lightning::Bolt { + at: b.at, + seed: b.seed, + }) + .collect() } } diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..243904424 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -63,6 +63,7 @@ mod arena; mod cull; mod flat; mod java_stages; +pub mod lightning; mod lod; mod occlusion; mod pack_stages; @@ -193,7 +194,9 @@ pub struct Frame<'a> { pub dynamic_lights: &'a [[f32; 4]], /// Cloud mesh inputs; geometry and GPU storage are retained by the renderer. pub clouds: Option>, - /// Additive translucent geometry after the entities (lightning, dragon rays). + /// Retained lightning bolts, drawn before the other additive entities. + pub lightning: lightning::Input<'a>, + /// Additive translucent geometry after lightning (dragon rays). pub additive: &'a [Vertex], /// Name tags over everything, without depth (`TEXT_SEE_THROUGH`). pub see_through: &'a [Vertex], @@ -334,6 +337,8 @@ pub struct Renderer { cloud_uniform: wgpu::Buffer, cloud_group: wgpu::BindGroup, additive_pipeline: wgpu::RenderPipeline, + lightning_pipeline: wgpu::RenderPipeline, + lightning: lightning::Renderer, see_through_pipeline: wgpu::RenderPipeline, celestial_pipeline: wgpu::RenderPipeline, celestial_buffer: wgpu::Buffer, @@ -1664,8 +1669,17 @@ impl Renderer { alpha_blend, false, ); + let lightning_attributes = wgpu::vertex_attr_array![6=>Float32x3]; + let lightning_vertex = [ + entity_vertex[0].clone(), + Some(wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::<[f32; 3]>() as u64, + step_mode: wgpu::VertexStepMode::Instance, + attributes: &lightning_attributes, + }), + ]; // BlendFunction.LIGHTNING: src alpha, one; no depth writes. - let additive_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + let additive_descriptor = wgpu::RenderPipelineDescriptor { label: Some("Additive entities"), layout: Some(&entity_layout), vertex: wgpu::VertexState { @@ -1709,6 +1723,16 @@ impl Renderer { }), multiview_mask: None, cache: None, + }; + let additive_pipeline = device.create_render_pipeline(&additive_descriptor); + let lightning_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Lightning"), + vertex: wgpu::VertexState { + entry_point: Some("vs_lightning"), + buffers: &lightning_vertex, + ..additive_descriptor.vertex.clone() + }, + ..additive_descriptor }); let celestial_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("Celestial bodies"), @@ -2110,6 +2134,8 @@ impl Renderer { cloud_uniform, cloud_group, additive_pipeline, + lightning_pipeline, + lightning: lightning::Renderer::new(), see_through_pipeline, celestial_pipeline, celestial_buffer, @@ -3279,6 +3305,13 @@ impl Renderer { } else { 0 }; + self.lightning.prepare( + &self.device, + &mut self.uploads, + &mut encoder, + &frame.lightning, + camera, + ); let all_entities = &self.entity_batch.combined; let hand_quads = (frame.hand.len() / 4) as u32; let additive_quads = (frame.additive.len() / 4) as u32; @@ -3318,8 +3351,13 @@ impl Renderer { bytemuck::cast_slice(&frame.celestial[..celestial_vertices]), ); } - let max_quads = - (world_quads + additive_quads + hand_quads + see_through_quads).max(cloud_quads); + let max_quads = (world_quads + additive_quads + hand_quads + see_through_quads) + .max(cloud_quads) + .max(if frame.lightning.bolts.is_empty() { + 0 + } else { + lightning::QUADS + }); if max_quads > self.index_quads { self.index_quads = max_quads.next_power_of_two(); self.indices = Self::quad_indices(&self.device, self.index_quads); @@ -3622,6 +3660,12 @@ impl Renderer { ); pass.set_bind_group(0, &self.group, &[]); } + if !frame.lightning.bolts.is_empty() { + pass.set_pipeline(&self.lightning_pipeline); + pass.set_bind_group(0, &self.entity_group, &[]); + self.lightning.draw(&mut pass, &frame.lightning); + pass.set_bind_group(0, &self.group, &[]); + } if additive_quads > 0 { pass.set_pipeline(&self.additive_pipeline); pass.set_bind_group(0, &self.entity_group, &[]); diff --git a/crates/horizon-client/src/gfx/lightning.rs b/crates/horizon-client/src/gfx/lightning.rs new file mode 100644 index 000000000..251dbf00e --- /dev/null +++ b/crates/horizon-client/src/gfx/lightning.rs @@ -0,0 +1,211 @@ +//! Seeded, bolt-local lightning meshes retained until their last active bolt disappears. +use crate::{gfx::upload::Uploads, mesher::Vertex}; +use glam::DVec3; +use horizon_core::random::{LegacyRandom, RandomSource}; +use std::collections::HashMap; +use wgpu::util::DeviceExt; + +/// A bolt's render state. Simulation lifetime and flashes stay in the game. +#[derive(Clone, Copy)] +pub struct Bolt { + pub at: [f64; 3], + pub seed: i64, +} + +#[derive(Default)] +pub struct Input<'a> { + pub bolts: &'a [Bolt], + /// Current atlas white texel; a changed rect invalidates retained vertices. + pub uv: [f32; 2], +} + +// Four layers, fourteen segments (eight trunk, two branches of three), four quads. +pub(super) const QUADS: u32 = 4 * 14 * 4; + +/// `LightningBoltRenderer.submit`: keep random draws, layers and quad order unchanged. +fn geometry(seed: i64, uv: [f32; 2]) -> Vec { + let mut out = Vec::with_capacity(QUADS as usize * 4); + // ARGB 0.45, 0.45, 0.5 at 0.3 alpha, packed RGBA. + let color = (76u32 << 24) | (127 << 16) | (114 << 8) | 114; + let mut random = LegacyRandom::new(seed); + let (mut xs, mut zs) = ([0f32; 8], [0f32; 8]); + let (mut x_off, mut z_off) = (0f32, 0f32); + for i in (0..8).rev() { + xs[i] = x_off; + zs[i] = z_off; + x_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; + z_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; + } + for layer in 0..4 { + let mut random = LegacyRandom::new(seed); + for branch in 0..3 { + let trunk = branch == 0; + let start = 7 - branch; + let end = if trunk { 0 } else { start - 3 + 1 }; + let mut sx = xs[start] - x_off; + let mut sz = zs[start] - z_off; + for segment in (end..=start).rev() { + let (ex, ez) = (sx, sz); + let spread = if trunk { 11 } else { 31 }; + sx += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; + sz += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; + let mut top = 0.1 + layer as f32 * 0.2; + let mut bottom = top; + if trunk { + top *= segment as f32 * 0.1 + 1.0; + bottom *= (segment as f32 - 1.0) * 0.1 + 1.0; + } + for (rx, rz, lx, lz) in [ + (false, false, true, false), + (true, false, true, true), + (true, true, false, true), + (false, true, false, false), + ] { + let s = |p: bool, r: f32| if p { r } else { -r }; + let y0 = segment as f32 * 16.0; + let corners = [ + [sx + s(rx, bottom), y0, sz + s(rz, bottom)], + [ex + s(rx, top), y0 + 16.0, ez + s(rz, top)], + [ex + s(lx, top), y0 + 16.0, ez + s(lz, top)], + [sx + s(lx, bottom), y0, sz + s(lz, bottom)], + ]; + for c in corners { + out.push(Vertex { + normal: [0; 4], + pos: c, + uv, + layer: 2, + color, + light: 240 | 240 << 8, + }); + } + } + } + } + } + out +} + +struct Cached { + mesh: T, + used: bool, +} + +/// Shared seeds use the same mesh; storage is bounded by active unique seeds, +/// including after seed changes, removals, dimension switches and disconnects. +struct Cache { + uv: Option<[f32; 2]>, + meshes: HashMap>, +} +impl Cache { + fn new() -> Self { + Self { + uv: None, + meshes: HashMap::new(), + } + } + + fn prepare(&mut self, input: &Input<'_>, mut build: impl FnMut(i64, [f32; 2]) -> T) { + if self.uv != Some(input.uv) { + self.meshes.clear(); + self.uv = Some(input.uv); + } + for cached in self.meshes.values_mut() { + cached.used = false; + } + for bolt in input.bolts { + self.meshes + .entry(bolt.seed) + .or_insert_with(|| Cached { + mesh: build(bolt.seed, input.uv), + used: true, + }) + .used = true; + } + self.meshes.retain(|_, cached| cached.used); + // HashMap::retain keeps its allocation. Release historical peak capacity + // as well as meshes once the storm (or connection) is gone. + if self.meshes.is_empty() { + self.meshes = HashMap::new(); + } else if self.meshes.capacity() > self.meshes.len() * 4 { + self.meshes.shrink_to_fit(); + } + } +} + +fn offset(bolt: &Bolt, camera: DVec3) -> [f32; 3] { + (DVec3::from_array(bolt.at) - camera).as_vec3().to_array() +} + +pub(super) struct Renderer { + cache: Cache, + instances: Option, + capacity: usize, +} +impl Renderer { + pub(super) fn new() -> Self { + Self { + cache: Cache::new(), + instances: None, + capacity: 0, + } + } + + pub(super) fn prepare( + &mut self, + device: &wgpu::Device, + uploads: &mut Uploads, + encoder: &mut wgpu::CommandEncoder, + input: &Input<'_>, + camera: DVec3, + ) { + self.cache.prepare(input, |seed, uv| { + device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some("Lightning vertices"), + contents: bytemuck::cast_slice(&geometry(seed, uv)), + usage: wgpu::BufferUsages::VERTEX, + }) + }); + if input.bolts.is_empty() { + self.instances = None; + self.capacity = 0; + return; + } + if input.bolts.len() > self.capacity || input.bolts.len() < self.capacity / 4 { + self.capacity = input.bolts.len().next_power_of_two(); + self.instances = Some(device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Lightning offsets"), + size: (self.capacity * std::mem::size_of::<[f32; 3]>()) as u64, + usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + })); + } + let offsets: Vec<_> = input + .bolts + .iter() + .map(|bolt| offset(bolt, camera)) + .collect(); + uploads.buffer( + encoder, + self.instances.as_ref().unwrap(), + 0, + bytemuck::cast_slice(&offsets), + ); + } + + pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>, input: &Input<'_>) { + let Some(instances) = &self.instances else { + return; + }; + pass.set_vertex_buffer(1, instances.slice(..)); + // Follow simulation order, including repeated seeds; HashMap order must + // never change additive accumulation or the order before dragon rays. + for (i, bolt) in input.bolts.iter().enumerate() { + pass.set_vertex_buffer(0, self.cache.meshes[&bolt.seed].mesh.slice(..)); + pass.draw_indexed(0..QUADS * 6, 0, i as u32..i as u32 + 1); + } + } +} + +#[cfg(test)] +mod tests; diff --git a/crates/horizon-client/src/gfx/lightning/tests/mod.rs b/crates/horizon-client/src/gfx/lightning/tests/mod.rs new file mode 100644 index 000000000..f89f402de --- /dev/null +++ b/crates/horizon-client/src/gfx/lightning/tests/mod.rs @@ -0,0 +1,495 @@ +use super::*; +use std::cell::Cell; + +// Frozen pre-cache generator: compare every Vertex byte, including primitive +// order and the original camera-relative rounding, without game resources. +fn reference(seed: i64, at: [f64; 3], camera: DVec3, uv: [f32; 2]) -> Vec { + let mut out = Vec::new(); + // ARGB 0.45, 0.45, 0.5 at 0.3 alpha, packed RGBA. + let color = (76u32 << 24) | (127 << 16) | (114 << 8) | 114; + let b = Bolt { seed, at }; + { + let o = (glam::DVec3::from_array(b.at) - camera).as_vec3(); + let mut random = LegacyRandom::new(b.seed); + let (mut xs, mut zs) = ([0f32; 8], [0f32; 8]); + let (mut x_off, mut z_off) = (0f32, 0f32); + for i in (0..8).rev() { + xs[i] = x_off; + zs[i] = z_off; + x_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; + z_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; + } + for layer in 0..4 { + let mut random = LegacyRandom::new(b.seed); + for branch in 0..3 { + let trunk = branch == 0; + let start = 7 - branch; + let end = if trunk { 0 } else { start - 3 + 1 }; + let mut sx = xs[start] - x_off; + let mut sz = zs[start] - z_off; + for segment in (end..=start).rev() { + let (ex, ez) = (sx, sz); + let spread = if trunk { 11 } else { 31 }; + sx += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; + sz += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; + let mut top = 0.1 + layer as f32 * 0.2; + let mut bottom = top; + if trunk { + top *= segment as f32 * 0.1 + 1.0; + bottom *= (segment as f32 - 1.0) * 0.1 + 1.0; + } + for (rx, rz, lx, lz) in [ + (false, false, true, false), + (true, false, true, true), + (true, true, false, true), + (false, true, false, false), + ] { + let s = |p: bool, r: f32| if p { r } else { -r }; + let y0 = segment as f32 * 16.0; + let corners = [ + [sx + s(rx, bottom), y0, sz + s(rz, bottom)], + [ex + s(rx, top), y0 + 16.0, ez + s(rz, top)], + [ex + s(lx, top), y0 + 16.0, ez + s(lz, top)], + [sx + s(lx, bottom), y0, sz + s(lz, bottom)], + ]; + for c in corners { + out.push(Vertex { + normal: [0; 4], + pos: (o + glam::Vec3::from_array(c)).to_array(), + uv, + layer: 2, + color, + light: 240 | 240 << 8, + }); + } + } + } + } + } + } + out +} + +fn seeds() -> Vec { + let mut seeds = vec![0, 1, -1, i64::MIN, i64::MAX, 0x123456789abcdef]; + let mut random = LegacyRandom::new(42); + seeds.extend((0..256).map(|_| random.next_long())); + seeds +} + +/// Pinned 26.3 LightningBoltRenderer.lambda$submit$0, captured with an +/// identity PoseStack and a VertexConsumer recording big-endian xyz floats. +#[test] +fn geometry_matches_pinned_vanilla_vertex_digest() { + use sha2::{Digest, Sha256}; + let mut digest = Sha256::new(); + for seed in seeds() { + for vertex in geometry(seed, [0.0; 2]) { + for value in vertex.pos { + digest.update(value.to_be_bytes()); + } + } + } + assert_eq!( + format!("{:x}", digest.finalize()), + "a9ed25caa50b9aa340faa4bb417b3d533b061f0dce66514e4bb212931444dee6" + ); +} + +#[test] +fn retained_geometry_matches_original_generator() { + let uv = [0.8125, 0.03125]; + for seed in seeds() { + let local = geometry(seed, uv); + assert_eq!(local.len(), QUADS as usize * 4); + for (at, camera) in [ + ([0.0; 3], DVec3::ZERO), + ([12.5, 64.0, -12.5], DVec3::new(-4.25, 71.125, 32.5)), + ( + [29_999_999.5, -64.0, -29_999_999.5], + DVec3::new(29_999_987.125, 67.75, -29_999_983.875), + ), + ] { + let offset = offset(&Bolt { seed, at }, camera); + let translated: Vec<_> = local + .iter() + .map(|v| Vertex { + pos: (glam::Vec3::from_array(offset) + glam::Vec3::from_array(v.pos)) + .to_array(), + ..*v + }) + .collect(); + let expected = reference(seed, at, camera, uv); + assert_eq!( + bytemuck::cast_slice::<_, u8>(&translated), + bytemuck::cast_slice::<_, u8>(&expected), + "seed {seed}" + ); + } + } +} + +#[test] +fn cache_tracks_seed_lifecycle_movement_and_atlas_reload() { + let mut cache = Cache::new(); + let builds = Cell::new(0); + let build = |seed, uv| { + builds.set(builds.get() + 1); + geometry(seed, uv) + }; + let mut bolts = [ + Bolt { + seed: 123, + at: [0.0; 3], + }, + Bolt { + seed: 456, + at: [1.0; 3], + }, + ]; + fn input(bolts: &[Bolt]) -> Input<'_> { + Input { + bolts, + uv: [0.25, 0.5], + } + } + cache.prepare(&input(&bolts), build); + assert_eq!(builds.get(), 2); + assert_eq!(cache.meshes.len(), 2); + // Any number of rendered frames or multiplayer position updates reuse meshes. + for i in 0..100 { + bolts[0].at = [i as f64; 3]; + cache.prepare(&input(&bolts), build); + } + assert_eq!(builds.get(), 2); + // A flash changes the seed; retire its previous mesh immediately. + bolts[0].seed = 789; + cache.prepare(&input(&bolts), build); + assert_eq!(builds.get(), 3); + assert!(!cache.meshes.contains_key(&123)); + // Removal retains other bolts, and repeated seeds still share geometry. + bolts[0].seed = 456; + cache.prepare(&input(&bolts), build); + assert_eq!(builds.get(), 3); + assert_eq!(cache.meshes.len(), 1); + // Atlas replacement must update white texel UVs without changing the seed. + cache.prepare( + &Input { + bolts: &bolts, + uv: [0.75, 0.25], + }, + build, + ); + assert_eq!(builds.get(), 4); + assert_eq!(cache.meshes[&456].mesh[0].uv, [0.75, 0.25]); + // Disconnect/dimension switch/expiry drops every retained resource. + cache.prepare(&Input::default(), build); + assert!(cache.meshes.is_empty()); + assert_eq!(cache.meshes.capacity(), 0); + cache.prepare(&input(&bolts), build); + assert_eq!(builds.get(), 5); +} + +#[test] +fn long_flash_sequence_keeps_only_active_seeds() { + let mut cache = Cache::new(); + for seed in 0..10_000 { + cache.prepare( + &Input { + bolts: &[Bolt { seed, at: [0.0; 3] }], + uv: [0.0; 2], + }, + |seed, _| seed, + ); + assert_eq!(cache.meshes.len(), 1); + assert_eq!(cache.meshes[&seed].mesh, seed); + assert!(cache.meshes.capacity() < 16); + } +} + +/// Exercise the actual entity shader and retained draw path offscreen. Run +/// explicitly, separately from other headless device tests (some GPU drivers +/// fail during concurrent device teardown). Machines without an adapter skip it. +#[test] +#[ignore = "requires GPU; run separately with --ignored --exact"] +fn retained_gpu_draw_matches_transient_additive_draw() { + use bytemuck::Zeroable; + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else { + eprintln!("no GPU adapter: skipped"); + return; + }; + eprintln!("lightning differential GPU: {}", adapter.get_info().name); + let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap(); + let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("Lightning differential shader"), + source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()), + }); + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; + let offsets = wgpu::vertex_attr_array![6=>Float32x3]; + let vertices = [Some(wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::() as u64, + step_mode: wgpu::VertexStepMode::Vertex, + attributes: &attributes, + })]; + let retained_vertices = [ + vertices[0].clone(), + Some(wgpu::VertexBufferLayout { + array_stride: 12, + step_mode: wgpu::VertexStepMode::Instance, + attributes: &offsets, + }), + ]; + let pipelines: Vec<_> = [false, true] + .into_iter() + .map(|retained| { + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Lightning differential pipeline"), + layout: None, + vertex: wgpu::VertexState { + module: &shader, + entry_point: Some(if retained { + "vs_lightning" + } else { + "vs_entity" + }), + compilation_options: Default::default(), + buffers: if retained { + &retained_vertices + } else { + &vertices + }, + }, + primitive: wgpu::PrimitiveState { + cull_mode: None, + ..Default::default() + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(false), + depth_compare: Some(wgpu::CompareFunction::GreaterEqual), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &shader, + entry_point: Some("fs_celestial"), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format: wgpu::TextureFormat::Rgba8Unorm, + blend: Some(wgpu::BlendState { + color: wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::SrcAlpha, + dst_factor: wgpu::BlendFactor::One, + operation: wgpu::BlendOperation::Add, + }, + alpha: wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::SrcAlpha, + dst_factor: wgpu::BlendFactor::One, + operation: wgpu::BlendOperation::Add, + }, + }), + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }) + }) + .collect(); + let globals = crate::gfx::Globals { + view_proj: (glam::Mat4::orthographic_rh(-100.0, 100.0, -10.0, 150.0, 0.1, 400.0) + * glam::Mat4::look_at_rh( + glam::Vec3::new(80.0, 30.0, 160.0), + glam::Vec3::new(0.0, 60.0, 0.0), + glam::Vec3::Y, + )) + .to_cols_array_2d(), + ..crate::gfx::Globals::zeroed() + }; + let globals = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: None, + contents: bytemuck::bytes_of(&globals), + usage: wgpu::BufferUsages::UNIFORM, + }); + let size = wgpu::Extent3d { + width: 256, + height: 256, + depth_or_array_layers: 1, + }; + let texture = |format, usage| { + device.create_texture(&wgpu::TextureDescriptor { + label: None, + size, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format, + usage, + view_formats: &[], + }) + }; + let white = device + .create_texture_with_data( + &queue, + &wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: 1, + height: 1, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }, + wgpu::util::TextureDataOrder::LayerMajor, + &[255; 4], + ) + .create_view(&Default::default()); + let sampler = device.create_sampler(&Default::default()); + let groups: Vec<_> = pipelines + .iter() + .map(|pipeline| { + device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &pipeline.get_bind_group_layout(0), + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: globals.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&white), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::Sampler(&sampler), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::TextureView(&white), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: wgpu::BindingResource::Sampler(&sampler), + }, + ], + }) + }) + .collect(); + let mut renderer = Renderer::new(); + let mut uploads = Uploads::new(&device); + let mut bolts = [Bolt { + seed: 123, + at: [29_999_999.5, 64.0, -29_999_999.5], + }; 3]; + bolts[1].seed = -456; + bolts[1].at[0] -= 32.0; + bolts[2].at[2] += 20.0; + let indices = crate::gfx::Renderer::quad_indices(&device, QUADS * 3); + for frame in 0..4 { + let camera = DVec3::new(29_999_997.125 + frame as f64, 62.75, -29_999_998.875); + if frame == 2 { + bolts[0].seed = 789; + } + let input = Input { + bolts: &bolts[..if frame == 3 { 1 } else { 3 }], + uv: if frame == 3 { [0.75; 2] } else { [0.5; 2] }, + }; + let expected: Vec<_> = input + .bolts + .iter() + .flat_map(|bolt| reference(bolt.seed, bolt.at, camera, input.uv)) + .collect(); + let transient = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: None, + contents: bytemuck::cast_slice(&expected), + usage: wgpu::BufferUsages::VERTEX, + }); + let mut encoder = device.create_command_encoder(&Default::default()); + renderer.prepare(&device, &mut uploads, &mut encoder, &input, camera); + let mut readbacks = Vec::new(); + for mode in 0..2 { + let color = texture( + wgpu::TextureFormat::Rgba8Unorm, + wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC, + ); + let view = color.create_view(&Default::default()); + let depth = texture( + wgpu::TextureFormat::Depth32Float, + wgpu::TextureUsages::RENDER_ATTACHMENT, + ) + .create_view(&Default::default()); + { + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: None, + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: &view, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT), + store: wgpu::StoreOp::Store, + }, + })], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: &depth, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Clear(0.0), + store: wgpu::StoreOp::Discard, + }), + stencil_ops: None, + }), + ..Default::default() + }); + pass.set_pipeline(&pipelines[mode]); + pass.set_bind_group(0, &groups[mode], &[]); + pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32); + if mode == 0 { + pass.set_vertex_buffer(0, transient.slice(..)); + pass.draw_indexed(0..expected.len() as u32 / 4 * 6, 0, 0..1); + } else { + renderer.draw(&mut pass, &input); + } + } + let read = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: 256 * 256 * 4, + usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ, + mapped_at_creation: false, + }); + encoder.copy_texture_to_buffer( + color.as_image_copy(), + wgpu::TexelCopyBufferInfo { + buffer: &read, + layout: wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(1024), + rows_per_image: None, + }, + }, + size, + ); + readbacks.push(read); + } + uploads.finish(&encoder); + queue.submit([encoder.finish()]); + for read in &readbacks { + read.slice(..) + .map_async(wgpu::MapMode::Read, |r| r.unwrap()); + } + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + let pixels: Vec> = readbacks + .iter() + .map(|read| read.slice(..).get_mapped_range().unwrap().to_vec()) + .collect(); + assert!(pixels[0].iter().any(|&b| b != 0), "empty reference frame"); + assert_eq!(pixels[0], pixels[1], "frame {frame}: GPU output differs"); + } +} From c9c7cda779e1462e1801bb601d8a9c17c1e00f00 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:06:09 +0100 Subject: [PATCH 44/59] docs: record the completed ten-agent optimization sequence --- docs/chunk-performance-campaign.md | 44 ++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/docs/chunk-performance-campaign.md b/docs/chunk-performance-campaign.md index 5c9d15001..667b72b01 100644 --- a/docs/chunk-performance-campaign.md +++ b/docs/chunk-performance-campaign.md @@ -2,6 +2,20 @@ Profiling baseline: `41055168afcd8687c7efe525545de896f17f4478` (2026-10-22). No production optimization is included in this profiling step. Measurements identify work to investigate; they do not establish a candidate speedup or complete Minecraft world parity. +## Completed sequence: ten agents + +The ten sequential GPT-6.1 Sol/high agents are complete. Three production changes are retained in independent pull requests: + +| Change | Measured complete-workload reduction | Pull request | +| --- | --- | --- | +| Saved list-palette loading (Round 2) | 10.257% normal saved load | [#1223](https://github.com/ludovic111/horizon/pull/1223) | +| Aquifer neighborhood reuse (Rounds 3 and 7) | Primary generation + decoration: 4.152% / 2.377% at one/four workers | [#1229](https://github.com/ludovic111/horizon/pull/1229) | +| Saved-light reconstruction (Round 8) | 6.179% normal / 10.981% flat saved load, incremental to palette loading | [#1231](https://github.com/ludovic111/horizon/pull/1231) | + +These paired-median reductions have different workloads/baselines and must not be added together or treated as total game startup improvements. Retained changes passed their scoped pinned vanilla oracles, exact baseline/candidate snapshots, and repository quick self-checks. The final retained source passed 1,443 tests with serialization after an initial client-test crash. No universal world/gameplay parity claim is made. + +Surface dispatch, section access and NBT feasibility stopped early. The state-cache key candidate was reverted below the default 5% complete-load gate. Aquifer work resumed under the user's explicit lower threshold, then passed full qualification. The final decompression attempt passed the main loading gate but was reverted because related valid-stream workloads regressed. All rejected production/dependency changes are restored; no eleventh agent was started. Further optimization awaits user feedback. + ## Reproduction and artifacts Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM, Linux 7.2.11-zen1-1-zen x86_64; Rust/Cargo 1.99.0, OpenJDK 25.0.4.1. CPU boost remained enabled, governor `powersave`; normal desktop background activity was not isolated. Builds, timed workloads and sampling runs were sequential. Release uses `opt-level=3`, thin LTO, one codegen unit; client benchmarks disable audio/controllers and need no window/GPU. Do not compare these numbers directly with earlier `fast` profile reports. @@ -140,3 +154,33 @@ Evidence is retained under `/srv/bob-data/horizon-chunk-campaign-41055168/state- One discarded process pair followed by two alternating measured pairs used `--rounds 5 --limit 256 --checksum`. Complete normal-load paired reductions were **3.257% and 2.412%** (median **2.835%**); baseline/candidate process-median medians were **49.725 / 48.316 ms** per 256 chunks. Native decode improved **5.917%** (20.266 / 19.067 ms); inflate/NBT varied by **-0.844%**. Compressed-record and block/biome/light checksums matched in every process. Those checksums are limited benchmark checks, not comprehensive semantic or vanilla parity evidence. Decision: **early no-go** at the incremental 5% complete-load gate. Both production files were restored exactly to their pre-candidate contents; only this report remains. No flat/long qualification, comprehensive snapshot comparison, fresh parity suite, tests, commit or PR were pursued for this rejected candidate. The shared Cargo target contains the rejected executable; future work must use the preserved accepted binary or rebuild restored sources. + + +## Round 7: aquifer qualification — retained + +The user explicitly accepted the aquifer pilot's smaller gain and later confirmed the repeated 3.3–3.5% observations were sufficient. The candidate was restored and qualified with five alternating process pairs per workload, startup/streaming/memory checks, fresh client/server aquifer/terrain/material oracles, and 36 exact pre/post-decoration snapshot comparisons. All 20 measured Overworld pairs improve; no material regression was established in the declared checks. The cache adds 312 bytes per transient aquifer object with no new allocation calls. Full results, limitations and reproduction are in [PR #1229](https://github.com/ludovic111/horizon/pull/1229). + +## Round 8: saved-light loading — retained + +Detect uniform saved nibble layers before allocation and decode remaining layers in byte pairs. Final-source complete loading improves by paired medians 6.179% normal and 10.981% flat, incremental to the accepted palette optimization. All ten measured pairs improve. All 691 full metadata snapshots and 50,331,648 fresh pinned Java light values match; the repository quick self-check passes with 1,443 tests. The separate native-decode loop measured slower despite unchanged source; its cause remains unisolated and is disclosed in [PR #1231](https://github.com/ludovic111/horizon/pull/1231). + +## Round 9: NBT payload and modified-UTF fast paths — early no-go + +Inspected the unchanged NBT reader at accepted HEAD `fb2be075` and its actual release assembly in the preserved accepted saved-light executable; captured pinned 26.3 integer-array/JDK modified-UTF bytecode for evidence. Checked the open-PR catalog on 2026-10-22; no NBT-reader optimization overlap was found. Two concrete candidates were bulk big-endian integer-array decoding after one checked slice, avoiding repeated per-element bounds/offset/push checks, and an ASCII widening path before the existing lossless modified-UTF decoder. The latter must retain raw NUL, accepted overlong sequences and unpaired UTF-16 surrogates; arrays must retain count/byte-limit/truncation errors and offsets. + +Decision: **early no-go before implementation**. The valid original mixed-loader profile attributes 4.08% exclusive to all `Reader::payload` work and 2.96% exclusive to all `Reader::string` work; NBT runs in both complete-load and inflate/NBT loops. These are not complete-load shares or strict speedup ceilings. Array decoding affects only part of payload work, while ASCII widening retains string allocation and map construction. Neither narrow candidate offers a credible incremental 5% complete `SaveDir::load` reduction; combining them would still require unusually large savings across both functions. The accepted palette and saved-light improvements are already in HEAD and are not counted again. No production edits, builds, timing runs, tests, parity jobs, candidate, commit or PR were made; no new performance/correctness result is claimed. + +Bounded evidence is outside Git at `/srv/bob-data/horizon-chunk-campaign-41055168/nbt-feasibility/`: source/accepted-binary hashes, assembly, pinned bytecode and the open-PR catalog. NBT source SHA256 remains `a32fd0ac8fe94ab1b23c000b51c3a81b28d40c518c5befb5272818792d1cf1ac`. The separate decompression lead for Round 10 is the existing profile's `inflate_fast_help_avx2` at 15.71% exclusive; no backend investigation was performed in this round. + + +## Round 10: whole-buffer zlib decompression — rejected + +Inspected the actual region decoder (`crates/horizon-world/src/compression.rs`), its flate2/zlib-rs backend, current open PRs and the official libdeflate/libdeflater API and portability documentation. No overlapping decompression PR was found on 2026-10-22. Tested libdeflater 1.26.1 as a safe whole-buffer zlib fast path, with the original decoder retained for errors and output limits. Gzip, uncompressed records, LZ4 and all encoding paths were unchanged. The initial output buffer used compressed length ×16, clamped to 16–128 KiB and the caller's output limit. All 3,285 scanned real zlib records, including proto chunks, fit that policy. + +The preserved accepted `fb2be075` saved-light executable is the baseline; source/dependency/resource/corpus hashes and release flags match the campaign protocol. After a discarded pair, the two-pair normal pilot improved complete loading by **11.908% and 11.941%**. The formatted candidate then completed five alternating process pairs per corpus after a discarded pair, with no concurrent builds/tests/profiles. Complete normal loading improved **11.079% (9.548–12.314%)**, from median 46.642 to 41.474 ms per 256 chunks; inflate/NBT improved 18.452%. Flat complete loading improved **2.568% (1.915–7.363%)**, 10.635 to 10.367 ms, supporting no 5% flat claim. All timed checksums match. Peak RSS ranges overlap (normal baseline/candidate medians 161,656/161,008 KiB; flat 160,860/160,188 KiB). The normal gain is incremental to accepted palette, aquifer and saved-light changes. + +Partial correctness gates passed for that candidate: four codec tests, including differential valid/damaged/truncated/trailing/concatenated/dictionary/limit streams and all 65,536 zlib headers; all **691 comprehensive loaded-metadata snapshots** match the accepted source byte-for-byte. A fresh pinned Minecraft 26.3 `RegionFileVersion` oracle generated 62 valid fixtures covering all four codecs, large/high-ratio data and Java zlib levels 0–9 with all three strategies. Both Rust implementations decode these exactly; Horizon encoding bytes match the original, and pinned Minecraft decodes all 62 Horizon outputs exactly. These are focused loading/codec checks, not a complete world-parity claim. + +Decision: **no-go because related valid-input workloads materially regress**. The initial bounded fast path adds a failed trial before legacy decode on high-ratio/large streams; isolated decode probes showed roughly 26–39% regressions for representative 60/64/128 KiB cases. Geometric output growth was also rejected after poor uniform-input results. A final bounded policy restricted the fast path to compressed records of 2–64 KiB, resolving those first cases, but 24 additional controlled-compressibility fixtures exposed **27–71% isolated decode regressions near 131 KiB**, about **26–27% at 256 KiB**, and about **9% on one 1 MiB case**. These microbenchmarks use the original and candidate decoder in the same release executable, a discarded pair and five alternating measured pairs; they are related-workload evidence, not complete-world timing claims. No complete-load gain is claimed for the final gated policy. Removing this tradeoff requires further design beyond this bounded attempt. + +All production and Cargo changes were restored exactly, and owned temporary examples were removed. No final repository quick-check, additional parity work, commit or PR was pursued after rejection. The shared release target contains rejected candidate artifacts and must not be used as an accepted baseline. Earlier campaign documentation, including the uncommitted Round 9 report, is preserved. Evidence remains outside Git at `/srv/bob-data/horizon-chunk-campaign-41055168/decompression/`: authenticated sources and binaries for each policy, dependencies, build/test logs, paired runners/raw observations, RSS, fresh Java fixtures/bytecode, 691 snapshot outputs, controlled-compressibility probes and `decision.json`. Agent 10 ends this optimization sequence; further work awaits user feedback. From fba42920e4c112893ceab14989e83069d113d898 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:15:41 +0100 Subject: [PATCH 45/59] Remove benchmark report from pull request --- docs/chunk-performance-campaign.md | 186 ----------------------------- 1 file changed, 186 deletions(-) delete mode 100644 docs/chunk-performance-campaign.md diff --git a/docs/chunk-performance-campaign.md b/docs/chunk-performance-campaign.md deleted file mode 100644 index 667b72b01..000000000 --- a/docs/chunk-performance-campaign.md +++ /dev/null @@ -1,186 +0,0 @@ -# Chunk generation and loading performance campaign - -Profiling baseline: `41055168afcd8687c7efe525545de896f17f4478` (2026-10-22). No production optimization is included in this profiling step. Measurements identify work to investigate; they do not establish a candidate speedup or complete Minecraft world parity. - -## Completed sequence: ten agents - -The ten sequential GPT-6.1 Sol/high agents are complete. Three production changes are retained in independent pull requests: - -| Change | Measured complete-workload reduction | Pull request | -| --- | --- | --- | -| Saved list-palette loading (Round 2) | 10.257% normal saved load | [#1223](https://github.com/ludovic111/horizon/pull/1223) | -| Aquifer neighborhood reuse (Rounds 3 and 7) | Primary generation + decoration: 4.152% / 2.377% at one/four workers | [#1229](https://github.com/ludovic111/horizon/pull/1229) | -| Saved-light reconstruction (Round 8) | 6.179% normal / 10.981% flat saved load, incremental to palette loading | [#1231](https://github.com/ludovic111/horizon/pull/1231) | - -These paired-median reductions have different workloads/baselines and must not be added together or treated as total game startup improvements. Retained changes passed their scoped pinned vanilla oracles, exact baseline/candidate snapshots, and repository quick self-checks. The final retained source passed 1,443 tests with serialization after an initial client-test crash. No universal world/gameplay parity claim is made. - -Surface dispatch, section access and NBT feasibility stopped early. The state-cache key candidate was reverted below the default 5% complete-load gate. Aquifer work resumed under the user's explicit lower threshold, then passed full qualification. The final decompression attempt passed the main loading gate but was reverted because related valid-stream workloads regressed. All rejected production/dependency changes are restored; no eleventh agent was started. Further optimization awaits user feedback. - -## Reproduction and artifacts - -Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM, Linux 7.2.11-zen1-1-zen x86_64; Rust/Cargo 1.99.0, OpenJDK 25.0.4.1. CPU boost remained enabled, governor `powersave`; normal desktop background activity was not isolated. Builds, timed workloads and sampling runs were sequential. Release uses `opt-level=3`, thin LTO, one codegen unit; client benchmarks disable audio/controllers and need no window/GPU. Do not compare these numbers directly with earlier `fast` profile reports. - -Private/generated evidence is outside Git at `/srv/bob-data/horizon-chunk-campaign-41055168/`: `baseline-raw.json`, `baseline-summary.json`, `run_baseline.py`, individual logs, preserved executables in `baseline/`, `binary-sha256.txt`, `fixture-sha256.txt`, the `*-profile.er` sampling experiments, and `*-functions.txt` tables. The matrix binaries are preserved separately from subsequent `*-profile` binaries. The latter add a structure timing field or optional worker execution for profiling; production sources are identical. Prepared resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Pinned jars and source artifacts: `/srv/bob-data/horizon/.local/minecraft/26.3`. - -```sh -CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-target cargo build --locked --release -p horizon-world --example chunkgen_bench -p horizon-client --no-default-features --example chunk_bench --example streaming_bench --example save_bench --example load_bench -``` - -`chunkgen_bench` now accepts `--warmup --json --no-map`. Warmup generates/discards an offset 9×9 region at center+(64,64), with the same seeded generator and a separate worker, before creating fresh measured workers. This removes lazy ring initialization from the steady workload without generating target chunks. Resource loading, generator construction, warmup, diagnostic output and map rendering remain outside the measured generation brackets. `BENCH` JSON reports exact elapsed seconds, process CPU accounting and cumulative stage wall brackets. Worker stage brackets are not exclusive CPU shares; elapsed/count has no thread multiplier. Non-warmed runs should be measured separately when changing startup behavior. - -`load_bench RESOURCES DIMENSION_DIR --rounds 5 --limit 256 --checksum` is read-only. It selects full chunks in sorted region/coordinate order, primes region handles and filesystem cache, then separately times `SaveDir::load` (region read, decompression, NBT, resident decode and saved light), decompression/NBT of retained compressed records, and native decode of retained tags. Allocation and destruction are inside each timed loop. Setup and checksums are outside. Stage times come from separate loops and must not be summed as an exact breakdown. It emits compressed-record SHA256 provenance and an optional complete blocks/biomes/light checksum; this checksum does not cover all saved metadata. - -## Baseline observations - -The primary workload uses seed 12345, center (0,0), size 16: 256 proto chunks and 196 interior decorations. One-worker/four-worker results have five processes each; Nether/End have three each. Values are medians. - -| Workload | Proto wall | Decoration wall | Combined ms/input chunk | -| --- | ---: | ---: | ---: | -| Overworld, 1 worker | 2.224094 s | 0.440144 s | 10.407179 | -| Overworld, 4 workers | 0.732982 s | 0.131088 s | 3.375274 | -| Nether, 1 worker | 0.981417 s | 0.084589 s | 4.164085 | -| End, 1 worker | 0.213254 s | 0.015784 s | 0.894681 | - -The one-worker Overworld brackets are approximately noise 4.20, surface 2.55, biomes 0.40 and carvers 0.34 ms/input chunk. A separate sampled size-32 run reports structures 0.395 ms/input chunk; its larger site mix differs from size 16. - -Resident `chunk_bench --seed 12345 --size 4`, three processes: finish 0.4 ms/chunk (rounded display), light median 1.43 ms/column, mesh 109.5 µs/section (each process reports its best of three mesh sweeps), 29.8 KiB resident storage/chunk. Before qualifying a finish/light/mesh change, emit exact timings on both revisions; existing rounded/best-of-three output is exploratory evidence only. - -`streaming_bench --threads 4 --radius 4 --seed 12345 --fly 4 --seconds 3 --hz 120`, three processes: fill median 1.21 s, 81 chunks generated and 504 sections meshed; median reported update p99 0.041 ms. Flight generates 121 chunks, with median update p99 0.207 ms and no sampled frame with an unlit column within two chunks of the player. This short fixed-duration flight is a responsiveness/throughput check, not a complete long-travel stress test. - -Saved loads use 256 full chunks, three independent processes, five measured rounds/process; table entries are the median of process medians for the whole 256-chunk batch. - -| Corpus | Complete load | Inflate + NBT | Native decode | -| --- | ---: | ---: | ---: | -| Normal vanilla 26.3, seed 12345 | 55.740 ms | 22.068 ms | 27.211 ms | -| Flat vanilla 26.3 locator fixture | 12.733 ms | 4.505 ms | 4.884 ms | - -The normal fixture was generated by the pinned local vanilla server, `level-type=minecraft:normal`, seed 12345, forced block bounds -128,-128 through 127,127, followed by `save-all flush` and clean stop. It contains 400 full chunks; the sorted limit selects 256. Files remain at `vanilla-normal/world/dimensions/minecraft/overworld` under the artifact root. Flat source is `/srv/bob-data/horizon/.local/locator-bar-parity/generate/world/dimensions/minecraft/overworld`. Normal compressed-record SHA256: `ff9bf9e822e334e117e3d6ba5c26a88b7698456ec6d83bdbe4355ad0af1d6f55`; blocks/biomes/light: `661dd26eed78b051afeca11d8ba69222162b5da72e5d1572a12ce2a3b3a4f764`. All three processes agree, and all 256 selected chunks have saved light. Flat checksums are in the raw logs. These are warm storage measurements; cold physical I/O and a remote multiplayer chunk stream are not measured. - -`save_bench` also read the 400 normal chunks and checked written compressed records byte-for-byte: median encode 139 ms, compression 141 ms, parallel SaveDir encode/compress/write 54 ms, five rounds. This checks existing save output consistency, not vanilla read/write parity. - -## CPU samples and ranked investigations - -`perf`, Valgrind and samply are unavailable; GNU gprofng 2.47 is installed. Collection uses `gprofng collect app -p hi -o OUTPUT.er BINARY ARGS`, nominally 997 µs samples. On this machine the collector warns that the initial thread's timer is cleared (`997 -> 0`). Initial-thread samples are therefore unusable. The measured terrain worker (thread 4) records 9.204 sampled CPU seconds against 9.22 process CPU seconds in its generation bracket; decoration worker threads record 3.098 seconds against 3.126 wall seconds. Their worker-only tables are retained as `terrain-worker-functions.txt` and `decoration-worker-functions.txt`. Startup/main-thread percentages must not be inferred from these samples. Streaming worker samples independently reproduce the same generation hotspots. - -The initial loader experiment captured only 0.108 sampled seconds against 10.899 process CPU seconds and is rejected. Repeating the identical code with optional `load_bench --profile-worker --rounds 100` captures 11.323 sampled seconds against 11.347 process CPU seconds; its table is `load-worker-profile-functions.txt`. In this mixed complete-load/NBT/native-decode workload, `PalettedContainer::from_packed` is 16.12% exclusive / 16.62% inclusive, zlib `inflate_fast_help_avx2` 15.71% exclusive, saved `load_light` 5.80% exclusive / 7.38% inclusive, and NBT `Reader::payload` 4.08% exclusive / 15.06% inclusive. Native `decode_column` is 46.97% inclusive. Formatting (`format_inner`) is 6.52% inclusive, including property-map Debug formatting at 4.79%; these nested shares cannot be added. These are shares of all three benchmark loops, not just the complete-load loop. Palette reconstruction/validation is the strongest loading lead; replacing the formatted per-chunk state-cache key is a smaller plausible lead requiring the full-load 5% gate. - -For the size-32 Overworld terrain worker, ranked opportunities outside the excluded PRs are: - -1. Aquifer `compute_substance`: 13.00% exclusive / 15.83% inclusive CPU. Investigate repeated nearest-cell/grid work while retaining exact distance ties, arithmetic, random draws and fluid scheduling. -2. Material `CompiledRule::apply`: 8.52% exclusive / 14.58% inclusive. Check the already-merged surface work before changing anything; inspect fresh evidence for remaining dispatch/data access, preserving condition order and random consumption. -3. `BlockSection::set` 6.09% and `get` 2.79%; decoration additionally spends 9.95% in `get`. Investigate construction/access patterns rather than changing vanilla palette semantics. Shared storage changes need broad callers and palette-width boundary validation. -4. Beardifier `sample_unchecked`: 4.78% exclusive. Recent bulk-density work is already in baseline; only a distinct measured bottleneck should proceed. -5. Decoration sculk `spread_all`: 8.82% exclusive / 22.85% inclusive of decoration-worker CPU at this larger site. Strongly site-dependent; require a matched sculk corpus before claiming a whole-workload win. - -Open/overlapping work excluded from optimization: #1208 Perlin floor/int conversion and float gradients; #1206 Perlin volume/climate lookup; #1207 feature-region grid, ore column/visited handling, lazy biome temperature; #1201 player proximity/ticket/requeue grids; #1192 worker priority; #1191 content/assets loading. Existing merged sampler reuse, neighbor generation, carver cache, surface, packed lighting and bulk density changes are part of this baseline. These exclusions cover the semantic mechanism, not merely the file paths. - -## Candidate acceptance protocol - -For each independent candidate, preserve identical benchmark sources, resource/corpus hashes, build flags and baseline/candidate executables. Do not compare against an open PR's branch. Run no builds, parity jobs or profilers concurrently with timed qualification. Use one discarded baseline/candidate process pair, then at least five measured pairs, alternating A/B and B/A order. Keep every observation; if external contention invalidates a batch, retain it and restart the entire batch with an explanation. - -Primary generation command: `chunkgen_bench RESOURCES --seed 12345 --size 16 --threads 1 --warmup --json --no-map`, repeated at four workers. Add seed -1 at center (32,-32), Nether and End, with five pairs for any affected claim. Report proto, decoration and complete proto+decoration wall time; input and decorated chunk counts must match. Retain a non-warmed check for startup regressions and streaming fill/flight for player-visible effects. - -Primary loading command: `load_bench RESOURCES NORMAL_DIMENSION --rounds 5 --limit 256 --checksum`, repeated with the flat fixture. Each process's median complete `load_s` is one observation; internal rounds are not independent processes. Report native decode and inflate/NBT alongside complete load. Use the same command without profiler-worker mode on both revisions for qualification. - -Open a PR only after the affected complete workload improves by at least 5% in the paired repeated measurements, the improvement is stable across the measured pairs, and correctness gates pass. Report median reduction and range of paired reductions; add pairs if noise makes the 5% threshold ambiguous. A 5% isolated-stage win without a 5% complete affected-workload win does not qualify. Check related workloads for material regression. Explain corpus-specific results instead of claiming universal speedups. - -Correctness gates must include exact baseline/candidate generated blocks, quart biomes, heightmaps, postprocessing, structures, block entities and metadata for affected cases, preserving RNG and iteration behavior, plus the pinned vanilla oracle. Use existing `tools/test_chunk_generation_parity.py` (full world stage comparisons), relevant noise/density/aquifer/material/feature/palette harnesses, and `tools/test_light_parity.py` if lighting changes. Cover negative/far coordinates, several seeds, all affected dimensions and both worker counts. `tools/parity.py --repeat 3 ...` checks repeated oracle/probe agreement; reused Java oracle output is suitable for Rust-only comparisons, with a fresh relevant oracle run before final qualification. - -Loading changes additionally require existing save unit tests and comprehensive baseline/candidate semantic output checks, including heightmaps, block entities, ticks, structures and preserved unknown NBT. The benchmark's block/biome/light checksum is only one gate. Use `tools/test_save_roundtrip_parity.py` for the full vanilla → Horizon → vanilla path when relevant. Prepared Java 25/pinned jars/resources make these checks feasible here; full roundtrip requires the repository's virtual-display/runtime setup and has not been run in this profiling step. No complete world-parity pass is claimed by this report. Run `python3 tools/pr_ready.py --base origin/main` and repository-required checks before any PR. - -## Agent 2: saved palette validation - -Candidate: list palettes in `PalettedContainer::from_packed` keep the saved words directly, so avoid allocating/filling the discarded unpacked-index vector. Reuse index validation, scanning words and their occupied slots in entry order; a palette filling the bit capacity cannot contain an invalid index. Global reencoding remains unchanged. The first invalid index, exact storage-length errors, unused high padding, palette order and resident words are preserved. Pinned 26.3 `PalettedContainer.unpack` bytecode was inspected first: matching list configurations retain `SimpleBitStorage` directly; global configurations reencode. No palette-related open PR overlap was found on 2026-10-22. - -Evidence: `/srv/bob-data/horizon-chunk-campaign-41055168/palette/`, `palette-pairs.py`, `palette-pilot.log`, `palette-qualification.log`, `palette-candidate.patch`, `palette-java-bytecode.txt`, and `palette-*.log`. Binary hashes and commands are recorded in `palette/binaries.json` and `*-raw.json`. The preserved baseline `load_bench-profile` is used without worker/profiler flags because its source exactly matches the candidate benchmark source, including the optional worker branch. Identical release flags, resources and compressed records were used. No builds, tests or profilers overlapped qualification. - -Three pilot pairs showed 9.77–10.28% complete normal-load reductions after a discarded pair. Qualification used five alternating process pairs per corpus, each after a discarded pair, with five measured rounds per process. Values below are medians of process medians for each 256-chunk batch; reductions are medians/ranges of the paired reductions. - -| Corpus / workload | Baseline | Candidate | Paired reduction (range) | -| --- | ---: | ---: | ---: | -| Normal complete load | 55.459 ms | 49.770 ms | 10.257% (9.656–10.573%) | -| Normal native decode | 26.263 ms | 19.902 ms | 24.188% (22.323–25.987%) | -| Normal inflate + NBT | 22.260 ms | 22.086 ms | 0.782% (-1.174–1.680%) | -| Flat complete load | 12.663 ms | 12.027 ms | 5.023% (2.609–5.617%) | -| Flat native decode | 5.170 ms | 4.220 ms | 13.908% (5.850–28.399%) | -| Flat inflate + NBT | 4.537 ms | 4.548 ms | -0.159% (-1.852–0.563%) | - -Normal clears the complete-workload 5% gate in every measured pair. Flat shows no observed regression, but its variation does not support a stable at-least-5% claim. This is a warm saved-load improvement on these fixtures, not a generation or cold-I/O claim. - -Correctness: all timed baseline/candidate compressed-record and block/biome/light hashes match. Core palette tests pass (7 passed; 2 existing ignored). A differential reference test covers all saved widths through 13, single/list/global modes, duplicate values, full-capacity palettes, absent/wrong storage, dirty word/final padding, and first-invalid-index errors; successful cases compare strategy, bits, palette and words exactly. A fresh pinned Java palette oracle passes 266 scenarios and 861,864 edits with identical hashes. Existing `save::tests` pass (19/19), including malformed packed palettes, stored light, block-entity roundtrips, file upgrades and level-file roundtrip. - -The temporary `load_snapshot.rs` harness and true baseline/candidate binaries are archived under `palette/`; the harness was removed from the working tree. It hashes resident palette/word representations and light values, canonical complete reencoded NBT (including heightmaps/block entities), saved root NBT/block-entity sources/order/ticks, and loaded flags, names, postprocessing, entities and structure references. Every full chunk was checked: 400 normal and 289 flat, plus a synthetic nested unknown NBT key and nonempty block/fluid ticks for each corpus. All 691 per-case baseline/candidate outputs match byte-for-byte. `palette/correctness.json` records hashes; `palette/sources.json` authenticates both core sources and the harness. Exact candidate source was restored after the baseline comparison. - -Both baseline and candidate also ran `save_parity` against the pinned vanilla-generated worlds: 324 interior normal chunks have zero block, biome, heightmap or other metadata differences, with the same preexisting 7/63,700,992 recomputed light-value differences in both revisions. All checks on 225 interior flat chunks are identical to vanilla, including all 44,236,800 light values. This establishes no added discrepancy in these comparisons; it is not a clean normal-world lighting parity pass. The full server/client `test_save_roundtrip_parity.py` simulation was not run; the candidate changes only loading/validation, and the read-only full-output comparison covers unchanged save output. No generation parity claim or PR is included in this agent's result. - - -## Round 3: aquifer neighborhood pilot — rejected - -Inspected the pinned server 26.3 `Aquifer.NoiseBasedAquifer.computeSubstance` bytecode and current open PRs; no aquifer optimization overlap was found. Tested a single-current-grid cache of the 12 decoded candidate positions/indices, populated in vanilla cell order only after successful checked accesses, plus explicit four-slot nearest insertion preserving later-cell distance ties. The candidate touched only `worldgen/aquifer/noise_based.rs`; no noise evaluation or terrain traversal was changed. - -Evidence is retained in `/srv/bob-data/horizon-chunk-campaign-41055168/aquifer/`: baseline source, candidate patch, preserved candidate executable, binary hashes, build log, pilot script, all process logs, `pilot-raw.json` and `summary.json`. Pinned Java bytecode is in `aquifer-java-bytecode.txt` at the parent artifact root. The benchmark source SHA256 is `f404feb7ec526f12735d11b15af36254fd585f39b975cdbdc71905d87f10f8cc`, identical to the preserved `chunkgen_bench-profile` baseline source. Both executables use the established release flags and resources. No builds, tests or profilers ran during timing. - -One discarded process pair followed by three alternating pairs used the primary seed-12345, center-(0,0), size-16, one-worker warmed command. Every process generated 256 proto chunks and decorated 196 chunks. Complete proto+decoration paired reductions were **3.864%, 4.326%, 3.828%** (median **3.864%**); baseline/candidate complete-time medians were **2.678451 s / 2.568094 s**. This does not clear the 5% complete-workload gate. The pilot had already completed when the parent requested early cancellation. The production candidate was reverted; no qualification, four-worker/second-site matrix, parity tests, generated snapshots or PR were pursued. No correctness claim is made for the rejected candidate. This result applies to this mechanism and corpus, not an upper bound on all aquifer optimization. - -Next lead: remaining material-rule dispatch/data access (8.52% exclusive terrain-worker CPU), after checking the already-merged surface changes. Preserve rule evaluation order and random consumption; reject early if its complete-workload pilot remains below 5%. - - -## Round 4: remaining material-rule dispatch — early no-go - -Inspected merged #801 (`Specialize constant surface material-rule branches`), `docs/surface-generation-benchmark.md`, the current compiled rule/condition/density implementation, and the pinned 26.3 material resources and Java `ConditionRule`, `SequenceRule`, `OreVeinRule`, and `BlockRule` bytecode. The open-PR list was checked on 2026-10-22; no additional material-rule dispatch PR was found, and the campaign's excluded mechanisms were left untouched. Inspection evidence is retained under `/srv/bob-data/horizon-chunk-campaign-41055168/surface-feasibility/`: `pinned-material-bytecode.txt` and `inspection.json` (source commit, pinned server-game SHA256, and static expanded rule counts). - -The existing implementation already removes constant predicates and singleton/empty sequences after compiling all children, shares eager density roots, and uses unit-step material-volume indexing. The 8.52% exclusive terrain-worker sample share for `CompiledRule::apply` includes ore-vein execution and inlined work, so it cannot be treated as removable dispatch overhead. Vanilla's top-level Overworld sequence includes both ore-vein rules before the surface predicate and underground rules. Condition/block fusion or flattening nested sequences would remove only part of this work; a broad replacement evaluator would be a speculative refactor without evidence for the required complete-workload gain. The raw expanded Overworld resource tree contains 53 sequences, 149 conditions, 110 blocks, two ore-vein rules and two band rules; these static counts precede constant specialization and are not runtime frequencies. - -Decision: **early no-go**, accepted by the parent before implementation. No production source or tests were changed, no build/timing/parity jobs were run, and no candidate or PR was created. This is a feasibility rejection, not a measured performance result or an upper bound on future material optimizations. The rejected aquifer executable in the shared target directory was not used. Earlier campaign evidence and the uncommitted Round 3 report were preserved. - - -## Round 5: section access and construction — early no-go - -Inspected `BlockSection` get/set/construction, `PackedStorage` addressing, the existing ignored section microbenchmark and differential tests, and merged commits `939eabe6`, `56a251eb` and `5c55e7d8`. Checked the open-PR list on 2026-10-22; no section-storage optimization overlap was found. Pinned 26.3 `LevelChunkSection`, `PalettedContainer` and `SimpleBitStorage` bytecode was inspected before considering changes. Evidence is retained in `/srv/bob-data/horizon-chunk-campaign-41055168/section-feasibility/`: `pinned-section-bytecode.txt`, `baseline-access-assembly.txt` and `inspection.json` (source/pinned-jar/baseline hashes and the bounded open-PR catalog). - -The current implementation already reads the old packed index directly, resolves the incoming state with one multiplicative-hash map probe, reuses freed palette slots, and skips repeated storage validation after the section checks. The ignored microbenchmark compares against older pre-optimization implementations; its historical speedups are already in the campaign baseline and cannot qualify a new candidate. Uniform construction still allocates palette/count/map storage, but construction is not identified as a substantial exclusive hotspot in the retained profile. - -The preserved baseline executable confirms runtime division in packed-index addressing; pinned Java uses reciprocal multiplication in `SimpleBitStorage.cellIndex`. This is a possible future storage investigation, but the division is only part of the sampled access cost, alongside palette/word loads, incoming-state lookup and count/free-slot handling. Terrain samples assign 6.09% exclusive CPU to `set` and 2.79% to `get`, while the separate decoration sample assigns 9.95% to `get`; these site-specific shares are not a measured removable fraction or a complete-workload speedup prediction. There is no evidence here that a small addressing or construction change can remove enough complete proto-plus-decoration work to meet the 5% gate. A dense representation or bulk terrain writer would need broader semantic and workload evidence and was not attempted. - -Decision: **early no-go**, accepted by the parent before implementation. No production source or tests were changed, no build/timing/parity jobs were run, and no candidate or PR was created. No new correctness or performance result is claimed. The rejected aquifer executable in the shared target directory was not used; assembly inspection used the preserved genuine baseline. Earlier campaign evidence and uncommitted Round 3/4 reports were preserved. - - -## Round 6: saved block-state cache keys — rejected - -Inspected the loader's formatted per-chunk state-cache keys, `BlockState::from_nbt`, registry lookup/default fallback, and pinned 26.3 `StateHolder.codec`/`BlockState` bytecode. Checked the open-PR list on 2026-10-22; no saved-state-cache optimization overlap was found. The candidate derived `Hash` for `BlockState` and replaced the formatted string key with the parsed structural state. Invalid parse results returned air directly; the existing registry/default-property resolution was retained. No palette or lighting code changed. - -Evidence is retained under `/srv/bob-data/horizon-chunk-campaign-41055168/state-key/`: candidate patch and sources, preserved baseline source copies, pinned bytecode, bounded open-PR catalog, build log, paired runner, raw process observations/logs, executable hashes and summary. The baseline was the preserved **accepted palette candidate**, so these results are incremental to commit `5d82b4c9`, with none of its earlier gain counted again. Both binaries used identical `load_bench` source (SHA256 `b6f5042731d7c9d5622758043f7c1e125a3f7d098c57ee0501012474c2df7325`), release/thin-LTO/one-codegen-unit flags, resources and normal corpus. No builds, tests or profilers overlapped timing. - -One discarded process pair followed by two alternating measured pairs used `--rounds 5 --limit 256 --checksum`. Complete normal-load paired reductions were **3.257% and 2.412%** (median **2.835%**); baseline/candidate process-median medians were **49.725 / 48.316 ms** per 256 chunks. Native decode improved **5.917%** (20.266 / 19.067 ms); inflate/NBT varied by **-0.844%**. Compressed-record and block/biome/light checksums matched in every process. Those checksums are limited benchmark checks, not comprehensive semantic or vanilla parity evidence. - -Decision: **early no-go** at the incremental 5% complete-load gate. Both production files were restored exactly to their pre-candidate contents; only this report remains. No flat/long qualification, comprehensive snapshot comparison, fresh parity suite, tests, commit or PR were pursued for this rejected candidate. The shared Cargo target contains the rejected executable; future work must use the preserved accepted binary or rebuild restored sources. - - -## Round 7: aquifer qualification — retained - -The user explicitly accepted the aquifer pilot's smaller gain and later confirmed the repeated 3.3–3.5% observations were sufficient. The candidate was restored and qualified with five alternating process pairs per workload, startup/streaming/memory checks, fresh client/server aquifer/terrain/material oracles, and 36 exact pre/post-decoration snapshot comparisons. All 20 measured Overworld pairs improve; no material regression was established in the declared checks. The cache adds 312 bytes per transient aquifer object with no new allocation calls. Full results, limitations and reproduction are in [PR #1229](https://github.com/ludovic111/horizon/pull/1229). - -## Round 8: saved-light loading — retained - -Detect uniform saved nibble layers before allocation and decode remaining layers in byte pairs. Final-source complete loading improves by paired medians 6.179% normal and 10.981% flat, incremental to the accepted palette optimization. All ten measured pairs improve. All 691 full metadata snapshots and 50,331,648 fresh pinned Java light values match; the repository quick self-check passes with 1,443 tests. The separate native-decode loop measured slower despite unchanged source; its cause remains unisolated and is disclosed in [PR #1231](https://github.com/ludovic111/horizon/pull/1231). - -## Round 9: NBT payload and modified-UTF fast paths — early no-go - -Inspected the unchanged NBT reader at accepted HEAD `fb2be075` and its actual release assembly in the preserved accepted saved-light executable; captured pinned 26.3 integer-array/JDK modified-UTF bytecode for evidence. Checked the open-PR catalog on 2026-10-22; no NBT-reader optimization overlap was found. Two concrete candidates were bulk big-endian integer-array decoding after one checked slice, avoiding repeated per-element bounds/offset/push checks, and an ASCII widening path before the existing lossless modified-UTF decoder. The latter must retain raw NUL, accepted overlong sequences and unpaired UTF-16 surrogates; arrays must retain count/byte-limit/truncation errors and offsets. - -Decision: **early no-go before implementation**. The valid original mixed-loader profile attributes 4.08% exclusive to all `Reader::payload` work and 2.96% exclusive to all `Reader::string` work; NBT runs in both complete-load and inflate/NBT loops. These are not complete-load shares or strict speedup ceilings. Array decoding affects only part of payload work, while ASCII widening retains string allocation and map construction. Neither narrow candidate offers a credible incremental 5% complete `SaveDir::load` reduction; combining them would still require unusually large savings across both functions. The accepted palette and saved-light improvements are already in HEAD and are not counted again. No production edits, builds, timing runs, tests, parity jobs, candidate, commit or PR were made; no new performance/correctness result is claimed. - -Bounded evidence is outside Git at `/srv/bob-data/horizon-chunk-campaign-41055168/nbt-feasibility/`: source/accepted-binary hashes, assembly, pinned bytecode and the open-PR catalog. NBT source SHA256 remains `a32fd0ac8fe94ab1b23c000b51c3a81b28d40c518c5befb5272818792d1cf1ac`. The separate decompression lead for Round 10 is the existing profile's `inflate_fast_help_avx2` at 15.71% exclusive; no backend investigation was performed in this round. - - -## Round 10: whole-buffer zlib decompression — rejected - -Inspected the actual region decoder (`crates/horizon-world/src/compression.rs`), its flate2/zlib-rs backend, current open PRs and the official libdeflate/libdeflater API and portability documentation. No overlapping decompression PR was found on 2026-10-22. Tested libdeflater 1.26.1 as a safe whole-buffer zlib fast path, with the original decoder retained for errors and output limits. Gzip, uncompressed records, LZ4 and all encoding paths were unchanged. The initial output buffer used compressed length ×16, clamped to 16–128 KiB and the caller's output limit. All 3,285 scanned real zlib records, including proto chunks, fit that policy. - -The preserved accepted `fb2be075` saved-light executable is the baseline; source/dependency/resource/corpus hashes and release flags match the campaign protocol. After a discarded pair, the two-pair normal pilot improved complete loading by **11.908% and 11.941%**. The formatted candidate then completed five alternating process pairs per corpus after a discarded pair, with no concurrent builds/tests/profiles. Complete normal loading improved **11.079% (9.548–12.314%)**, from median 46.642 to 41.474 ms per 256 chunks; inflate/NBT improved 18.452%. Flat complete loading improved **2.568% (1.915–7.363%)**, 10.635 to 10.367 ms, supporting no 5% flat claim. All timed checksums match. Peak RSS ranges overlap (normal baseline/candidate medians 161,656/161,008 KiB; flat 160,860/160,188 KiB). The normal gain is incremental to accepted palette, aquifer and saved-light changes. - -Partial correctness gates passed for that candidate: four codec tests, including differential valid/damaged/truncated/trailing/concatenated/dictionary/limit streams and all 65,536 zlib headers; all **691 comprehensive loaded-metadata snapshots** match the accepted source byte-for-byte. A fresh pinned Minecraft 26.3 `RegionFileVersion` oracle generated 62 valid fixtures covering all four codecs, large/high-ratio data and Java zlib levels 0–9 with all three strategies. Both Rust implementations decode these exactly; Horizon encoding bytes match the original, and pinned Minecraft decodes all 62 Horizon outputs exactly. These are focused loading/codec checks, not a complete world-parity claim. - -Decision: **no-go because related valid-input workloads materially regress**. The initial bounded fast path adds a failed trial before legacy decode on high-ratio/large streams; isolated decode probes showed roughly 26–39% regressions for representative 60/64/128 KiB cases. Geometric output growth was also rejected after poor uniform-input results. A final bounded policy restricted the fast path to compressed records of 2–64 KiB, resolving those first cases, but 24 additional controlled-compressibility fixtures exposed **27–71% isolated decode regressions near 131 KiB**, about **26–27% at 256 KiB**, and about **9% on one 1 MiB case**. These microbenchmarks use the original and candidate decoder in the same release executable, a discarded pair and five alternating measured pairs; they are related-workload evidence, not complete-world timing claims. No complete-load gain is claimed for the final gated policy. Removing this tradeoff requires further design beyond this bounded attempt. - -All production and Cargo changes were restored exactly, and owned temporary examples were removed. No final repository quick-check, additional parity work, commit or PR was pursued after rejection. The shared release target contains rejected candidate artifacts and must not be used as an accepted baseline. Earlier campaign documentation, including the uncommitted Round 9 report, is preserved. Evidence remains outside Git at `/srv/bob-data/horizon-chunk-campaign-41055168/decompression/`: authenticated sources and binaries for each policy, dependencies, build/test logs, paired runners/raw observations, RSS, fresh Java fixtures/bytecode, 691 snapshot outputs, controlled-compressibility probes and `decision.json`. Agent 10 ends this optimization sequence; further work awaits user feedback. From b054c8db1156c63e5c97584d01897ef7c3730609 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:15:44 +0100 Subject: [PATCH 46/59] Remove benchmark report from pull request --- docs/aquifer-cache-benchmark.md | 56 --------------------------------- 1 file changed, 56 deletions(-) delete mode 100644 docs/aquifer-cache-benchmark.md diff --git a/docs/aquifer-cache-benchmark.md b/docs/aquifer-cache-benchmark.md deleted file mode 100644 index 09ce2558b..000000000 --- a/docs/aquifer-cache-benchmark.md +++ /dev/null @@ -1,56 +0,0 @@ -# Aquifer neighborhood cache benchmark - -Caching the most recently used aquifer grid neighborhood reduces complete Overworld proto-generation plus decoration by a median **4.152% with one worker** and **2.377% with four workers** at the primary site. A second site improves **3.865% / 3.275%**. All 20 measured Overworld pairs improve. The implementation changes only `worldgen/aquifer/noise_based.rs`. - -## Implementation and scope - -Keep the twelve decoded cell positions and indices for the current grid in vanilla traversal order. Publish a replacement neighborhood only after every checked grid access succeeds; location entries initialized before an error remain visible in their original order. Reuse the neighborhood while its grid key matches. The existing location/status/surface caches retain their behavior. Explicit four-slot nearest insertion preserves later-cell distance ties (`<=`), wrapping distance arithmetic, random draw order, sampler/error order and fluid-update scheduling. Pinned 26.3 `Aquifer.NoiseBasedAquifer.computeSubstance` bytecode was inspected before implementation. - -No overlap with open aquifer work was found on 2026-10-22. The excluded Perlin, climate, feature-region, ore, biome-temperature and chunk-bookkeeping mechanisms are unchanged. Baseline `753c071c` includes the accepted saved-palette optimization; both variants contain that same loading code. These generation results measure only the aquifer change. - -## Measurements - -AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM; Linux 7.2.11-zen1-1-zen; Rust 1.99.0; release optimization, thin LTO, one codegen unit. Boost stayed enabled with the powersave governor and ordinary desktop activity. Resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Both executables were rebuilt from accepted sources with identical benchmark source (SHA256 `f404feb7ec526f12735d11b15af36254fd585f39b975cdbdc71905d87f10f8cc`), dependencies, resources and flags. Builds, tests and profiling did not overlap qualification timing. - -Every row uses one discarded process pair, then five measured pairs alternating baseline/candidate order. All 84 processes produced 256 proto chunks and 196 interior decorations. Warmup generates/discards an offset 9×9 region before fresh measured workers. Primary seed/center: 12345/(0,0); second: -1/(32,-32). Values are process-median **milliseconds for the complete 256-input-chunk batch**, without a thread multiplier. Stage medians need not sum to the combined median. Reductions are medians/ranges of per-pair reductions, so they need not equal the ratio of the independently reported medians. - -| Workload | Proto baseline → candidate | Decoration baseline → candidate | Combined baseline → candidate | Paired combined reduction (range) | -| --- | ---: | ---: | ---: | ---: | -| Primary Overworld, 1 worker | 2224.363 → 2135.304 | 442.671 → 438.347 | 2667.810 → 2575.518 | 4.152% (3.324–5.131%) | -| Primary Overworld, 4 workers | 733.644 → 716.328 | 131.039 → 128.976 | 864.363 → 844.938 | 2.377% (0.736–2.800%) | -| Second Overworld, 1 worker | 1994.369 → 1913.935 | 233.564 → 230.780 | 2230.391 → 2143.154 | 3.865% (3.552–4.144%) | -| Second Overworld, 4 workers | 572.673 → 551.555 | 68.164 → 67.669 | 640.836 → 618.820 | 3.275% (2.561–4.469%) | -| Nether, 1 worker | 969.751 → 962.970 | 87.048 → 85.903 | 1058.483 → 1048.873 | 0.730% (-2.406–1.096%) | -| End, 1 worker | 211.710 → 211.837 | 15.689 → 16.119 | 227.650 → 228.151 | -0.175% (-1.801–1.859%) | -| Primary Overworld, non-warmed, 1 worker | 4361.328 → 4256.020 | 442.196 → 437.629 | 4804.541 → 4691.376 | 2.177% (1.743–4.552%) | - -The non-warmed row retains lazy generator initialization. Resource loading remains outside the generation brackets; whole-process duration was also recorded and its non-warmed paired median improves 1.733%. Nether/End show ordinary variation, including a 0.175% End combined slowdown (about 0.5 ms per batch); no material regression is established there. - -Five alternating streaming pairs after a discarded pair use four workers, radius 4, seed 12345, a three-second flight at speed 4 and 120 Hz. Median fill is 1.21 → 1.19 s with identical 81 generated chunks/504 meshed sections. Flight produces identical 121 chunks/1,704 sections. Fill update p99 is unchanged at 0.041 ms; flight p99 is 0.200 → 0.208 ms and maximum update is 0.28 → 0.23 ms. All twelve runs have zero nearby unlit frames. This short route checks responsiveness and output counts; it is not a long-travel throughput claim. - -## Footprint - -The twelve-entry cache field occupies 312 bytes on this platform, inline in the existing aquifer object, and adds no allocation calls or independently growing buffer. It enlarges the existing transient aquifer object, which is discarded after generation; resident and saved chunk representations are unchanged. Peak RSS medians are 732,032 → 732,088 KiB (primary one-worker) and 756,724 → 759,768 KiB (four-worker). Paired RSS ranges span increases and decreases; the four-worker median difference is about 0.4% of process RSS. The release executable text grows by 3,872 bytes (about 0.075%). - -## Correctness - -- Fresh authenticated vanilla 26.3 aquifer oracle: **379 fixtures, 389,804 exact lines per client/server JAR**. Covers modern/legacy factories, repeated/reversed queries, negative/wrapped coordinates, nonfinite inputs, sampler/picker traces, fluid scheduling, location/status/surface caches, bounds failures and all 18 injected sampler failure/retry cases. -- Fresh terrain-fill oracle: **114 fixtures, 200 fills, 7,950,873 exact lines per JAR**, including 61 noise-aquifer fixtures, 24 structure-density fixtures, repeated/prefilled/clipped fills, raw blocks, WG heightmaps and ordered fluid postprocessing. -- Fresh material-stage oracle: **79 fixtures, 106 surface builds, 42 generated-carving passes, 6,733,382 exact lines per JAR**, including real biome neighborhoods, aquifer traces, carving masks, top-material queries, complete sections, heightmaps and postprocessing. -- **36/36 exact baseline/candidate phase snapshots match**: three dimensions × three seeds/sites × one/four workers × before/after decoration. Each region retains 81 chunks and decorates 49 interior chunks, totaling 1,458 retained chunks per phase and 882 decorations. Seeds/sites are 12345/(0,0), -1/(-32,32), and 81985529216486895/(1874990,-1874990). Snapshots include resident palettes/words and public block reads, quart biomes, all six heightmaps, ordered postprocessing, structure summaries, binary-NBT entities/block entities, complete scheduled ticks, stage/decorated/retrogen metadata and actual non-air counts. Temporary diagnostic source was removed. A final production-only rebuild with the original package feature graph is byte-identical to the measured candidate executable (SHA256 `3b4e07bd9189270c7e0a4521bd25e156f932014d976b1c4208cde4769d5fd8ea`). - -These checks establish unchanged output for the declared cases. Complete world/gameplay parity and cold physical I/O are outside this comparison. - -## Reproduction and evidence - -Private/generated artifacts are outside Git at `/srv/bob-data/horizon-chunk-campaign-41055168/aquifer-qualification/`: preserved binaries/sources and hashes, build logs, `pairs.py`, `matrix-raw.json`, `matrix-summary.json`, every process log, streaming runner/raw/summary, snapshot source/runner/outputs, and fresh oracle reports/inputs/outputs. Oracle runners retain the repository's corpus/comparison/authentication logic, with isolated output storage and absolute hash-map keys; the worldgen runner selects only `noise_aquifer_corpus`. - -```sh -CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-target cargo build --locked --release -p horizon-world --example chunkgen_bench -p horizon-client --no-default-features --example streaming_bench -python3 /srv/bob-data/horizon-chunk-campaign-41055168/aquifer-qualification/pairs.py -python3 /srv/bob-data/horizon-chunk-campaign-41055168/aquifer-qualification/streaming.py -``` - -The standard warmed generation command is `chunkgen_bench RESOURCES --seed 12345 --size 16 --threads 1 --warmup --json --no-map`; use four workers for the parallel row and `--seed -1 --center 32 -32` for the second site. - -Repository quick self-check passes: `CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-check-target python3 tools/pr_ready.py --quick --base origin/main` (4 min 23 s). Public-tree validation, workspace rustfmt, clippy with warnings denied, **1,442 client/core/world tests** and the doc-test step pass. The quick check lists affected parity harnesses; the three fresh relevant oracle suites above were executed separately. Full log: `aquifer-qualification/pr-ready.txt`. From ca2d5e04dc35394c859146a64d35f47e1e2c1059 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:15:46 +0100 Subject: [PATCH 47/59] Remove benchmark report from pull request --- docs/saved-light-loading-benchmark.md | 44 --------------------------- 1 file changed, 44 deletions(-) delete mode 100644 docs/saved-light-loading-benchmark.md diff --git a/docs/saved-light-loading-benchmark.md b/docs/saved-light-loading-benchmark.md deleted file mode 100644 index f11d72443..000000000 --- a/docs/saved-light-loading-benchmark.md +++ /dev/null @@ -1,44 +0,0 @@ -# Saved-light loading benchmark - -Saved-light reconstruction reduces complete saved-chunk loading by a median **6.179% on the normal world** and **10.981% on the flat world**, incremental to the accepted palette-loading optimization. Every measured process pair improves. The implementation changes only `save.rs::load_light` and its tests. - -## Implementation and scope - -Detect uniform stored nibble layers before allocating expanded resident light. Both nibbles must match: repeated bytes such as `0xF0` and `0x0F` remain nonuniform. Decode two resident light values per stored byte for remaining layers. Preserve section compaction, low-nibble-first indexing, missing-block darkness, missing-sky bottom-row inheritance, skyless behavior, section bounds, last duplicate section, invalid array handling, and loaded flags. Pinned Minecraft 26.3 `DataLayer` and `SkyLightSectionStorage.repeatFirstLayer` bytecode was inspected first. No saved-light optimization overlap was found among the 34 open PRs checked on 2026-10-22. - -## Measurements - -Baseline `411c5574` includes accepted palette loading and aquifer changes; the candidate differs only in saved-light reconstruction. Both loader executables were rebuilt from those sources using identical benchmark source (SHA256 `b6f5042731d7c9d5622758043f7c1e125a3f7d098c57ee0501012474c2df7325`), dependencies, resources and flags. Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM; Linux 7.2.11-zen1-1-zen; Rust 1.99.0. Release optimization, thin LTO, one codegen unit, client default features disabled; CPU boost enabled, powersave governor, ordinary desktop activity. No builds, tests or profiles overlapped timing. - -Each corpus uses one discarded process pair followed by five measured pairs in alternating baseline/candidate order. Each observation is a process's median of five rounds loading the same sorted 256 full chunks. Checksumming and setup are outside timing; allocation/destruction and region reads/decompression/NBT/native decode/saved light are inside complete loading. Storage is warm. Reductions are medians/ranges of paired reductions; independently reported medians need not give the same ratio. Separate stage loops do not sum to a timing breakdown. - -| Corpus | Complete load, baseline → candidate | Paired reduction (range) | Inflate/NBT, baseline → candidate | Native decode, baseline → candidate | -| --- | ---: | ---: | ---: | ---: | -| Normal vanilla 26.3, seed 12345 | 50.036 → 47.005 ms | 6.179% (5.217–6.836%) | 22.187 → 22.087 ms | 20.464 → 21.621 ms | -| Flat vanilla 26.3 | 12.030 → 10.688 ms | 10.981% (10.423–11.751%) | 4.562 → 4.549 ms | 4.076 → 4.183 ms | - -Values are milliseconds per complete 256-chunk batch. The separate native-decode loop slows by a paired median 4.644% on normal and 3.185% on flat; the flat observations are variable. Its source is unchanged, and the cause of this separate-loop change was not isolated. Complete `SaveDir::load`, which includes native decode and saved light, improves in all ten measured pairs. The earlier two-pair normal pilot improved 5.894% and 6.553%; final-source qualification was repeated after the iterator syntax change. All timed compressed-record and block/biome/light hashes agree. Normal compressed records: `ff9bf9e822e334e117e3d6ba5c26a88b7698456ec6d83bdbe4355ad0af1d6f55`; block/biome/light: `661dd26eed78b051afeca11d8ba69222162b5da72e5d1572a12ce2a3b3a4f764`. - -## Correctness - -All 20 save unit tests pass. The new differential test compares the original loader with the candidate for every repeated packed byte, all 256 pairs of uniform sky/block nibble values, nonuniform inherited rows, missing/wrong layer types and lengths, skyless dimensions, out-of-range/invalid section Y values and duplicate sections. It compares every resident light value, uniform/full representation, block/biome storage and loaded flags. - -A fresh pinned Java 26.3 oracle uses `DataLayer.get` and `SkyLightSectionStorage.repeatFirstLayer` over all 256 repeated byte patterns in both sky modes. Baseline and candidate exactly match all **50,331,648 light values** plus flags (SHA256 `608bab077edc713110f827740cb5d9baf2af9c1a251ea2458441e2d981f25920`). - -The same comprehensive snapshot harness runs on the actual accepted-source baseline and final candidate: **400 normal chunks, 289 flat chunks, and two synthetic unknown-NBT/nonempty-tick cases**. All 691 outputs match byte-for-byte. It covers resident blocks/biomes/light, complete reencoded NBT, heightmaps, block entities and their saved sources/order, structures, unknown NBT, ticks, postprocessing, entities, names and loaded/arrival flags. Light representation is additionally covered by the unit test. Temporary diagnostic sources were removed. - -The final source uses the fixed-size chunk iterator syntax required by Clippy. Its rebuilt executable (SHA256 `40d7031e7d3efe785815b1286af05553807bbc59f66a9275a5f89191f0ecda7e`) is the one used for final qualification; snapshot/oracle harnesses use the same production source. Earlier pilot artifacts are retained separately: section extraction normalized ELF metadata (original timed SHA256 `eb28209fd54b6deedab1ff701c291ae36b8116b2ba52a02d1ec82600b57e427f`; normalized SHA256 `78f2092b2661655fdea8d0fa2247389ccc8f48f37dd9abfbb8d8864867187297`). Those earlier artifacts are superseded by the final-source qualification. - -The required repository quick self-check passes: public-tree validation, formatting, Clippy with warnings denied, **1,443 client/core/world tests**, and the doc-test step. Command: `RUST_TEST_THREADS=1 CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-check-target python3 tools/pr_ready.py --quick --base origin/main` (11 min 15 s). Tests were serialized after an initial client-test process SIGSEGV; the failed log is retained as `pr-ready-attempt1.txt`. Relevant oracle checks were run separately; `--quick` lists other affected parity harnesses for CI. - -## Reproduction and evidence - -Private/generated evidence: `/srv/bob-data/horizon-chunk-campaign-41055168/saved-light/`. Preserved baseline/candidate sources and executables, source/binary hashes, open-PR catalog, pinned bytecode, build logs, `final-pairs.py`, `final-raw.json`, final qualification logs and `final-summary.json`; earlier pilot/qualification artifacts are retained there. Resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Normal corpus: `/srv/bob-data/horizon-chunk-campaign-41055168/vanilla-normal/world/dimensions/minecraft/overworld`; flat: `/srv/bob-data/horizon/.local/locator-bar-parity/generate/world/dimensions/minecraft/overworld`. - -```sh -CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-target cargo build --locked --release -p horizon-client --no-default-features --example load_bench -load_bench RESOURCES DIMENSION_DIR --rounds 5 --limit 256 --checksum -python3 /srv/bob-data/horizon-chunk-campaign-41055168/saved-light/final-pairs.py final 5 -``` - -These results cover the declared warm saved-load workloads. Cold physical I/O, remote chunk streams and complete gameplay parity are outside this comparison. From d86a1b2882b81d403bde2f02076143ab50814dad Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:26:39 +0100 Subject: [PATCH 48/59] Fix cooldown after instant survival breaks in multiplayer --- crates/horizon-client/src/game/remote.rs | 4 +- tests/test_remote_mining.py | 149 +++++++++++++++++++++++ tools/test_first_person_parity.py | 6 + 3 files changed, 156 insertions(+), 3 deletions(-) create mode 100644 tests/test_remote_mining.py diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..ea12eb4d2 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3309,10 +3309,8 @@ impl Game<'_> { sequence: seq, })); if progress >= 1.0 { + // startDestroyBlock: instant survival breaks have no destroy delay. self.predict_break(hit.pos, state, seq); - if let Some(r) = self.remote.as_mut() { - r.destroy_delay = 5; - } return; } if let Some(r) = self.remote.as_mut() { diff --git a/tests/test_remote_mining.py b/tests/test_remote_mining.py new file mode 100644 index 000000000..236b85c28 --- /dev/null +++ b/tests/test_remote_mining.py @@ -0,0 +1,149 @@ +"""Exercise the live remote_mining method with scripted world and packet sinks. + +Vanilla reference: MultiPlayerGameMode.startDestroyBlock/continueDestroyBlock. +The first_person parity harness separately checks consecutive instant breaks +against the pinned client; this fixture catches drift in the multiplayer path. +""" +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + + +ROOT = Path(__file__).resolve().parents[1] + + +@unittest.skipUnless(shutil.which("rustc"), "requires Rust") +class RemoteMiningTests(unittest.TestCase): + def test_break_timing_and_packets(self): + source = (ROOT / "crates/horizon-client/src/game/remote.rs").read_text() + start = source.index(" fn remote_mining(") + end = source.index(" /// MultiPlayerGameMode.destroyBlock", start) + fixture = r''' +#![allow(dead_code)] +#[derive(Clone, Copy)] +struct Hit { pos: [i32; 3], face: u8 } +struct Mining { pos: [i32; 3], progress: f32, ticks: u32 } +#[derive(Default)] +struct Remote { destroy_delay: u32, destroying: Option<([i32; 3], u8, f32)> } +struct Ground { on_ground: bool } +struct Player { ground: Ground } +#[derive(Clone)] +struct Sounds { hit: String, volume: f32, pitch: f32 } +#[derive(Clone)] +struct Facts { hardness: f32, name: String, requires_tool: bool, sounds: Sounds } +struct Resources { facts: Facts, speed: f32 } +impl Resources { + fn facts(&self) -> &Self { self } + fn items(&self) -> &Self { self } + fn get(&self, _: u32) -> &Facts { &self.facts } + fn is_air(&self, state: u32) -> bool { state == 0 } + fn mining_speed(&self, _: Option<&()>, _: &str) -> f32 { self.speed } + fn correct_for_drops(&self, _: Option<&()>, _: &str) -> bool { true } +} +#[derive(Default)] +struct World { broken: Vec<[i32; 3]> } +impl World { + fn block(&self, x: i32, y: i32, z: i32) -> u32 { + u32::from(!self.broken.contains(&[x, y, z])) + } +} +struct Audio; +impl Audio { + fn play(&self, _: &str, _: Option<[f64; 3]>, _: f32, _: f32) {} +} +mod play { + #[derive(Debug, PartialEq)] + pub struct PlayerAction { + pub action: u8, pub pos: [i32; 3], pub direction: u8, pub sequence: i32, + } +} +enum S { PlayerAction(play::PlayerAction) } +fn face_direction(face: u8) -> u8 { face } +struct Game { + remote: Option, mining: Option, creative: bool, + world: World, res: Resources, player: Option, audio: Audio, + hit: Hit, sequence: i32, packets: Vec, +} +impl Game { + fn new(hardness: f32, speed: f32, creative: bool) -> Self { + Self { + remote: Some(Remote::default()), mining: None, creative, + world: World::default(), + res: Resources { facts: Facts { hardness, name: "block".into(), + requires_tool: false, sounds: Sounds { hit: "hit".into(), volume: 1.0, pitch: 1.0 } }, speed }, + player: Some(Player { ground: Ground { on_ground: true } }), audio: Audio, + hit: Hit { pos: [0, 64, 0], face: 1 }, sequence: 0, packets: vec![], + } + } + fn pick(&self) -> Option { Some(self.hit) } + fn held(&self) -> Option<&()> { None } + fn next_sequence(&mut self) -> i32 { self.sequence += 1; self.sequence } + fn predict_break(&mut self, pos: [i32; 3], _: u32, _: i32) { self.world.broken.push(pos); } + fn send(&mut self, S::PlayerAction(packet): S) { self.packets.push(packet); } + fn crack_particle(&mut self, _: [i32; 3], _: u8, _: u32) {} +METHOD +} +fn main() { + // Zero-hardness blocks and a tool fast enough to break in one tick. + for (hardness, speed) in [(0.0, 1.0), (0.5, 15.0), (0.5, 30.0)] { + let mut game = Game::new(hardness, speed, false); + for tick in 0..8 { + game.hit.pos[0] = tick; + game.remote_mining(tick == 0); + assert_eq!(game.world.broken.len(), tick as usize + 1, + "instant break must happen every held tick"); + let remote = game.remote.as_ref().unwrap(); + assert_eq!(remote.destroy_delay, 0); + assert!(remote.destroying.is_none()); + assert!(game.mining.is_none()); + assert_eq!(game.packets[tick as usize], play::PlayerAction { + action: 0, pos: [tick, 64, 0], direction: 1, sequence: tick + 1, + }); + } + assert_eq!(game.packets.len(), 8, "instant breaks only send START"); + } + // Gradual breaking still sends STOP and waits five continuation ticks. + let mut game = Game::new(1.0, 15.0, false); + game.remote_mining(true); + assert!(game.world.broken.is_empty()); + game.remote_mining(false); + assert!(game.world.broken.is_empty()); + game.remote_mining(false); + assert_eq!(game.world.broken.len(), 1); + assert_eq!(game.packets.iter().map(|p| p.action).collect::>(), [0, 3]); + assert_eq!(game.remote.as_ref().unwrap().destroy_delay, 5); + game.hit.pos[0] = 1; + for _ in 0..5 { + game.remote_mining(false); + assert_eq!(game.packets.len(), 2); + } + game.remote_mining(false); + assert_eq!(game.packets.len(), 3); + assert_eq!(game.packets[2].action, 0); + // Creative also keeps its five-tick delay, even for zero-hardness blocks. + let mut game = Game::new(0.0, 1.0, true); + game.remote_mining(true); + game.hit.pos[0] = 1; + assert_eq!(game.remote.as_ref().unwrap().destroy_delay, 5); + for _ in 0..5 { + game.remote_mining(false); + assert_eq!(game.world.broken.len(), 1); + } + game.remote_mining(false); + assert_eq!(game.world.broken.len(), 2); + assert_eq!(game.remote.as_ref().unwrap().destroy_delay, 5); +} +'''.replace("METHOD", source[start:end]) + with tempfile.TemporaryDirectory(prefix="remote-mining-") as directory: + path = Path(directory) + (path / "main.rs").write_text(fixture) + subprocess.run(["rustc", "--edition=2024", str(path / "main.rs"), "-o", str(path / "probe")], + check=True, capture_output=True, text=True) + result = subprocess.run([str(path / "probe")], capture_output=True, text=True) + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/test_first_person_parity.py b/tools/test_first_person_parity.py index d73262595..476d2cc52 100644 --- a/tools/test_first_person_parity.py +++ b/tools/test_first_person_parity.py @@ -69,6 +69,12 @@ def block_hit(pos, face=1): def scenarios(): stone = {TARGETS[0]: 'minecraft:stone', TARGETS[1]: 'minecraft:dirt', TARGETS[2]: 'minecraft:glass'} + # Consecutive instant survival breaks have no destroy delay. Cover both + # zero hardness and a shovel with haste reaching one-tick destroy progress. + for block, main, haste in [('minecraft:short_grass', None, None), + ('minecraft:dirt', ['minecraft:diamond_shovel', 1], 9)]: + steps = [step(block_hit(p), ac=int(i == 0), ad=True) for i, p in enumerate(TARGETS)] + yield case(steps + [step()] * 6, main=main, blocks={p: block for p in TARGETS}, haste=haste) for creative in (False, True): for main in ITEMS: # Hold attack on blocks until they break, then on the air behind. From 6d36d468e70d0aea524e61f32081879ea064fa3b Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:29:55 +0100 Subject: [PATCH 49/59] Fix empty-hand drop animations --- .../examples/held_drop_fixture.rs | 11 +++++- crates/horizon-client/src/game/remote.rs | 23 ++++++----- .../parity/VanillaHeldDropOracle.java | 39 +++++++++++++++++-- tools/test_held_drop_parity.py | 10 +++-- 4 files changed, 65 insertions(+), 18 deletions(-) diff --git a/crates/horizon-client/examples/held_drop_fixture.rs b/crates/horizon-client/examples/held_drop_fixture.rs index 87ca9870c..a0c5d92ba 100644 --- a/crates/horizon-client/examples/held_drop_fixture.rs +++ b/crates/horizon-client/examples/held_drop_fixture.rs @@ -14,13 +14,22 @@ fn main() { for count in [0, 1, 4, 64] { let mut slot = Some(ItemStack::new("minecraft:stone", count)); let mut dropped = 0; + let mut swings = 0; + let mut packets = 0; for _ in 0..2 { if let Some(stack) = take_held_drop(&mut slot, all, mode == GameMode::Spectator) { dropped += stack.count; + swings += 1; } - println!("{} {}", slot.as_ref().map_or(0, |s| s.count), dropped); + if mode != GameMode::Spectator { + packets += 1; + } + println!( + "{} {dropped} {swings} {packets}", + slot.as_ref().map_or(0, |s| s.count), + ); } } } diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..6614c68a3 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -7,7 +7,7 @@ //! client predicts its own movement; the server stays authoritative for //! everything else. use super::{Dim, Game, Mining, Screen}; -use horizon_client::first_person::Hand; +use horizon_client::first_person::{Hand, SwingAnimation}; use horizon_client::{ Result, chunk::{BIOME_STRATEGY, Chunk, Light, MIN_Y, SECTIONS, Section, block_strategy}, @@ -3836,23 +3836,26 @@ impl Game<'_> { Ok(true) } KeyCode::KeyQ => { + if self.spectator() { + return Ok(true); + } let all = self.keys.contains(&KeyCode::ControlLeft); + // MultiPlayerGameMode.dropItem: predict removal before sending + // the action, then swing only if a nonempty stack was removed. + let dropped = horizon_client::items::take_held_drop( + &mut self.inventory[self.selected], + all, + false, + ); self.send(S::PlayerAction(play::PlayerAction { action: if all { 4 } else { 5 }, pos: [0; 3], direction: 0, sequence: 0, })); - // Inventory.removeFromSelected (prediction). - let slot = &mut self.inventory[self.selected]; - if let Some(s) = slot { - if all || s.count <= 1 { - *slot = None; - } else { - s.count -= 1; - } + if dropped.is_some() { + self.swing_hand(Hand::Main, SwingAnimation::DEFAULT); } - self.swing_arm(); Ok(true) } KeyCode::KeyE => { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeldDropOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeldDropOracle.java index 8034968a5..b2cdb3383 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeldDropOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeldDropOracle.java @@ -6,9 +6,14 @@ import java.io.PrintWriter; import net.minecraft.client.*; import net.minecraft.client.gui.Gui; import net.minecraft.client.multiplayer.MultiPlayerGameMode; +import net.minecraft.client.multiplayer.ClientPacketListener; import net.minecraft.client.player.LocalPlayer; +import net.minecraft.network.protocol.Packet; +import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket; +import net.minecraft.world.InteractionHand; import net.minecraft.world.entity.player.*; import net.minecraft.world.item.*; +import net.minecraft.world.item.component.SwingAnimation; import net.minecraft.world.level.GameType; /** Runs the real key handler through its drop loop; stops before item-use handling. */ @@ -41,16 +46,36 @@ public final class VanillaHeldDropOracle { } static final class Actor extends LocalPlayer { GameType mode; + int swings; Actor() { super(null, null, null, null, null, null, false, null, null); } @Override public GameType gameMode() { return mode; } @Override public boolean isUsingItem() { throw new Done(); } + @Override public boolean swing(InteractionHand hand, SwingAnimation animation, boolean sendPacket) { + if (hand != InteractionHand.MAIN_HAND || !animation.equals(SwingAnimation.DEFAULT) || sendPacket) + throw new AssertionError("unexpected drop swing"); + swings++; + return true; + } + } + static final class Connection extends ClientPacketListener { + int drops; + ServerboundPlayerActionPacket.Action expected; + Connection() { super(null, null, null); } + @Override public void send(Packet packet) { + if (packet instanceof ServerboundPlayerActionPacket action) { + if (action.getAction() != expected) throw new AssertionError("unexpected drop action"); + drops++; + } + } } static final class Controller extends MultiPlayerGameMode { int dropped; Controller() { super(null, null); } - // Controlled dispatch boundary: no networking, swings, statistics or item entities. + // Run vanilla's actual prediction, packet dispatch and conditional swing. @Override public void dropItem(LocalPlayer player, boolean all) { - dropped += player.getInventory().removeFromSelected(all).getCount(); + int before = player.getInventory().getSelectedItem().getCount(); + super.dropItem(player, all); + dropped += before - player.getInventory().getSelectedItem().getCount(); } } public static void main(String[] args) throws Exception { @@ -81,6 +106,9 @@ public final class VanillaHeldDropOracle { field(Player.class, "inventory").set(actor, inventory); field(Minecraft.class, "player").set(client, actor); var controller = make(Controller.class); + var connection = make(Connection.class); + field(MultiPlayerGameMode.class, "minecraft").set(controller, client); + field(MultiPlayerGameMode.class, "connection").set(controller, connection); field(Minecraft.class, "gameMode").set(client, controller); try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[0])))) { for (var mode : GameType.values()) for (boolean all : new boolean[]{false, true}) { @@ -91,6 +119,10 @@ public final class VanillaHeldDropOracle { inventory.setSelectedSlot(selected); inventory.setItem(selected, new ItemStack(Items.STONE, count)); controller.dropped = 0; + actor.swings = 0; + connection.drops = 0; + connection.expected = all ? ServerboundPlayerActionPacket.Action.DROP_ALL_ITEMS + : ServerboundPlayerActionPacket.Action.DROP_ITEM; // Two consecutive key presses also cover an emptied stack and repeated spectator drops. for (int press = 0; press < 2; press++) { ((Key) options.keyDrop).clicks = 1; @@ -100,7 +132,8 @@ public final class VanillaHeldDropOracle { } catch (InvocationTargetException e) { if (!(e.getCause() instanceof Done)) throw e; } - out.println(inventory.getSelectedItem().getCount() + " " + controller.dropped); + out.println(inventory.getSelectedItem().getCount() + " " + controller.dropped + + " " + actor.swings + " " + connection.drops); } } } diff --git a/tools/test_held_drop_parity.py b/tools/test_held_drop_parity.py index c546c5987..842ad3d8a 100644 --- a/tools/test_held_drop_parity.py +++ b/tools/test_held_drop_parity.py @@ -2,10 +2,12 @@ """Compare selected-slot drops with Minecraft.handleKeybinds in all four game modes. The oracle invokes the unmodified native key handler, consuming real drop-key -clicks. Its controlled dropItem callback removes from the real player Inventory; -other keys are idle and execution stops at the following item-use boundary. +clicks, and MultiPlayerGameMode.dropItem's real prediction and swing dispatch. +Other keys are idle and execution stops at the following item-use boundary. Checks Q/Ctrl+Q, slots 0/8, empty/single/partial/full stacks and repeated drops. -Packet delivery, item entities, swing animation and statistics are outside scope. +Checks swing attempts and drop packet counts, including packets without swings +for empty slots. Packet delivery, animation ticks, item entities and statistics +are outside scope. """ import os import subprocess @@ -35,7 +37,7 @@ def main(): subprocess.run(['cargo', 'run', '--quiet', '-p', 'horizon-client', '--example', 'held_drop_fixture'], cwd=lab.ROOT, stdout=out, check=True) matched = base.compare(build / 'vanilla.txt', build / 'rust.txt') - print(f'Held drop parity passed: {matched} selected-stack/drop-count snapshots match vanilla') + print(f'Held drop parity passed: {matched} inventory/drop/swing/packet snapshots match vanilla') if __name__ == '__main__': From 6e83037fca77eeb7884ceec25292c806efc48937 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 18:32:54 +0200 Subject: [PATCH 50/59] end sky test: as_chunks instead of chunks_exact (clippy 1.99) Rust 1.99's clippy denies chunks_exact with a constant size (chunks_exact_to_as_chunks), so `cargo clippy --all-targets -D warnings` failed on this test. Same check, written as as_chunks::<4>(). Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx/end_sky/tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/gfx/end_sky/tests.rs b/crates/horizon-client/src/gfx/end_sky/tests.rs index d01fca18c..61266003d 100644 --- a/crates/horizon-client/src/gfx/end_sky/tests.rs +++ b/crates/horizon-client/src/gfx/end_sky/tests.rs @@ -314,7 +314,7 @@ fn separate_draws_match_combined_celestial_pixels() { visible_flash_cases += usize::from(expected != no_flash); assert_eq!(actual, expected, "yaw={yaw} pitch={pitch} flash={level}"); assert!( - actual.chunks_exact(4).any(|p| p[..3] != [0; 3]), + actual.as_chunks::<4>().0.iter().any(|p| p[..3] != [0; 3]), "empty frame" ); assert_eq!(resident.mesh.as_ref().unwrap().1, first); From 15b85145845f2c500dcee979d1401217093426b6 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:37:23 +0100 Subject: [PATCH 51/59] Fix registry-backed slash command suggestions on connected clients --- crates/horizon-client/src/game/remote.rs | 5 +++ tools/agent_control_e2e.py | 45 ++++++++++++++++++++++-- tools/test_chat_screen_parity.py | 10 ++++++ 3 files changed, 58 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..020746d68 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -306,6 +306,11 @@ impl Game<'_> { progress: 0.0, total: 0, }; + // The connected client never opens a server world (single player also + // joins here), so load the registries its argument parsers and local + // suggestions need before receiving the server's command tree. + self.ui.registries = Default::default(); + self.build_registries(); self.ui.registries.permission = 0; self.ui.chat.clear(); self.screen = Screen::Playing; diff --git a/tools/agent_control_e2e.py b/tools/agent_control_e2e.py index 977d2e292..962d04575 100644 --- a/tools/agent_control_e2e.py +++ b/tools/agent_control_e2e.py @@ -10,7 +10,8 @@ the options scenario reads and sets options.txt values by key; the events scenar states (wait-for) and reads the event log; the consume scenario eats and drinks consumables (a golden apple, milk, honey, chorus fruit) and checks their effects, remainders and teleport; the pick scenario middle-clicks slots (AbstractContainerScreen's cloning): a full stack in creative, from -the hotbar and from an item tab, and nothing in survival. +the hotbar and from an item tab, and nothing in survival; the suggestions scenario checks +slash-command Tab completion on single player's connected client after a fresh launch. python3 tools/agent_control_e2e.py # both modes python3 tools/agent_control_e2e.py --mode mcp # one of them @@ -45,6 +46,7 @@ LOG_KINDS = ['oak_log', 'birch_log', 'spruce_log', 'jungle_log', 'acacia_log', ' 'mangrove_log', 'cherry_log'] # Positional arguments of the commands the scenario uses, for the CLI. POSITIONAL = { + 'key': ['key', 'action'], 'goto': ['x', 'y', 'z'], 'break': ['x', 'y', 'z'], 'place': ['x', 'y', 'z'], 'block': ['x', 'y', 'z'], 'find_block': ['block', 'radius'], 'entities': ['radius', 'type'], 'click_slot': ['slot'], 'click_button': ['label'], 'type': ['text'], 'wait': ['ticks'], 'wait_ready': ['seconds'], @@ -522,8 +524,47 @@ def pick_scenario(d, out): return {'cloned': shown['item']} +def suggestions_scenario(d, out): + # Start from the title screen: single player's client joins through memory, + # without opening a server world and building its command registries. + d('click', id='singleplayer') + if 'game' not in widgets(d): + d('click', id='create-new-world') + d('type', field='name', replace=True, text='Suggestions') + d('click', id='game-mode') # survival -> hardcore -> creative (commands on) + d('click', id='game-mode') + d('click', id='create-new-world') + d('wait_for', condition='loaded', timeout=400) + d('wait_ready', seconds=400) + + cases = [ + ('/giv', '/give'), + ('/fill ^', '/fill ^ ^'), + ('/give @s diamond_sw', '/give @s minecraft:diamond_sword'), + ('/setblock ~ ~ ~ sto', '/setblock ~ ~ ~ minecraft:stone'), + ('/fill ~ ~ ~ ~1 ~1 ~1 sto', '/fill ~ ~ ~ ~1 ~1 ~1 minecraft:stone'), + ('/setblock ~ ~ ~ oak_stairs[fa', '/setblock ~ ~ ~ oak_stairs[facing='), + ('/clear @s diamond_sw', '/clear @s minecraft:diamond_sword'), + ('/execute run give @s diamond_sw', '/execute run give @s minecraft:diamond_sword'), + ] + for text, expected in cases: + d('key', key='t', action='tap') + d('type', text=text) + if text == '/give @s diamond_sw': + shot = d('screenshot', path=str((out / f'{d.name}-suggestions.png').resolve())) + if '_image' in shot: + (out / f'{d.name}-suggestions.png').write_bytes(shot['_image']) + d('key', key='tab', action='tap') + actual = d('screen')['chat_input'] + assert actual == expected, (text, expected, actual) + d('key', key='esc', action='tap') + if d('screen')['screen'] == 'chat': # Escape first dismisses suggestions + d('key', key='esc', action='tap') + return {'completions': len(cases)} + + SCENARIOS = {'survival': scenario, 'ui': ui_scenario, 'options': options_scenario, 'events': events_scenario, - 'consume': consume_scenario, 'pick': pick_scenario} + 'consume': consume_scenario, 'pick': pick_scenario, 'suggestions': suggestions_scenario} def run(mode, ctl, out, resources, which='survival'): diff --git a/tools/test_chat_screen_parity.py b/tools/test_chat_screen_parity.py index 52febd9f6..1447ebaa6 100644 --- a/tools/test_chat_screen_parity.py +++ b/tools/test_chat_screen_parity.py @@ -69,6 +69,16 @@ def cases(count): 'history': rng.sample(HISTORY, rng.randint(0, len(HISTORY))), 'autoSuggest': rng.random() < 0.85, 'chatOnly': rng.random() < 0.7, 'opacity': rng.choice([0.0, 0.5, 1.0]), 'actions': actions, 'mouse': list(mouse), 'blink': rng.choice([0, 100, 400, 650])}) + # Always exercise registry-backed suggestions and their replacement ranges, + # before and after Tab, including the redirect through execute's root. + for text in ['/give @s diamond_sw', '/setblock ~ ~ ~ sto', '/fill ~ ~ ~ ~1 ~1 ~1 sto', + '/setblock ~ ~ ~ oak_stairs[fa', '/clear @s diamond_sw', + '/execute run give @s diamond_sw', '/fill ']: + for keys in [[], ['tab'], ['tab', 'tab', 'shift+tab']]: + out.append({'width': 640, 'height': 360, 'initial': '', 'history': [], 'autoSuggest': True, + 'chatOnly': True, 'opacity': 0.5, 'mouse': [0, 0], 'blink': 0, + 'actions': [{'type': 'type', 'text': text}] + + [{'type': 'key', 'key': key} for key in keys]}) return out From ecbb0368c551b060fb6c13766552062c9508d487 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:37:42 +0100 Subject: [PATCH 52/59] Fix hand swing prediction for rejected block placements --- crates/horizon-client/src/game/remote.rs | 220 ++++++++++++++++-- .../examples/level_place_fixture.rs | 5 + .../parity/VanillaBlockPlacementOracle.java | 6 +- tools/test_level_place_parity.py | 18 +- 4 files changed, 222 insertions(+), 27 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..f6404223e 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3489,7 +3489,15 @@ impl Game<'_> { self.predict_use(&changes, seq); } if held_block { - self.with_hand(hand, Game::swing_arm); + if reacts + || held + .as_ref() + .is_some_and(|stack| self.remote_can_place(&hit, stack)) + { + self.with_hand(hand, Game::swing_arm); + } + // BlockItem.place returns FAIL when placement is rejected: + // stop this click without trying the item or the other hand. return true; } return reacts; @@ -3547,7 +3555,11 @@ impl Game<'_> { /// container, and the blocks it changed. Vanilla's client runs it on its /// own level first; this runs it on a copy, and `predict_use` keeps the /// changes it predicts. - fn remote_block_reacts(&self, hit: &super::Hit, held: Option<&ItemStack>) -> (bool, DryUse) { + fn remote_block_reacts( + &mut self, + hit: &super::Hit, + held: Option<&ItemStack>, + ) -> (bool, DryUse) { // Player.isSecondaryUseActive with something in either hand. let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some(); if self.keys.contains(&KeyCode::ShiftLeft) && hands_full { @@ -3562,26 +3574,53 @@ impl Game<'_> { [-1, 0, 0] => Direction::West, _ => Direction::East, }; - let mut level = DryLevel { - world: &self.world, - changed: HashMap::new(), - random: horizon_core::random::LegacyRandom::new(0), - sounds: Vec::new(), + let player = self.use_context(); + self.with_level(|b, level, _| { + let mut level = DryLevel::new(level); + let reacts = b + .use_item_on( + &mut level, + &mut horizon_world::level::Ticks::default(), + horizon_core::position::BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]), + face, + horizon_core::geometry::Vec3::new(hit.point[0], hit.point[1], hit.point[2]), + player, + held.map(|s| &*s.item), + ) + .consumes_action(); + (reacts, (level.changed.into_iter().collect(), level.sounds)) + }) + } + + /// Run BlockItem.place on a disposable level before predicting its swing. + /// The real level supplies collision shapes and building-blocking entities; + /// block writes, random draws, scheduled ticks and events stay in the preview. + fn remote_can_place(&mut self, hit: &super::Hit, stack: &ItemStack) -> bool { + if !self.may_build() { + return false; + } + let ctx = horizon_world::level::PlaceContext { + clicked_pos: horizon_core::position::BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]), + face: horizon_core::geometry::Direction::ALL[face_direction(hit.face) as usize], + hit: Vec3::new(hit.point[0], hit.point[1], hit.point[2]), + inside: hit.face == [0; 3], + yaw: self.yaw, + pitch: self.pitch, + sneaking: self.keys.contains(&KeyCode::ShiftLeft), + item: stack.item.to_string(), + can_use_game_master_blocks: self.can_use_game_master_blocks(), }; - let reacts = self - .res - .behaviours() - .use_item_on( - &mut level, - &mut horizon_world::level::Ticks::default(), - horizon_core::position::BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]), - face, - horizon_core::geometry::Vec3::new(hit.point[0], hit.point[1], hit.point[2]), - self.use_context(), - held.map(|s| &*s.item), + self.with_level(|b, level, _| { + let mut level = DryLevel::new(level); + matches!( + b.place_block( + &mut level, + &mut horizon_world::level::Ticks::default(), + &ctx + ), + horizon_world::level::PlaceOutcome::Placed { .. } ) - .consumes_action(); - (reacts, (level.changed.into_iter().collect(), level.sounds)) + }) } /// MultiPlayerGameMode.useItem for `hand`, if it holds something: whether @@ -4529,7 +4568,7 @@ pub(super) fn input_ordinal(input: Input) -> i32 { /// The client's world for a guess at what a click does: reads go to the /// world, writes stay here and are dropped. struct DryLevel<'w> { - world: &'w horizon_client::world::World, + base: &'w dyn horizon_world::level::LevelAccess, changed: HashMap, random: horizon_core::random::LegacyRandom, /// The sounds the use plays (a door's creak). @@ -4559,6 +4598,17 @@ pub(super) fn hand_operated(name: &str) -> bool { || name == "lever" } +impl<'w> DryLevel<'w> { + fn new(base: &'w dyn horizon_world::level::LevelAccess) -> Self { + Self { + base, + changed: HashMap::new(), + random: horizon_core::random::LegacyRandom::new(0), + sounds: Vec::new(), + } + } +} + impl horizon_world::level::LevelAccess for DryLevel<'_> { fn emit(&mut self, event: horizon_world::level::LevelEvent) { if let horizon_world::level::LevelEvent::Sound { @@ -4575,7 +4625,7 @@ impl horizon_world::level::LevelAccess for DryLevel<'_> { self.changed .get(&pos) .copied() - .unwrap_or_else(|| self.world.block(pos.x, pos.y, pos.z)) + .unwrap_or_else(|| self.base.block_state(pos)) } fn set_raw( &mut self, @@ -4587,13 +4637,31 @@ impl horizon_world::level::LevelAccess for DryLevel<'_> { Some(previous) } fn is_loaded(&self, pos: horizon_core::position::BlockPos) -> bool { - self.world.loaded(pos.x, pos.z) + self.base.is_loaded(pos) + } + fn min_y(&self) -> i32 { + self.base.min_y() + } + fn max_y(&self) -> i32 { + self.base.max_y() + } + fn block_light(&self, pos: horizon_core::position::BlockPos) -> i32 { + self.base.block_light(pos) + } + fn sky_light(&self, pos: horizon_core::position::BlockPos) -> i32 { + self.base.sky_light(pos) + } + fn sky_darken(&self) -> i32 { + self.base.sky_darken() + } + fn is_unobstructed(&self, pos: horizon_core::position::BlockPos, state: BlockStateId) -> bool { + self.base.is_unobstructed(pos, state) } fn random(&mut self) -> &mut horizon_core::random::LegacyRandom { &mut self.random } fn game_time(&self) -> i64 { - self.world.game_time + self.base.game_time() } } @@ -4709,6 +4777,110 @@ impl horizon_client::interaction_input::InteractionWorld for RemoteInputWorld<'_ mod tests { use super::Game; + #[test] + fn placement_preview_checks_obstruction_without_changing_the_level() { + use super::DryLevel; + use horizon_core::{position::BlockPos, random::LegacyRandom}; + use horizon_world::{ + level::{ + Behaviours, LevelAccess, PlaceContext, PlaceOutcome, Ticks, data::load_registry, + }, + registry::BlockStateId, + }; + + struct Level { + air: BlockStateId, + stone: BlockStateId, + obstructed: bool, + loaded: bool, + ceiling: i32, + } + impl LevelAccess for Level { + fn block_state(&self, pos: BlockPos) -> BlockStateId { + if pos == BlockPos::new(0, 0, 0) { + self.stone + } else { + self.air + } + } + fn set_raw(&mut self, _: BlockPos, _: BlockStateId) -> Option { + panic!("preview must not write to the live level"); + } + fn is_loaded(&self, _: BlockPos) -> bool { + self.loaded + } + fn max_y(&self) -> i32 { + self.ceiling + } + fn is_unobstructed(&self, pos: BlockPos, _: BlockStateId) -> bool { + assert_eq!(pos, BlockPos::new(0, 1, 0)); + !self.obstructed + } + fn random(&mut self) -> &mut LegacyRandom { + panic!("preview must not advance the live level's random source"); + } + fn game_time(&self) -> i64 { + 0 + } + } + + // As with the LAN tests, prepared game resources are optional locally. + let resources = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !resources.join("block-behaviours.json").exists() { + return; + } + let registry = load_registry(&resources).unwrap(); + let behaviours = Behaviours::load(®istry, &resources).unwrap(); + let mut base = Level { + air: registry.default_state("minecraft:air").unwrap(), + stone: registry.default_state("minecraft:stone").unwrap(), + obstructed: false, + loaded: true, + ceiling: 320, + }; + for item in [ + "minecraft:stone", + "minecraft:oak_slab", + "minecraft:oak_door", + // GrowingPlantHeadBlock.getStateForPlacement draws a random age. + "minecraft:twisting_vines", + ] { + let ctx = PlaceContext { + clicked_pos: BlockPos::new(0, 0, 0), + face: horizon_core::geometry::Direction::Up, + hit: horizon_core::geometry::Vec3::new(0.5, 1.0, 0.5), + inside: false, + yaw: 0.0, + pitch: 45.0, + sneaking: false, + item: item.into(), + can_use_game_master_blocks: false, + }; + for (obstructed, loaded, ceiling) in [ + (false, true, 320), + (true, true, 320), + (false, false, 320), + (false, true, 1), + ] { + base.obstructed = obstructed; + base.loaded = loaded; + base.ceiling = ceiling; + let valid = !obstructed && loaded && ceiling > 1; + let mut preview = DryLevel::new(&base); + let outcome = behaviours.place_block(&mut preview, &mut Ticks::default(), &ctx); + assert_eq!( + matches!(outcome, PlaceOutcome::Placed { .. }), + valid, + "{item}, obstructed={obstructed}, loaded={loaded}, ceiling={ceiling}" + ); + assert_eq!(preview.changed.is_empty(), !valid); + assert_eq!(base.block_state(BlockPos::new(0, 1, 0)), base.air); + } + } + } + #[test] fn every_inventory_menu_slot_is_a_game_slot_and_45_is_the_off_hand() { // InventoryMenu: result, 2x2 grid, armour, 27 + 9 inventory slots, then the off hand. diff --git a/crates/horizon-world/examples/level_place_fixture.rs b/crates/horizon-world/examples/level_place_fixture.rs index a8f00edd1..13595726d 100644 --- a/crates/horizon-world/examples/level_place_fixture.rs +++ b/crates/horizon-world/examples/level_place_fixture.rs @@ -20,6 +20,7 @@ struct Cells { cells: HashMap, air: BlockStateId, random: LegacyRandom, + obstructed: bool, } impl LevelAccess for Cells { fn block_state(&self, pos: BlockPos) -> BlockStateId { @@ -37,6 +38,9 @@ impl LevelAccess for Cells { fn game_time(&self) -> i64 { 0 } + fn is_unobstructed(&self, _pos: BlockPos, _state: BlockStateId) -> bool { + !self.obstructed + } } fn main() -> Result<(), Box> { @@ -68,6 +72,7 @@ fn main() -> Result<(), Box> { cells, air, random: LegacyRandom::new(case["seed"].as_i64().unwrap()), + obstructed: case["obstructed"].as_bool().unwrap_or(false), }; let mut ticks = Ticks::new(0); for x in -2..=2 { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaBlockPlacementOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaBlockPlacementOracle.java index 0757bc2ef..e204d3cc0 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaBlockPlacementOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaBlockPlacementOracle.java @@ -27,7 +27,7 @@ import net.minecraft.world.phys.shapes.CollisionContext; /** * Native BlockItem placement-state selection (BlockPlaceContext resolution, * updatePlacementContext and getPlacementState) over generated neighbourhoods. - * Entities never obstruct; nothing is written to the world. + * Entity obstruction can be scripted; nothing is written to the world. */ public final class VanillaBlockPlacementOracle { static Object unsafe; @@ -67,6 +67,7 @@ public final class VanillaBlockPlacementOracle { static final class World extends net.minecraft.server.level.ServerLevel { Map cells; RandomSource random; + boolean obstructed; World() { super(null, null, null, null, null, null, false, 0L, List.of(), false); } @@ -77,7 +78,7 @@ public final class VanillaBlockPlacementOracle { @Override public RandomSource getRandom() { return random; } @Override public int getMinY() { return -64; } @Override public int getHeight() { return 384; } - @Override public boolean isUnobstructed(BlockState state, BlockPos pos, CollisionContext context) { return true; } + @Override public boolean isUnobstructed(BlockState state, BlockPos pos, CollisionContext context) { return !obstructed; } @Override public boolean isUnobstructed(Entity entity) { return true; } @Override public void scheduleTick(BlockPos pos, Block block, int delay) { } @Override public net.minecraft.core.RegistryAccess registryAccess() { return RegistryAccess.fromRegistryOfRegistries(BuiltInRegistries.REGISTRY); } @@ -116,6 +117,7 @@ public final class VanillaBlockPlacementOracle { world.cells.put(new BlockPos(c.get(0).getAsInt(), c.get(1).getAsInt(), c.get(2).getAsInt()), Block.stateById(c.get(3).getAsInt())); } world.random = new LegacyRandomSource(f.get("seed").getAsLong()); + world.obstructed = f.has("obstructed") && f.get("obstructed").getAsBoolean(); var player = make(FakePlayer.class); player.world = world; player.yaw = f.get("yaw").getAsFloat(); diff --git a/tools/test_level_place_parity.py b/tools/test_level_place_parity.py index 423951942..23a68800c 100644 --- a/tools/test_level_place_parity.py +++ b/tools/test_level_place_parity.py @@ -68,6 +68,22 @@ def generate(resources, count, seed): return cases +def obstruction_cases(resources): + """Placement failures must not predict a hand swing. + + Exercise BlockItem.canPlace's entity-obstruction gate with the same + otherwise valid placements, including partial shapes and two-block items. + """ + facts = json.loads((resources / 'facts.json').read_text()) + states = {s[0]: i for i, s in reversed(list(enumerate(facts['states'])))} + stone = states['minecraft:stone'] + for item in ['minecraft:stone', 'minecraft:oak_slab', 'minecraft:oak_stairs', + 'minecraft:oak_door', 'minecraft:torch']: + for obstructed in [False, True]: + yield dict(seed=0, item=item, pos=[0, 0, 0], face=1, hit=[0.5, 1.0, 0.5], + yaw=0, pitch=45, sneak=False, cells=[[0, 0, 0, stone]], obstructed=obstructed) + + def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--count', type=int, default=20000) @@ -77,7 +93,7 @@ def main(): resources = lab.LOCAL / 'horizon-client' / lock['minecraft']['version'] work = lab.LOCAL / 'level-place-parity' work.mkdir(parents=True, exist_ok=True) - cases = generate(resources, args.count, args.seed) + cases = list(obstruction_cases(resources)) + generate(resources, args.count, args.seed) (work / 'cases.jsonl').write_text(''.join(json.dumps(case) + '\n' for case in cases)) classes = work / 'classes' classes.mkdir(exist_ok=True) From e7d42dc9d077e93f1546732c803a427ab0ea3043 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:41:17 +0100 Subject: [PATCH 53/59] Fix in-world menu background blur --- crates/horizon-client/src/game.rs | 13 +++-- crates/horizon-client/src/game/screens.rs | 47 ++++++++++++++++- crates/horizon-client/src/gfx.rs | 19 +++++-- crates/horizon-client/src/hud.rs | 62 ++++++++++++++++++++++- 4 files changed, 130 insertions(+), 11 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..be7010c61 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4838,6 +4838,9 @@ impl Game<'_> { self.draw_chat(&mut batch); self.draw_tab_list(&mut batch); } + // Screen.extractBlurredBackground blurs the world and HUD, while the + // screen's background, widgets, toasts and debug overlay stay sharp. + batch.blur_at = batch.vertices.len() as u32; match self.screen { Screen::Paused if self.pause_menu => self.draw_pause_menu(&mut batch), // PauseScreen(false): only its title, at the top. @@ -10007,9 +10010,8 @@ impl Game<'_> { }; level_loading::draw(batch, atlas, Some(&status), Some(self.loading_progress)); } - /// `Screen.extractBlurredBackground` over the panorama: every classic - /// screen of the title menus but the title itself (`TitleScreen` - /// doesn't blur), when `menuBackgroundBlurriness` is at least 1. + /// `Screen.extractBlurredBackground` over the panorama or the world and + /// HUD, when `menuBackgroundBlurriness` is at least 1. fn menu_blur(&self) -> Option { let loading = self.loading_reason() == Some(horizon_client::level_loading::Reason::Other); let blurred = !horizon_client::ui_theme::horizon() @@ -10017,7 +10019,10 @@ impl Game<'_> { || self.title.as_ref().is_some_and(|t| { self.screen == Screen::Options || !matches!(t.mode, horizon_client::title::Mode::Main) - })); + }) + || (self.title.is_none() + && self.player.is_some() + && self.screen.blurs_background(self.pause_menu))); let radius = self.settings.menu_blur as f32; (blurred && radius >= 1.0).then_some(radius) } diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index cecd8d46f..07eacfb49 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -7,6 +7,24 @@ use horizon_client::{ ui, }; +impl Screen { + /// Screen.extractBackground for non-isInGameUi screens, and + /// PauseScreen.extractBackground only when showPauseMenu is true. + pub(super) fn blurs_background(self, pause_menu: bool) -> bool { + match self { + Self::Paused => pause_menu, + Self::Options | Self::Stats | Self::Advancements | Self::WorldOptions => true, + Self::Playing + | Self::GameModeSwitcher + | Self::Chat + | Self::Creative + | Self::Inventory + | Self::Dead + | Self::CommandBlock => false, + } + } +} + /// PauseScreen buttons: (x, y, width, label key, action id, active). /// https://mcsrc.dev/2/26.3/net/minecraft/client/gui/screens/PauseScreen fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static str, u8, bool)> { @@ -334,7 +352,34 @@ impl Game<'_> { #[cfg(test)] mod tests { - use super::pause_buttons; + use super::{Screen, pause_buttons}; + + #[test] + fn menu_blur_matches_vanilla_screen_backgrounds() { + for screen in [ + Screen::Options, + Screen::Stats, + Screen::Advancements, + Screen::WorldOptions, + ] { + assert!(screen.blurs_background(false)); + assert!(screen.blurs_background(true)); + } + assert!(Screen::Paused.blurs_background(true)); + assert!(!Screen::Paused.blurs_background(false)); + for screen in [ + Screen::Playing, + Screen::GameModeSwitcher, + Screen::Chat, + Screen::Creative, + Screen::Inventory, + Screen::Dead, + Screen::CommandBlock, + ] { + assert!(!screen.blurs_background(true)); + assert!(!screen.blurs_background(false)); + } + } #[test] fn pause_menu_uses_disconnect_for_servers_and_keeps_world_options() { diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..3de07b17b 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -3841,9 +3841,19 @@ impl Renderer { let first = debug_depth + debug_top; pass.draw(0..4, first..first + crosshair); } - if let Some(radius) = frame.menu_blur - && self.config.usage.contains(wgpu::TextureUsages::COPY_SRC) - { + let menu_blur = frame + .menu_blur + .filter(|_| self.config.usage.contains(wgpu::TextureUsages::COPY_SRC)); + let blur_at = menu_blur.map_or(0, |_| frame.hud.blur_at); + self.hud.draw_range( + &mut encoder, + &view_target, + &self.depth, + frame.hud, + [self.config.width, self.config.height], + 0..blur_at, + ); + if let Some(radius) = menu_blur { let format = self.config.format; let device = &self.device; self.menu_blur @@ -3875,12 +3885,13 @@ impl Renderer { grade, ); } - self.hud.draw( + self.hud.draw_range( &mut encoder, &view_target, &self.depth, frame.hud, [self.config.width, self.config.height], + blur_at..frame.hud.vertices.len() as u32, ); if culling && let Some(cull) = &mut self.cull { cull.end(&self.device, &mut encoder); diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 0cc99b07b..0c3bde1d1 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -363,6 +363,8 @@ pub struct HudBatch { pub patches: Vec, /// Vertex ranges with another blend or depth/scissor state, in order. pub blends: Vec<(std::ops::Range, Blend)>, + /// Screen's first vertex: the preceding HUD is part of its blurred background. + pub blur_at: u32, } /// How a run of HUD vertices blends and tests depth. #[derive(Clone, Copy, PartialEq, Eq, Debug)] @@ -398,6 +400,7 @@ impl HudBatch { height: (window[1] as f32 / scale as f32).ceil(), patches: Vec::new(), blends: Vec::new(), + blur_at: 0, } } /// Draw the vertices added since `start` with the inverting blend. @@ -450,6 +453,14 @@ impl HudBatch { } out } + fn runs_in(&self, vertices: std::ops::Range) -> Vec<(std::ops::Range, Blend)> { + let mut runs = self.runs(); + for (range, _) in &mut runs { + *range = range.start.max(vertices.start)..range.end.min(vertices.end); + } + runs.retain(|(range, _)| !range.is_empty()); + runs + } /// `AbstractContainerScreen.init`: center in integer GUI coordinates. pub fn centered_origin(&self, width: f32, height: f32) -> (f32, f32) { ( @@ -1078,7 +1089,26 @@ impl HudRenderer { batch: &HudBatch, size: [u32; 2], ) { - if batch.vertices.is_empty() || size.contains(&0) { + self.draw_range( + encoder, + target, + depth, + batch, + size, + 0..batch.vertices.len() as u32, + ); + } + /// Draw part of the prepared batch, preserving its blend/depth runs. + pub fn draw_range( + &self, + encoder: &mut wgpu::CommandEncoder, + target: &wgpu::TextureView, + depth: &wgpu::TextureView, + batch: &HudBatch, + size: [u32; 2], + vertices: std::ops::Range, + ) { + if vertices.is_empty() || size.contains(&0) { return; } let attachments = [Some(wgpu::RenderPassColorAttachment { @@ -1090,7 +1120,7 @@ impl HudRenderer { store: wgpu::StoreOp::Store, }, })]; - let runs = batch.runs(); + let runs = batch.runs_in(vertices); let mut at = 0; while at < runs.len() { let clip = match runs[at].1 { @@ -1329,6 +1359,33 @@ mod tests { ] ); } + + #[test] + fn blur_boundary_splits_blend_runs_without_losing_or_repeating_vertices() { + let mut batch = HudBatch::new([854, 480]); + for _ in 0..5 { + batch.quad([[0.0; 2]; 4], [[0.0; 2]; 4], 0); + } + batch.blends = vec![ + (6..18, Blend::Invert), + (18..24, Blend::Depth([0, 0, 10, 10])), + ]; + for split in [0, 6, 12, 18, 24, 30] { + let before = batch.runs_in(0..split); + let after = batch.runs_in(split..30); + let actual: Vec<_> = before + .into_iter() + .chain(after) + .flat_map(|(range, blend)| range.map(move |v| (v, blend))) + .collect(); + let expected: Vec<_> = batch + .runs() + .into_iter() + .flat_map(|(range, blend)| range.map(move |v| (v, blend))) + .collect(); + assert_eq!(actual, expected, "blur at {split}"); + } + } #[test] fn container_origins_use_java_integer_division() { // Odd scaled dimensions, odd image sizes and an oversized panel. @@ -1340,6 +1397,7 @@ mod tests { height: height as f32, patches: Vec::new(), blends: Vec::new(), + blur_at: 0, }; for (image_width, image_height) in [(195, 136), (176, 166), (176, 222)] { assert_eq!( From d67779d5a17432e553a36013e5ba3970cb6f9a20 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:42:56 +0100 Subject: [PATCH 54/59] Make completion regression deterministic and include screenshots --- docs/media/command-suggestions/after.png | Bin 0 -> 282564 bytes docs/media/command-suggestions/before.png | Bin 0 -> 151763 bytes tools/agent_control_e2e.py | 7 +++++-- 3 files changed, 5 insertions(+), 2 deletions(-) create mode 100644 docs/media/command-suggestions/after.png create mode 100644 docs/media/command-suggestions/before.png diff --git a/docs/media/command-suggestions/after.png b/docs/media/command-suggestions/after.png new file mode 100644 index 0000000000000000000000000000000000000000..9c1a9cd4c0526ca9b93024d403f80a75f3610f24 GIT binary patch literal 282564 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

HKJ1g<6>+)l=W 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 y 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

tY~h_iJHf*SBFApc=~{{1tWydPACVMb&9Jv%Q* zUxN1)))Kzm_DtWC87q|GWfJ7WBEir)_wd zks14#{`5Fp2OHst3XEtR_3=MV1FujYA0PX4N&5^Xt17cD|MmpbRR&-zQo=`enT@(E zXuN#QSO9wkHh_zqGPysofoAcKUTYV|sl+o7vTfiM(7PpN zVV`n<9p*OFwNL411nyZI!-uNiU{lRTIp*EX1sNt2(%{l095dAP!(sM8{J8~s*XC3y z)yDPTz^76Jorn?-0RP*x_|9HEi#4G zKtJvWw9+yto%J7JwAH11+-Mqa-pDa+ZTWkvPL0pE@%2!nz4I6eXzJ4)TRSP^e^*Qk z=Ewxl#pk9w{R-JjJa5LI&zE-~Vk-z+91rrQMl0P@PXAckjd0D)>4$^&_xIi17`0`A zj=OC%7y1=j1z4g+FXLN}wqx?ctsvk*4~^W_LCV~(DrfFe9pvKyl?;hC#a_GmFaBFkxE17N_DT(mqZ$rz=L)j4QPM={CkwpentE0tGa0bE>;fL^o$>t zX5G-|k z^?Vv_KK;OPdU|g7b<2A>hL__R`SRb}W(7LcjK*fGZnP!nOWK4tIQ#zl@7V+L`14i# zcbL!o_R&lOLn0X`I7mUpLTHeyWO=py$iQd|$oMIYE-HXw26X)G$&b*l71R@`hKoQ6 zi^Ihmgmh~|&y-0E>2mGZ$KeF|#-#wfXP2`5AHZH_G@be25z6ET&ri|Ma!lYRZ^=&I*9ZcIMz5-T?BE7meEtmYYH!cY zjra?rs4#(WRO{~k0h#r518rDTC*9w_4^a>hU&Vt?ARCeoToZ?2WRA|Tf51>cm3<$h zkQgSnvMmrBrnLs^>`e2a;cZT#zQVlT8Z?9(c2j|J_tTf53Or*|DwVgpF*YS}u4y_Q zX5UX2PjwwvZrGUH|8cKb_c2C5BI90IOlm^y_>0B__goTIQ6PFz8!{cN3OG#uQ0UD188BLUv`r@oVSzyYnm)K%28y2u_ z!~`_wJ;jBlg#HMpbPAwj3j+ToQtB}a#Mx=5=2HFX!_W_b@+)Ym0O$G|K!@KK5Gab@ zZSFH!ef)=LX$hmBf6l0fulQu}}ANfAaI^ z&v2grSZ3?t;l8`qKDc}7K4!r`v$3BM1m*6}4^z2+{4tg@jSuss?!W6E?}l@I?E^mS zxHmrGX$dJuFlYsi1%UEh)zA2_dN>UO^tbnT40wWeiR}Y`f&eTgK)t{_V4$G&?(PJx zb@%>;mxtG%BJ2KLwOP~NM)vhK-{XBKY`N}FX1Cze>D-;hskZic|MnWM4HyagvKAH0 z%nK$cf9XVpV`ag(94M|8)2E9HEE>hYmqq7XGO$3?y8x2wra z-(GBqdDlXDZYyNBY6>=IjLh9mKXgwg^0fI{rxr-Zc}gp1ofdm2_jx*e+5h%yf4xj> zH#nQuct-+3s%-OBAMs^6Rx`ROfOC|7doydz&i{UxHa!WH%_Frpz3SI-=V!K{)BH3K zd|k+A2F#D$GwYEJ74rxJLw{W-%0D*vBLw^4u954PwTPT`!E*Ga8^G;P&~#`_sv=60 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 z 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 T>`Y hardcore -> creative (commands on) d('click', id='game-mode') + d('type', field='seed', text='5') + d('click', id='world') + d('click', id='world-type') # superflat: this checks chat, without a spawn search d('click', id='create-new-world') d('wait_for', condition='loaded', timeout=400) d('wait_ready', seconds=400) @@ -541,8 +544,8 @@ def suggestions_scenario(d, out): ('/giv', '/give'), ('/fill ^', '/fill ^ ^'), ('/give @s diamond_sw', '/give @s minecraft:diamond_sword'), - ('/setblock ~ ~ ~ sto', '/setblock ~ ~ ~ minecraft:stone'), - ('/fill ~ ~ ~ ~1 ~1 ~1 sto', '/fill ~ ~ ~ ~1 ~1 ~1 minecraft:stone'), + ('/setblock ~ ~ ~ diamond_blo', '/setblock ~ ~ ~ minecraft:diamond_block'), + ('/fill ~ ~ ~ ~1 ~1 ~1 diamond_blo', '/fill ~ ~ ~ ~1 ~1 ~1 minecraft:diamond_block'), ('/setblock ~ ~ ~ oak_stairs[fa', '/setblock ~ ~ ~ oak_stairs[facing='), ('/clear @s diamond_sw', '/clear @s minecraft:diamond_sword'), ('/execute run give @s diamond_sw', '/execute run give @s minecraft:diamond_sword'), From a97d8098c7a5ac9ba9c1043035b26a3ad1134606 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:47:29 +0100 Subject: [PATCH 55/59] Fix firework tooltip translations --- .../examples/firework_tooltip_fixture.rs | 7 ++- crates/horizon-client/src/enchant.rs | 2 + crates/horizon-client/src/item_tooltip.rs | 59 +++++++++++++++++++ tools/test_firework_tooltip_parity.py | 3 +- 4 files changed, 67 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/examples/firework_tooltip_fixture.rs b/crates/horizon-client/examples/firework_tooltip_fixture.rs index 196fa9955..7f10278b7 100644 --- a/crates/horizon-client/examples/firework_tooltip_fixture.rs +++ b/crates/horizon-client/examples/firework_tooltip_fixture.rs @@ -1,7 +1,7 @@ //! Firework tooltip companion for tools/test_firework_tooltip_parity.py: the //! lines `item_tooltip::firework_lines` gives each stack (SNBT, one per line; //! the `#resources` line names the prepared resources for en_us). -use horizon_client::{item_data::parse_stack, item_tooltip::firework_lines, lang::Language}; +use horizon_client::{enchant::Enchantments, item_data::parse_stack, item_tooltip::firework_lines}; use std::{error::Error, fmt::Write, path::PathBuf}; fn main() -> Result<(), Box> { @@ -12,8 +12,9 @@ fn main() -> Result<(), Box> { .find_map(|l| l.strip_prefix("#resources ")) .map(PathBuf::from) .ok_or("no #resources line")?; - let language = Language::load(&[&root], "en_us"); - let translate = |key: &str| language.get(key).map(str::to_owned); + // Use the inventory's filtered translations so missing tooltip keys are caught. + let enchantments = Enchantments::load(&root); + let translate = |key: &str| enchantments.translate(key).map(str::to_owned); let mut output = String::new(); for line in input.lines().filter(|l| !l.starts_with('#')) { let stack = parse_stack(line)?.ok_or("empty stack")?; diff --git a/crates/horizon-client/src/enchant.rs b/crates/horizon-client/src/enchant.rs index 039ea658f..ca2ea6f5c 100644 --- a/crates/horizon-client/src/enchant.rs +++ b/crates/horizon-client/src/enchant.rs @@ -193,6 +193,8 @@ impl Enchantments { || k.starts_with("item.minecraft.splash_potion") || k.starts_with("item.minecraft.lingering_potion") || k.starts_with("item.minecraft.tipped_arrow") + || k.starts_with("item.minecraft.firework_rocket.") + || k.starts_with("item.minecraft.firework_star.") || k.starts_with("trim_") || k.starts_with("potion.") || k.starts_with("container.") diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs index 0fc9910d1..1dbbbf38b 100644 --- a/crates/horizon-client/src/item_tooltip.rs +++ b/crates/horizon-client/src/item_tooltip.rs @@ -591,6 +591,65 @@ mod tests { assert!(container_lines(&ItemStack::new("minecraft:chest", 1), &name, &lang).is_empty()); } + #[test] + fn fireworks_use_loaded_tooltip_translations() { + let root = std::env::temp_dir().join(format!( + "horizon-firework-tooltip-language-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos(), + )); + let dir = root.join("assets/minecraft/lang"); + std::fs::create_dir_all(&dir).unwrap(); + std::fs::write( + dir.join("en_us.json"), + serde_json::to_vec(&serde_json::json!({ + "item.minecraft.firework_rocket.flight_duration": "Flight Duration: %s", + "item.minecraft.firework_rocket.multiple_stars": "%s x %s", + "item.minecraft.firework_star.shape.small_ball": "Small Ball", + "item.minecraft.firework_star.red": "Red", + "item.minecraft.firework_star.custom_color": "Custom", + "item.minecraft.firework_star.fade_to": "Fade to", + "item.minecraft.firework_star.trail": "Trail", + "item.minecraft.firework_star.flicker": "Twinkle", + })) + .unwrap(), + ) + .unwrap(); + let enchantments = crate::enchant::Enchantments::load(&root); + std::fs::remove_dir_all(&root).unwrap(); + let translate = |key: &str| enchantments.translate(key).map(str::to_owned); + let mut rocket = ItemStack::new("minecraft:firework_rocket", 1); + assert_eq!(firework_lines(&rocket, &translate), ["Flight Duration: 1"]); + let explosion = crate::particles::FireworkExplosion { + colors: vec![0xB3312C], + fade: vec![0x123456], + trail: true, + twinkle: true, + ..Default::default() + }; + rocket.data_mut().fireworks = Some((3, vec![explosion.clone(), explosion.clone()])); + assert_eq!( + firework_lines(&rocket, &translate), + [ + "Flight Duration: 3", + "2 x Small Ball", + " Red", + " Fade to Custom", + " Trail", + " Twinkle", + ] + ); + let mut star = ItemStack::new("minecraft:firework_star", 1); + star.data_mut().firework_explosion = Some(explosion); + assert_eq!( + firework_lines(&star, &translate), + ["Small Ball", "Red", "Fade to Custom", "Trail", "Twinkle"] + ); + } + #[test] fn amounts_use_two_decimals_at_most() { assert_eq!(format_amount(8.0), "8"); diff --git a/tools/test_firework_tooltip_parity.py b/tools/test_firework_tooltip_parity.py index e6cea9925..b3114c01a 100644 --- a/tools/test_firework_tooltip_parity.py +++ b/tools/test_firework_tooltip_parity.py @@ -67,6 +67,7 @@ if __name__ == '__main__': 'firework-tooltip-parity', 'VanillaFireworkTooltipOracle', 'firework_tooltip_fixture', cases, 'Firework rocket and star tooltip lines: flight duration, explosions (counted runs), colours, fade, trail, ' 'twinkle, defaults and tooltip_display', - sources=[lab.ROOT / 'crates/horizon-client/src/item_tooltip.rs', lab.ROOT / 'crates/horizon-client/src/item_data.rs', + sources=[lab.ROOT / 'crates/horizon-client/src/enchant.rs', + lab.ROOT / 'crates/horizon-client/src/item_tooltip.rs', lab.ROOT / 'crates/horizon-client/src/item_data.rs', lab.ROOT / 'crates/horizon-client/src/particles.rs'], expected_lines=COUNT) From c0fd8dabfd96389d23cfd0d2874ae55ef6f4de5f Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 19:15:44 +0200 Subject: [PATCH 56/59] Fix #1222: single player runs in the frame again until server players have vehicles Since #1114 single player's window is a player of its own server thread, and a server's players can't use boats or minecarts: the client sends Attack and Interact only for mobs (remote_start_attack, remote_use_entity), the server aims a player's attack or use only at mobs and dragon parts (look_at_entity), and neither side handles riding (no SetPassengers on the client, no MoveVehicle or PaddleBoat packets). So a boat on water could not be boarded or broken in single player. The server thread is opt-in again (--server-thread or HORIZON_SERVER_THREAD=1); --no-server-thread still works. lan_e2e boats: the host right-clicks a boat on water and rides it, sneaks out, and breaks it. Without --server-thread the host now runs the game's default instead of forcing the frame, so the check covers what players get. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 11 ++-- crates/horizon-client/src/game/integrated.rs | 7 ++- tools/lan_e2e.py | 61 ++++++++++++++++++-- 3 files changed, 67 insertions(+), 12 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..6e978a6cb 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -272,9 +272,10 @@ struct Options { benchmark: Option, /// `--dev-mod PATH` (repeatable): mods always on and reloaded when rebuilt. dev_mods: Vec, - /// Single player runs on an integrated server thread (game/integrated.rs), - /// as vanilla's does: the default. `--no-server-thread` or - /// `HORIZON_SERVER_THREAD=0` runs the world in the frame instead. + /// `--server-thread` or `HORIZON_SERVER_THREAD=1`: single player runs on an + /// integrated server thread (game/integrated.rs), as vanilla's does. Off by + /// default again until a server's players can board, ride and hit + /// vehicles (#1222); `--no-server-thread` keeps it off. server_thread: bool, /// Set on the integrated server's own options: it draws nothing, so it skips meshing. integrated: bool, @@ -331,7 +332,7 @@ impl Options { dev_mods: Vec::new(), // The command harness (HORIZON_COMMAND_SCRIPT) drives the world // itself, without the event loop: it stays in the frame. - server_thread: std::env::var("HORIZON_SERVER_THREAD").map_or(true, |v| v != "0") + server_thread: std::env::var("HORIZON_SERVER_THREAD").is_ok_and(|v| v == "1") && std::env::var_os("HORIZON_COMMAND_SCRIPT").is_none(), integrated: false, }; @@ -341,7 +342,7 @@ impl Options { match arg.as_str() { "--help" | "-h" => { println!( - "Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --no-server-thread Run single player's world in the frame, not on its server thread\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.", + "Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --server-thread Run single player's world on its server thread (no vehicles yet)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.", horizon_core::VANILLA_VERSION ); return Ok(None); diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index ef5775174..1bd3c7696 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -6,9 +6,10 @@ //! the world's options) with [`Integrated::call`], as vanilla's client calls //! into its `IntegratedServer`. //! -//! On by default. `--no-server-thread` or `HORIZON_SERVER_THREAD=0` runs -//! the world in the frame instead (the escape hatch while the network -//! player's side catches up with the in-frame one). +//! Opt-in again (`--server-thread` or `HORIZON_SERVER_THREAD=1`): it was the +//! default for one day, but a server's players can't board, ride or hit +//! boats and minecarts yet (#1222), and single player's window is one of +//! them here. use super::{ Game, Options, PackResources, Resources, UiResources, lan::{LanSettings, Owner}, diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 9b883b163..6c4cffe23 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -114,6 +114,8 @@ address. The script then checks, from both sides, what a guest's game used to ge server's game time after the guest's game stalls for a few seconds (#848). - growth: far from the host, the chunks around the guest tick (#890): water placed there flows and wheat on farmland grows (random ticks), however the host runs its world. +- boats: the host (single player, on its server thread with --server-thread) right-clicks a + boat on water and rides it, sneaks out, and breaks it with its fists (#1222). - flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival: the guest, and on the server thread the host's window too, take what may fly from the server's abilities (ClientPacketListener.handlePlayerAbilities). @@ -155,7 +157,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'boats'] class Game: @@ -2279,6 +2281,52 @@ def check_flight(host, guest, out): return seen + +def check_boats(host, guest, out): + """#1222: the single player boards a boat on water with a right click, sneaks out, and breaks it.""" + x, y, z = (int(v // 1) for v in pos_of(host)) + bx = x + 3 + host('command', command='gamemode survival') + host('command', command=f'fill {bx - 1} {y} {z - 1} {bx + 1} {y + 3} {z + 1} minecraft:air') + host('command', command=f'fill {bx - 1} {y - 1} {z - 1} {bx + 1} {y - 1} {z + 1} minecraft:water') + host('command', command=f'summon minecraft:oak_boat {bx + 0.5} {y - 0.1} {z + 0.5}') + host.wait(30) + boats = [o for o in host('status')['objects'] if o['kind'].endswith('oak_boat') + and abs(o['position'][0] - (bx + 0.5)) < 2 and abs(o['position'][2] - (z + 0.5)) < 2] + try: + assert boats, 'the host sees no boat on the water' + boat = boats[0] + bp = boat['position'] + host.raw('look-at', f'{bp[0]:.2f}', f'{bp[1] + 0.3:.2f}', f'{bp[2]:.2f}') + host.raw('mouse', 'right', 'click') + host.wait(10) + riding = host('status').get('riding') + assert riding == boat['id'], f'right-clicking the boat {boat["id"]}: riding {riding}' + host.raw('key', 'shift', 'down') + host.wait(10) + host.raw('key', 'shift', 'up') + host.wait(10) + riding = host('status').get('riding') + assert riding is None, f'sneaking out of the boat: riding {riding}' + host('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + host.wait(5) + gone = False + for _ in range(10): + here = [o for o in host('status')['objects'] if o['id'] == boat['id']] + if not here: + gone = True + break + bp = here[0]['position'] + host.raw('look-at', f'{bp[0]:.2f}', f'{bp[1] + 0.3:.2f}', f'{bp[2]:.2f}') + host.raw('mouse', 'left', 'click') + # VehicleEntity.tick takes 1 off the damage every tick: hit fast. + host.wait(2) + assert gone, 'ten hits left the boat in place' + return {'boat': boat['id'], 'rode': True, 'broken': True} + finally: + host('command', command=f'kill @e[type=minecraft:oak_boat,x={bx},y={y},z={z},distance=..6]') + host('command', command=f'fill {bx - 1} {y - 1} {z - 1} {bx + 1} {y - 1} {z + 1} minecraft:stone') + def check_growth(host, guest, out): """Block ticks near a guest 1000 blocks from the host: only the guest's tickets tick them.""" x0, y0, z0 = pos_of(guest) @@ -2591,13 +2639,18 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'boats': check_boats} def run(ctl, out, resources, checks): host, guest = Game('host', ctl, resources), Game('guest', ctl, resources) - # Either way explicitly: the game's default is the server thread. - host.d.env['HORIZON_SERVER_THREAD'] = '1' if SERVER_THREAD else '0' + # Without --server-thread the host runs the game's default, the world in the frame, as players + # get it (`boats` fails there if the default goes back to the server thread before it has + # vehicles, #1222). + if SERVER_THREAD: + host.d.env['HORIZON_SERVER_THREAD'] = '1' + else: + host.d.env.pop('HORIZON_SERVER_THREAD', None) results = {} try: host.pid = host('launch', wait=False, offscreen=sys.platform == 'darwin')['pid'] From 724f42355f8884824f46189c64525e24ba02a0a4 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 19:37:21 +0200 Subject: [PATCH 57/59] Fix #1255: server players climbing down a ladder take no fall damage Player's MoveSimulationType is AUTHORITATIVE_SIDE_AND_SERVER, so a ServerPlayer travels on the server too, and every tick on a ladder or vine LivingEntity.handleOnClimbable resets its fall distance. Horizon's server only replayed the client's moves (ServerPlayer.doCheckFallDamage), so the fall distance grew all the way down a ladder and hurt the player where it landed: LAN guests, dedicated-server players and, while single player ran on the server thread (#1114), the single player. lan_e2e ladder: the guest slides down ten blocks of ladder and lands with full health (before: 20 -> 13). Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/lan_actions.rs | 7 ++++ crates/horizon-client/src/motion.rs | 3 +- tools/lan_e2e.py | 34 +++++++++++++++++-- 3 files changed, 41 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index bc224da9e..7028c2eca 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1730,6 +1730,13 @@ impl Game<'_> { break; } } + // A ServerPlayer travels on the server too + // (MoveSimulationType.AUTHORITATIVE_SIDE_AND_SERVER), so every tick + // on a ladder or vine LivingEntity.handleOnClimbable resets its fall + // distance: climbing down doesn't hurt where it lands (#1255). + if w.climbable().unwrap_or(false) { + w.player.fall_distance = 0.0; + } let _ = w.tick_environment_damage(); let _ = w.apply_fire_contact(); let _ = w.server_hazards_tick(in_wall); diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index b1088188c..1920026b9 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -716,7 +716,8 @@ impl MotionWorld<'_, '_, '_> { supporting_block: self.player.ground.supporting_block, } } - fn climbable(&mut self) -> Result { + /// `LivingEntity.onClimbable` at the player's feet (it remembers the block). + pub fn climbable(&mut self) -> Result { if self.player.spectator { return Ok(false); } diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 9b883b163..15129e6b6 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -114,6 +114,8 @@ address. The script then checks, from both sides, what a guest's game used to ge server's game time after the guest's game stalls for a few seconds (#848). - growth: far from the host, the chunks around the guest tick (#890): water placed there flows and wheat on farmland grows (random ticks), however the host runs its world. +- ladder: the guest climbs down ten blocks of ladder and lands unhurt: the server resets its fall + distance on a ladder every tick, as LivingEntity.handleOnClimbable does (#1255). - flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival: the guest, and on the server thread the host's window too, take what may fly from the server's abilities (ClientPacketListener.handlePlayerAbilities). @@ -155,7 +157,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder'] class Game: @@ -2279,6 +2281,34 @@ def check_flight(host, guest, out): return seen + +def check_ladder(host, guest, out): + """#1255: climbing down a ladder doesn't hurt where the guest lands.""" + x, y, z = (int(v // 1) for v in pos_of(guest)) + lx, lz = x + 6, z + guest('command', command='gamemode survival') + guest('command', command=f'fill {lx - 2} {y} {lz - 2} {lx + 2} {y + 12} {lz + 2} minecraft:air') + guest('command', command=f'fill {lx - 2} {y - 1} {lz - 2} {lx + 2} {y - 1} {lz + 2} minecraft:stone') + guest('command', command=f'fill {lx} {y} {lz + 1} {lx} {y + 10} {lz + 1} minecraft:stone') + guest('command', command=f'fill {lx} {y} {lz} {lx} {y + 10} {lz} minecraft:ladder[facing=north]') + guest.wait(10) + try: + before = remote(guest)['health'] + # No input on a ladder: the guest slides down at 0.15 a tick (LivingEntity.handleOnClimbable). + guest('command', command=f'tp @s {lx + 0.5} {y + 10} {lz + 0.4} 0 0') + for _ in range(40): + guest.wait(5) + if pos_of(guest)[1] < y + 0.01: + break + guest.wait(20) + landed, after = pos_of(guest), remote(guest)['health'] + assert landed[1] < y + 0.01, f'the guest stayed on the ladder at {landed}' + assert after >= before, f'climbing down ten blocks of ladder took the guest from {before} to {after} health' + return {'landed': landed, 'health': after} + finally: + guest('command', command=f'fill {lx} {y} {lz} {lx} {y + 10} {lz + 1} minecraft:air') + guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + def check_growth(host, guest, out): """Block ticks near a guest 1000 blocks from the host: only the guest's tickets tick them.""" x0, y0, z0 = pos_of(guest) @@ -2591,7 +2621,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder} def run(ctl, out, resources, checks): From 0928c83d4c28fb285c07e5c2404c5a7016cb5d7d Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 18:39:53 +0100 Subject: [PATCH 58/59] Skip provably unchanged native End surface traversal --- .../examples/streaming_bench.rs | 66 ++++++- .../horizon-world/examples/chunkgen_bench.rs | 118 ++++++++++- .../horizon-world/src/worldgen/generator.rs | 184 ++++++++++++++++-- 3 files changed, 341 insertions(+), 27 deletions(-) diff --git a/crates/horizon-client/examples/streaming_bench.rs b/crates/horizon-client/examples/streaming_bench.rs index 9f8e99899..b8c56b28c 100644 --- a/crates/horizon-client/examples/streaming_bench.rs +++ b/crates/horizon-client/examples/streaming_bench.rs @@ -3,6 +3,7 @@ //! what the render thread pays for it in `Streaming::update`. //! //! streaming_bench RESOURCES [--threads N] [--radius R] [--seed S] [--fly CHUNKS_PER_S] [--seconds T] [--hz F] +//! [--dimension overworld|the_nether|the_end] [--center-x X] [--center-z Z] //! //! First the area around (0, 0) fills; then, with `--fly`, the centre moves along +x //! at that speed for T seconds while frames run at F per second. Each phase reports @@ -72,14 +73,33 @@ static ALLOCATOR: CountingAllocator = CountingAllocator; type Result = std::result::Result>; +fn cpu_seconds() -> f64 { + std::fs::read_to_string("/proc/self/stat") + .ok() + .and_then(|stat| { + let fields = stat + .rsplit_once(')')? + .1 + .split_whitespace() + .collect::>(); + Some((fields[11].parse::().ok()? + fields[12].parse::().ok()?) / 100.0) + }) + .unwrap_or(0.0) +} + #[derive(Default)] struct Phase { updates: Vec, local: (u64, u64), uploads: usize, + stage_samples: [u64; 7], + cpu_start: f64, } impl Phase { fn update(&mut self, streaming: &mut Streaming, world: &mut World) { + if self.updates.is_empty() { + self.cpu_start = cpu_seconds(); + } let before = LOCAL.with(Cell::get); let started = Instant::now(); let (uploads, _) = streaming.update(world); @@ -89,6 +109,9 @@ impl Phase { self.local.1 += after.1 - before.1; self.uploads += uploads.len(); drop(uploads); + for (sum, (_, count)) in self.stage_samples.iter_mut().zip(streaming.stages()) { + *sum += count as u64; + } } fn report(&self, name: &str, wall: Duration, streaming: &Streaming, generated: u64) { let mut sorted = self.updates.clone(); @@ -106,6 +129,16 @@ impl Phase { at(0.99), sorted.last().copied().unwrap_or(0.0), ); + println!( + "BENCH {}", + serde_json::json!({ + "phase": name, "wall_s": wall.as_secs_f64(), + "cpu_s": cpu_seconds() - self.cpu_start, + "chunks": streaming.generated_total - generated, "sections": self.uploads, + "updates": self.updates.len(), "update_ms": total, + "mean_stages": self.stage_samples.map(|n| n as f64 / self.updates.len() as f64), + }) + ); if TRACK { println!( " update allocations: {} ({:.1} MiB)", @@ -142,6 +175,22 @@ fn main() -> Result<()> { let fly = flag("--fly", 0.0); let seconds = flag("--seconds", 10.0); let hz = flag("--hz", 240.0); + let dimension = args + .iter() + .position(|a| a == "--dimension") + .and_then(|i| args.get(i + 1)) + .map(|d| { + if d.contains(':') { + d.clone() + } else { + format!("minecraft:{d}") + } + }) + .unwrap_or_else(|| "minecraft:overworld".into()); + let center = ( + flag("--center-x", 0.0) as i32, + flag("--center-z", 0.0) as i32, + ); let assets = Arc::new(Assets::load(&root)?); let render = Arc::new(assets.reload(&root)?); @@ -154,11 +203,12 @@ fn main() -> Result<()> { models::load_visibility(&root, assets.registry)?, )?); let light = Arc::new(LightTables::load(&root, assets.registry, &facts)?); - let terrain = Arc::new(VanillaTerrain::new( + let terrain = Arc::new(VanillaTerrain::for_dimension( &root.join("worldgen"), assets.registry, &biomes, seed, + &dimension, )?); let context = Arc::new(WorkerContext { assets, @@ -170,8 +220,12 @@ fn main() -> Result<()> { let mut world = World::new(facts.air, seed); let mut streaming = Streaming::new(terrain, context, threads); streaming.radius = radius; - streaming.center = (0, 0); - println!("{threads} workers, radius {radius}, seed {seed}"); + streaming.center = center; + streaming.nether_shading = dimension == "minecraft:the_nether"; + streaming.sky_light = dimension != "minecraft:the_nether"; + println!( + "{threads} workers, radius {radius}, seed {seed}, dimension {dimension}, center {center:?}" + ); let (allocations, bytes) = (ALLOCATIONS.load(Relaxed), BYTES.load(Relaxed)); // Fill: update as often as the game would uncapped, until settled. @@ -198,12 +252,12 @@ fn main() -> Result<()> { let mut behind = Vec::new(); while started.elapsed().as_secs_f64() < seconds { let next = Instant::now() + frame; - let x = (started.elapsed().as_secs_f64() * fly) as i32; - streaming.center = (x, 0); + let x = center.0 + (started.elapsed().as_secs_f64() * fly) as i32; + streaming.center = (x, center.1); phase.update(&mut streaming, &mut world); // Columns within 2 chunks of the player still missing their meshes. let near = (-2..=2) - .flat_map(|dz| (-2..=2).map(move |dx| (x + dx, dz))) + .flat_map(|dz| (-2..=2).map(move |dx| (x + dx, center.1 + dz))) .filter(|&(cx, cz)| !streaming.is_lit(cx, cz)) .count(); behind.push(near); diff --git a/crates/horizon-world/examples/chunkgen_bench.rs b/crates/horizon-world/examples/chunkgen_bench.rs index 4992515c5..2eb433600 100644 --- a/crates/horizon-world/examples/chunkgen_bench.rs +++ b/crates/horizon-world/examples/chunkgen_bench.rs @@ -3,6 +3,7 @@ //! chunkgen_bench [--seed S] [--size N] [--threads T] //! [--center CX CZ] [--verify ] [--no-decorate] //! [--dimension overworld|the_nether|the_end] +//! [--warmup] [--json] [--no-map] [--snapshot PATH] use horizon_core::position::ChunkPos; use horizon_world::{ DATA_VERSION, @@ -274,7 +275,9 @@ fn main() -> Result<(), Error> { let resources = PathBuf::from(args.next().expect("client resource directory")); let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0)); let mut parity = None; + let mut snapshot_path = None; let mut decorate = true; + let (mut warmup, mut json, mut map) = (false, false, true); let mut dimension = String::from("minecraft:overworld"); let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None; while let Some(arg) = args.next() { @@ -285,7 +288,11 @@ fn main() -> Result<(), Error> { "--threads" => threads = next().parse()?, "--center" => center = (next().parse()?, next().parse()?), "--verify" => parity = Some(PathBuf::from(next())), + "--snapshot" => snapshot_path = Some(PathBuf::from(next())), "--no-decorate" => decorate = false, + "--warmup" => warmup = true, + "--json" => json = true, + "--no-map" => map = false, "--dimension" => { let d = next(); dimension = if d.contains(':') { @@ -326,6 +333,16 @@ fn main() -> Result<(), Error> { dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?; return Ok(()); } + if warmup { + let mut worker = generator.worker(); + for z in -4..=4 { + for x in -4..=4 { + std::hint::black_box( + worker.generate_proto(ChunkPos::new(center.0 + 64 + x, center.1 + 64 + z))?, + ); + } + } + } let (x0, z0) = (center.0 - size / 2, center.1 - size / 2); let count = (size * size) as usize; let next = AtomicUsize::new(0); @@ -353,6 +370,7 @@ fn main() -> Result<(), Error> { handles.into_iter().try_for_each(|h| h.join().unwrap()) })?; let elapsed = start.elapsed(); + let cpu_elapsed = cpu_seconds() - cpu; println!( "generated {count} proto chunks with {threads} threads in {elapsed:.2?}: {:.1} chunks/s ({:.1} ms/chunk/thread)", count as f64 / elapsed.as_secs_f64(), @@ -360,7 +378,7 @@ fn main() -> Result<(), Error> { ); println!( " cpu time {:.1} ms/chunk", - (cpu_seconds() - cpu) * 1000. / count as f64 + cpu_elapsed * 1000. / count as f64 ); let timings = timings.into_inner().unwrap(); let per_chunk = |f: fn(&StageTimings) -> std::time::Duration| { @@ -379,10 +397,23 @@ fn main() -> Result<(), Error> { per_chunk(|t| t.surface), per_chunk(|t| t.carvers) ); + if json { + println!( + "BENCH {}", + serde_json::json!({"phase": "proto", "chunks": count, + "threads": threads, "wall_s": elapsed.as_secs_f64(), "cpu_s": cpu_elapsed, + "biomes_ms_chunk": per_chunk(|t| t.biomes), "noise_ms_chunk": per_chunk(|t| t.noise), + "structures_ms_chunk": per_chunk(|t| t.structures), + "surface_ms_chunk": per_chunk(|t| t.surface), "carvers_ms_chunk": per_chunk(|t| t.carvers)}) + ); + } let mut chunks: Vec> = slots .into_iter() .map(|slot| slot.into_inner().unwrap()) .collect(); + if let Some(path) = &snapshot_path { + snapshot(&chunks, path, "terrain")?; + } if decorate && size >= 3 { let totals = Mutex::new(DecorateStats::default()); let start = Instant::now(); @@ -441,6 +472,13 @@ fn main() -> Result<(), Error> { } } let elapsed = start.elapsed(); + if json { + println!( + "BENCH {}", + serde_json::json!({"phase": "decorate", "chunks": decorated, + "wall_s": elapsed.as_secs_f64()}) + ); + } let totals = totals.into_inner().unwrap(); println!( "decorated {decorated} chunks in {elapsed:.2?}: {:.1} chunks/s; feature roots placed {}, unsupported {}, failed {}", @@ -461,6 +499,9 @@ fn main() -> Result<(), Error> { ); } } + if let Some(path) = &snapshot_path { + snapshot(&chunks, path, "decorated")?; + } let mut structures = BTreeMap::<(String, i32, i32), [[i32; 3]; 2]>::new(); for chunk in chunks.iter().flatten() { for (name, start, min, max) in chunk.structures() { @@ -492,6 +533,9 @@ fn main() -> Result<(), Error> { } } } + if !map { + return Ok(()); + } let mut legend = BTreeMap::>::new(); let step = (size * 16 / 96).max(1); for bz in (0..size * 16).step_by(step as usize) { @@ -534,3 +578,75 @@ fn main() -> Result<(), Error> { ); Ok(()) } + +// Diagnostic only: full ordered chunk state, outside performance measurements. +fn snapshot(chunks: &[Option], path: &Path, phase: &str) -> Result<(), Error> { + use std::io::Write; + let mut out = + std::io::BufWriter::new(fs::File::create(format!("{}-{phase}.bin", path.display()))?); + for chunk in chunks.iter().flatten() { + let terrain = &chunk.terrain; + writeln!( + out, + "chunk {:?} {:?} {} {:?} {:?}", + chunk.position(), + terrain.generation_stage(), + chunk.is_decorated(), + chunk.structures(), + terrain.below_zero_retrogen().map(|v| v.to_nbt()) + )?; + for section in 0..terrain.height() as usize / 16 { + let data = terrain.section(section).unwrap(); + writeln!(out, "section {section} {:?}", data.to_nbt()?)?; + for index in 0..4096 { + out.write_all(&data.get(index)?.0.to_le_bytes())?; + } + } + // Compare public reads too, including all-air section behavior. + for y in terrain.min_y()..terrain.min_y() + terrain.height() { + for z in 0..16 { + for x in 0..16 { + out.write_all(&terrain.block(x, y, z).0.to_le_bytes())?; + } + } + } + for y in (terrain.min_y() >> 2)..((terrain.min_y() + terrain.height()) >> 2) { + for z in 0..4 { + for x in 0..4 { + writeln!( + out, + "biome {}", + chunk.biome_at( + chunk.position().x * 16 + x * 4, + y * 4, + chunk.position().z * 16 + z * 4 + ) + )?; + } + } + } + for kind in HeightmapType::ALL { + writeln!( + out, + "heightmap {kind:?} {:?}", + terrain.heightmap(kind).map(|m| m.raw_data()) + )?; + } + writeln!(out, "post {:?}", terrain.postprocessing())?; + writeln!(out, "blockticks {:?}", terrain.block_ticks().pack(0))?; + writeln!(out, "fluidticks {:?}", terrain.fluid_ticks().pack(0))?; + for (position, tag) in &chunk.block_entities { + writeln!(out, "blockentity {position:?}")?; + let bytes = + horizon_world::nbt::write_network(&Tag::Compound(tag.clone()), Default::default())?; + out.write_all(&(bytes.len() as u64).to_le_bytes())?; + out.write_all(&bytes)?; + } + let entities = Tag::List(chunk.entities.iter().cloned().map(Tag::Compound).collect()); + let bytes = horizon_world::nbt::write_network(&entities, Default::default())?; + out.write_all(&(bytes.len() as u64).to_le_bytes())?; + out.write_all(&bytes)?; + } + out.flush()?; + Ok(()) +} diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs index 2d7dd251c..fdba843b0 100644 --- a/crates/horizon-world/src/worldgen/generator.rs +++ b/crates/horizon-world/src/worldgen/generator.rs @@ -995,6 +995,46 @@ where worker.terrain_context = context; result } + /// With the native End source there are no badlands/iceberg extensions. + /// Disabled aquifers with air as their default fluid can only add lava or + /// air to the default solid, so this constant rule would rewrite each solid + /// with the state it already has. Check their imported material flags too. + /// Noise filling already built the WG maps; these writes add no fluid marks. + fn identity_end_surface(&self, pos: ChunkPos) -> bool { + if !matches!(self.source, ResolvedBiomeSource::End(_)) + // At wrapped block coordinates the ordinary biome-region lookup + // can fail; retain that lookup and its error outside this range. + || ![pos.x, pos.z].into_iter().all(|c| { + c.checked_mul(16).is_some_and(|b| { + b.checked_sub(16).is_some() && b.checked_add(31).is_some() + }) + }) + || self.aquifer.is_some() + || Some(self.settings.default_block) + != self.data.registry.default_state("minecraft:end_stone") + || Some(self.settings.default_fluid) + != self.data.registry.default_state("minecraft:air") + || !self.data.states.get(self.settings.default_fluid).air + || !self + .data + .registry + .default_state("minecraft:lava") + .is_some_and(|lava| self.data.states.get(lava).fluid) + { + return false; + } + let mut rule = &self.rule; + // Restrict the shortcut to shallow block references; other rules still + // run their normal compilation, queries and error handling. + for _ in 0..32 { + match rule { + MaterialRule::Reference(next) => rule = next, + MaterialRule::Block(state) => return *state == self.settings.default_block, + _ => return false, + } + } + false + } fn generate_with_context( &self, worker: &mut WorkerState, @@ -1103,27 +1143,29 @@ where .map_err(stage("noise"))?; let generation = self.generation(); worker.timings.noise += lap(&mut clock); - build_surface( - &mut chunk, - self.rule.clone(), - SurfaceInputs:: { - generation, - noise_volume: volume, - root: self.root.clone(), - surface: SurfaceQueries { - pipeline: self, - temperatures: &mut worker.temperatures, - biome: Biomes::Region(&biomes), - possible: Some(possible), + if !self.identity_end_surface(pos) { + build_surface( + &mut chunk, + self.rule.clone(), + SurfaceInputs:: { + generation, + noise_volume: volume, + root: self.root.clone(), + surface: SurfaceQueries { + pipeline: self, + temperatures: &mut worker.temperatures, + biome: Biomes::Region(&biomes), + possible: Some(possible), + }, + preliminary_surface: self.preliminary.clone(), + density_context: context, + write_min_y: min, + write_max_y: min + height - 1, }, - preliminary_surface: self.preliminary.clone(), - density_context: context, - write_min_y: min, - write_max_y: min + height - 1, - }, - &self.extensions, - ) - .map_err(stage("surface"))?; + &self.extensions, + ) + .map_err(stage("surface"))?; + } worker.timings.surface += lap(&mut clock); let carvers = &data.biome_carvers; let mask = generate_carving_mask(self.seed, pos, generation, false, |origin| { @@ -2407,6 +2449,108 @@ impl GeneratorWorker { #[cfg(test)] mod tests { use super::*; + #[test] + fn end_identity_surface_matches_normal_surface_and_rejects_custom_rules() { + let root = std::env::var_os("HORIZON_TEST_RESOURCES") + .map(std::path::PathBuf::from) + .unwrap_or_else(|| { + Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3") + }); + if !root.join("worldgen/world_presets.json").exists() { + eprintln!("skipping: no worldgen bundle at {}", root.display()); + return; + } + let registry = Box::leak(Box::new(crate::level::data::load_registry(&root).unwrap())); + let data = GeneratorData::load(&root.join("worldgen"), registry).unwrap(); + let preset: Value = serde_json::from_str(&data.world_presets["minecraft:normal"]).unwrap(); + let settings: Value = serde_json::from_str(&data.settings["minecraft:end"]).unwrap(); + let mut pipeline = Pipeline::new( + data.clone(), + 12345, + LegacyRandom::new(12345), + &preset["dimensions"]["minecraft:the_end"]["generator"], + &settings, + false, + None, + ) + .unwrap(); + let mut worker = OverworldGenerator::for_world( + data.clone(), + 12345, + "minecraft:normal", + "minecraft:the_end", + false, + ) + .unwrap() + .worker(); + assert!(pipeline.identity_end_surface(ChunkPos::new(0, 0))); + for pos in [ + ChunkPos::new(0, 0), + ChunkPos::new(128, 128), + ChunkPos::new(-128, 192), + ChunkPos::new(1_875_000, -1_875_000), + ] { + let actual = pipeline.generate(&mut worker.state, pos).unwrap(); + let rule = pipeline.rule.clone(); + // A singleton sequence evaluates the same block rule through the full surface path. + pipeline.rule = MaterialRule::Sequence(vec![rule.clone()]); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + let expected = pipeline.generate(&mut worker.state, pos).unwrap(); + pipeline.rule = rule; + assert_eq!( + actual.terrain.generation_stage(), + expected.terrain.generation_stage() + ); + for section in 0..actual.terrain.height() as usize / 16 { + assert_eq!( + actual.terrain.section(section).unwrap().to_nbt().unwrap(), + expected.terrain.section(section).unwrap().to_nbt().unwrap() + ); + } + for kind in HeightmapType::ALL { + assert_eq!( + actual.terrain.heightmap(kind).map(|m| m.raw_data()), + expected.terrain.heightmap(kind).map(|m| m.raw_data()) + ); + } + assert_eq!( + actual.terrain.postprocessing(), + expected.terrain.postprocessing() + ); + assert_eq!( + actual.terrain.block_ticks().pack(0), + expected.terrain.block_ticks().pack(0) + ); + assert_eq!( + actual.terrain.fluid_ticks().pack(0), + expected.terrain.fluid_ticks().pack(0) + ); + assert_eq!(actual.block_entities, expected.block_entities); + assert_eq!(actual.entities, expected.entities); + assert_eq!(actual.structures(), expected.structures()); + } + assert!(!pipeline.identity_end_surface(ChunkPos::new(i32::MAX, 0))); + let old_rule = pipeline.rule.clone(); + pipeline.rule = MaterialRule::Block(registry.default_state("minecraft:stone").unwrap()); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + pipeline.rule = old_rule; + let old_fluid = pipeline.settings.default_fluid; + pipeline.settings.default_fluid = registry.default_state("minecraft:stone").unwrap(); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + pipeline.settings.default_fluid = old_fluid; + let old_source = std::mem::replace( + &mut pipeline.source, + ResolvedBiomeSource::Fixed(super::super::biome_source::FixedBiomeSource { + biome: "minecraft:the_end".into(), + }), + ); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + pipeline.source = old_source; + pipeline.aquifer = Some(std::array::from_fn(|_| { + pipeline.router.get(RouterField::Erosion).clone() + })); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + } #[test] fn far_surface_matches_undecorated_land_and_keeps_end_void() { From 4e04e97565575b09c5e012cef61a5ac619bbe81b Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 20:29:00 +0100 Subject: [PATCH 59/59] Reuse eligible End island candidates across bounded density volumes --- .../horizon-core/src/density/end_islands.rs | 140 +++++++++++++++++- 1 file changed, 139 insertions(+), 1 deletion(-) diff --git a/crates/horizon-core/src/density/end_islands.rs b/crates/horizon-core/src/density/end_islands.rs index 148f3575d..2ae9f9b5f 100644 --- a/crates/horizon-core/src/density/end_islands.rs +++ b/crates/horizon-core/src/density/end_islands.rs @@ -50,6 +50,64 @@ impl EndIslandSampler { } height } + // Nearby volume columns visit overlapping 25-by-25 island neighborhoods. + // Collect the eligible islands once, retaining their original X/Z order. + // Larger or coordinate-wrapping volumes keep the scalar evaluation path. + fn volume_islands(&self, volume: DensityVolume) -> Option> { + let sizes = volume.sizes(); + if sizes[0] * sizes[2] < 4 { + return None; + } + let minimum = volume.minimum(); + let steps = volume.steps(); + let end = |axis: usize| { + i32::try_from( + i64::from(minimum[axis]) + (sizes[axis] - 1) as i64 * i64::from(steps[axis]), + ) + .ok() + }; + let first_x = minimum[0] / 8 / 2 - 12; + let first_z = minimum[2] / 8 / 2 - 12; + let last_x = end(0)? / 8 / 2 + 12; + let last_z = end(2)? / 8 / 2 + 12; + if last_x - first_x >= 64 || last_z - first_z >= 64 { + return None; + } + let mut islands = Vec::new(); + for x in first_x..=last_x { + for z in first_z..=last_z { + if i64::from(x) * i64::from(x) + i64::from(z) * i64::from(z) <= 4096 + || self.noise.get2(f64::from(x), f64::from(z)) >= -0.9 + { + continue; + } + let scale = ((x as f32).abs() * 3439.0 + (z as f32).abs() * 147.0) % 13.0 + 9.0; + islands.push((x, z, scale)); + } + } + Some(islands) + } + fn density_from_islands(x: i32, z: i32, islands: &[(i32, i32, f32)]) -> f32 { + let x = x / 8; + let z = z / 8; + let center_x = x / 2; + let center_z = z / 2; + let mut height = -100.0; + for &(island_x, island_z, scale) in islands { + let offset_x = island_x - center_x; + let offset_z = island_z - center_z; + if !(-12..=12).contains(&offset_x) || !(-12..=12).contains(&offset_z) { + continue; + } + let dx = (x % 2 - offset_x * 2) as f32; + let dz = (z % 2 - offset_z * 2) as f32; + let candidate = 100.0 - ((dx * dx + dz * dz) as f64).sqrt() as f32 * scale; + let candidate = + super::arithmetic::java_min(super::arithmetic::java_max(candidate, -100.0), 80.0); + height = super::arithmetic::java_max(height, candidate); + } + (height - 8.0) / 128.0 + } fn density(&self, x: i32, z: i32) -> f32 { (self.height(x / 8, z / 8) - 8.0) / 128.0 } @@ -66,10 +124,15 @@ impl DensitySampler for EndIslandSampler { ) -> Result<(), SampleError> { check_buffer(buffer, volume)?; let [sx, sy, sz] = volume.sizes(); + let islands = self.volume_islands(volume); for z in 0..sz { let block_z = volume.block(Axis::Z, z).unwrap(); for x in 0..sx { - let value = self.density(volume.block(Axis::X, x).unwrap(), block_z); + let block_x = volume.block(Axis::X, x).unwrap(); + let value = match &islands { + Some(islands) => Self::density_from_islands(block_x, block_z, islands), + None => self.density(block_x, block_z), + }; let start = (x + z * sx) * sy; buffer[start..start + sy].fill(value); } @@ -77,3 +140,78 @@ impl DensitySampler for EndIslandSampler { Ok(()) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn end_island_volumes_match_scalar_at_truncation_and_world_boundaries() { + let cases = [ + ([5, 3, 5], [0, -64, 0], [4, 8, 4]), + ([5, 3, 5], [1920, -64, 2240], [8, 8, 8]), + ([5, 3, 5], [-2049, -64, 3071], [4, 8, 4]), + ([5, 3, 5], [1023, -64, -1025], [1, 8, 1]), + ([5, 3, 5], [30_000_000, 0, -30_000_000], [8, 1, 8]), + ([5, 3, 5], [i32::MIN, 0, i32::MIN], [8, 1, 8]), + ([5, 3, 5], [i32::MAX - 32, 0, i32::MAX - 32], [8, 1, 8]), + // Also exercise wrapping, wide, sparse and single-column volumes. + ([5, 3, 5], [i32::MAX - 12, 0, i32::MAX - 3], [8, 1, 8]), + ([5, 3, 5], [4096, 0, -8192], [1024, 1, 1024]), + ([2, 3, 2], [-4096, 0, 8192], [599, 1, 599]), + ([1, 4, 1], [-15, 0, -17], [1, 1, 1]), + ]; + for seed in [0, 12345, -1, i64::MIN, i64::MAX] { + let sampler = EndIslandSampler::new(seed); + let mut context = SamplerContext::default(); + let mut compare = |volume: DensityVolume| { + let sentinel = 123.0_f32; + let mut output = vec![sentinel; volume.size() + 1]; + sampler + .sample_volume(&mut context, &mut output, volume) + .unwrap(); + visit(volume, |index, position| { + let expected = sampler.sample_value(&mut context, position)?; + assert_eq!( + output[index].to_bits(), + expected.to_bits(), + "seed {seed}, position {position:?}, volume {volume:?}" + ); + Ok(()) + }) + .unwrap(); + assert_eq!(output[volume.size()], sentinel); + let mut short = vec![sentinel; volume.size() - 1]; + assert_eq!( + sampler.sample_volume(&mut context, &mut short, volume), + Err(DensityError::BufferTooShort.into()) + ); + assert!(short.iter().all(|&value| value == sentinel)); + }; + for (sizes, minimum, steps) in cases { + compare(DensityVolume::new(sizes, minimum, steps).unwrap()); + } + // Every signed remainder around both coordinate divisions, in a + // neighborhood that straddles the central-island exclusion circle. + for offset in -17..=17 { + compare( + DensityVolume::new([5, 2, 5], [1024 + offset, -32, -offset], [3, 16, 5]) + .unwrap(), + ); + } + } + let sampler = EndIslandSampler::new(12345); + assert!( + sampler + .volume_islands(DensityVolume::new([5, 2, 5], [-2049, 0, 3071], [4, 8, 4]).unwrap()) + .is_some() + ); + for (sizes, minimum, steps) in [cases[7], cases[8], cases[10]] { + assert!( + sampler + .volume_islands(DensityVolume::new(sizes, minimum, steps).unwrap()) + .is_none() + ); + } + } +}