From 4218a496b2756bb9f9261bb4025b6f1a9711c582 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 14:40:28 -0400 Subject: [PATCH 01/19] Preserve ominous banner components through placement and drops --- crates/horizon-client/src/containers.rs | 2 + crates/horizon-client/src/game/spill.rs | 74 +++++++++++++++++++++++-- crates/horizon-client/src/save.rs | 12 +++- 3 files changed, 81 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index 46e73f067..9cdac1463 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -132,6 +132,8 @@ impl Crafter { pub struct Banner { pub layers: Vec, pub name: Option, + /// Components not consumed by BannerBlockEntity's implicit fields. + pub components: horizon_world::nbt::Compound, } /// `CreakingHeartBlockEntity` (the logic is in `game/creaking.rs`). #[derive(Clone, Debug, Default)] diff --git a/crates/horizon-client/src/game/spill.rs b/crates/horizon-client/src/game/spill.rs index ac508dfb8..5f10622f5 100644 --- a/crates/horizon-client/src/game/spill.rs +++ b/crates/horizon-client/src/game/spill.rs @@ -6,6 +6,7 @@ use super::{Game, GameLevel, Screen, dispenser::new_item_motion, storage::is_shulker_box}; use horizon_client::{ containers::{Banner, BlockEntity}, + item_data, items::ItemStack, }; use horizon_core::position::BlockPos; @@ -15,6 +16,7 @@ use horizon_world::{ LevelEvent, removal::{self, PreRemove}, }, + nbt::{JavaString, Tag}, registry::BlockStateId, }; use std::collections::HashMap; @@ -80,14 +82,37 @@ impl Pending { stack.data_mut().pot_decorations = Some(Box::new(sides)); } if stack.item.ends_with("_banner") - && let Some(Banner { layers, name }) = self.banner.remove(&pos) + && let Some(Banner { + layers, + name, + components, + }) = self.banner.remove(&pos) { - let data = stack.data_mut(); - data.banner_patterns = layers; - if name.is_some() { - data.custom_name = name; + let mut patch = match item_data::encode_components(stack) { + Some(Tag::Compound(c)) => c, + _ => Default::default(), + }; + // The remaining components in the banner loot table's copy_components. + for key in [ + "minecraft:item_name", + "minecraft:rarity", + "minecraft:tooltip_display", + ] { + if let Some(value) = components.get(&JavaString::from(key)) { + patch.insert(key.into(), value.clone()); + } } - stack.tidy(); + patch.insert( + "minecraft:banner_patterns".into(), + horizon_client::banner::layers_to_nbt(&layers), + ); + if let Some(name) = name { + patch.insert( + "minecraft:custom_name".into(), + Tag::String(name.as_str().into()), + ); + } + (stack.damage, stack.extra) = item_data::decode_components(Some(&Tag::Compound(patch))); } } /// Remember a decorated pot's sherds from its saved block entity. @@ -553,3 +578,40 @@ impl Game<'_> { } } } + +#[cfg(test)] +mod tests { + use super::*; + use horizon_client::{block_entity_item, item_data, mobs::raider, save}; + use horizon_world::nbt::Tag; + + #[test] + fn ominous_banner_survives_placement_save_and_drop() { + let original = raider::ominous_banner(); + let Tag::Compound(components) = item_data::encode_components(&original).unwrap() else { + panic!("banner components"); + }; + for block in ["minecraft:white_banner", "minecraft:white_wall_banner"] { + let pos = (1, 64, 2); + let fresh = BlockEntity::for_block(block).unwrap(); + let fresh = save::encode_block_entity(pos, &fresh, block); + let placed = block_entity_item::place(&fresh, &components, false); + let (_, placed) = save::decode_block_entity(&placed).unwrap(); + let saved = save::encode_block_entity(pos, &placed, block); + let (_, loaded) = save::decode_block_entity(&saved).unwrap(); + let BlockEntity::Banner(banner) = &loaded else { + panic!("placed banner"); + }; + assert_eq!(banner.layers.len(), item_data::OMINOUS_LAYERS.len()); + let mut pending = Pending::default(); + pending.record([pos.0, pos.1, pos.2], &loaded, block, None); + let mut dropped = ItemStack::new("minecraft:white_banner", 1); + pending.attach([pos.0, pos.1, pos.2], &mut dropped); + assert!(dropped.data().unwrap().ominous_banner); + assert_eq!( + item_data::encode_components(&dropped), + Some(Tag::Compound(components.clone())) + ); + } + } +} diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index a3ee81912..61317c8aa 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -449,13 +449,17 @@ pub fn encode_block_entity( block: &str, ) -> Tag { use crate::containers::BlockEntity; + let components = match e { + BlockEntity::Banner(b) => b.components.clone(), + _ => Compound::new(), + }; let mut entries = vec![ ("id", string(&block_entity_id(e, block))), ("x", Tag::Int(p.0)), ("y", Tag::Int(p.1)), ("z", Tag::Int(p.2)), ("keepPacked", Tag::Byte(0)), - ("components", Tag::Compound(Compound::new())), + ("components", Tag::Compound(components)), ]; match e { BlockEntity::Chest(items) => entries.push(("Items", encode_items(items))), @@ -583,6 +587,10 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain BlockEntity::Banner(crate::containers::Banner { layers: crate::banner::layers_from_nbt(tag.get("patterns")), name: text(tag.get("CustomName")), + components: match tag.get("components") { + Some(Tag::Compound(c)) => c.clone(), + _ => Compound::new(), + }, }), )); } @@ -2984,6 +2992,7 @@ mod tests { let banner = crate::containers::Banner { layers: vec![crate::banner::BannerLayer::new("minecraft:creeper", "lime")], name: Some("Flag".into()), + components: [("minecraft:rarity".into(), string("uncommon"))].into(), }; let tag = encode_block_entity( (1, 2, 3), @@ -2997,6 +3006,7 @@ mod tests { }; assert_eq!(back.layers, banner.layers); assert_eq!(back.name, banner.name); + assert_eq!(back.components, banner.components); } use super::*; From a2cce7486ddb847d5455894e7e7f00ef75fa76c7 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 20:48:50 +0200 Subject: [PATCH 02/19] Villagers search an index of POI blocks instead of scanning every block AcquirePoi (job sites, beds, meeting points) and the bed searches read every block of the sections in a 48-block sphere. Like vanilla's PoiManager, each section now keeps the list of its POI blocks, rebuilt from its blocks after an edit (a weak reference detects edited and replaced sections). The searches visit the same positions in the same order. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/lib.rs | 1 + .../horizon-client/src/mobs/villager_brain.rs | 108 ++++++-------- crates/horizon-client/src/poi_sections.rs | 134 ++++++++++++++++++ crates/horizon-client/src/world.rs | 3 + 4 files changed, 185 insertions(+), 61 deletions(-) create mode 100644 crates/horizon-client/src/poi_sections.rs diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index b56891996..0e37214b0 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -130,6 +130,7 @@ pub mod particles; pub mod patrol; pub mod perf_overlay; pub mod pick_item; +pub mod poi_sections; pub mod pose; pub mod post; pub mod projectiles; diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs index 942afd233..5b8500c0d 100644 --- a/crates/horizon-client/src/mobs/villager_brain.rs +++ b/crates/horizon-client/src/mobs/villager_brain.rs @@ -924,8 +924,35 @@ fn tickets(m: &Mob, w: &MobWorld, p: [i32; 3]) -> usize { } n } +/// 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 +/// are visited (`PoiManager.getInChunk`). +fn chunk_pois( + w: &MobWorld, + (qx, qz): (i32, i32), + y0: i32, + y1: i32, + mut visit: impl FnMut(Poi, [i32; 3]), +) { + let Some(chunk) = w.world.chunks.get(&(qx, qz)) else { + return; + }; + let kind = |state: u32| poi_of_state(w, horizon_world::registry::BlockStateId(state)); + let min = crate::chunk::MIN_Y; + for s in (y0 - min) >> 4..=(y1 - min) >> 4 { + let section = &chunk.sections[s as usize]; + for &(i, poi) in w.world.pois.get((qx, s, qz), section, kind).iter() { + let i = i32::from(i); + let y = min + s * 16 + (i >> 8); + if (y0..=y1).contains(&y) { + visit(poi, [qx * 16 + (i & 15), y, qz * 16 + (i >> 4 & 15)]); + } + } + } +} /// `PoiManager.getInRange` with `HAS_SPACE`, nearest first (`distSqr` to the -/// block, ties in scan order), filtered by `accept`. +/// block, ties in scan order: chunk by chunk, z then x, and y, z, x within), +/// filtered by `accept`. fn pois_in_range( m: &Mob, w: &MobWorld, @@ -940,62 +967,24 @@ fn pois_in_range( let chunks = radius.div_euclid(16) + 1; let y0 = (c[1] - radius).max(crate::chunk::MIN_Y); let y1 = (c[1] + radius).min(crate::chunk::MIN_Y + crate::chunk::HEIGHT - 1); - // Sections whose palette holds no POI state are skipped whole, as - // PoiManager only visits sections with records: the same positions in - // the same order, without reading and naming every block of the sphere. - let kind = |state: u32| poi_of_state(w, horizon_world::registry::BlockStateId(state)); for qz in cz - chunks..=cz + chunks { for qx in cx - chunks..=cx + chunks { - let Some(chunk) = w.world.chunks.get(&(qx, qz)) else { - continue; - }; - let holds: Vec = chunk - .sections - .iter() - .map(|s| s.blocks.maybe_has(|v| kind(v).is_some())) - .collect(); - for y in y0..=y1 { - if !holds[((y - crate::chunk::MIN_Y) >> 4) as usize] { - continue; + chunk_pois(w, (qx, qz), y0, y1, |poi, p| { + if (p[0] - c[0]).abs() > radius + || (p[2] - c[2]).abs() > radius + || dist_sqr(p, c) > r2 + || !poi_matches(m, f, poi) + || tickets(m, w, p) >= poi.max_tickets() + { + return; } - for z in qz * 16..qz * 16 + 16 { - for x in qx * 16..qx * 16 + 16 { - if (x - c[0]).abs() > radius || (z - c[2]).abs() > radius { - continue; - } - let d = i64::from(x - c[0]).pow(2) - + i64::from(y - c[1]).pow(2) - + i64::from(z - c[2]).pow(2); - if d > r2 { - continue; - } - let state = chunk.block(x & 15, y, z & 15); - if w.facts.is_air(state) { - continue; - } - let Some(poi) = kind(state.0) else { - continue; - }; - if !poi_matches(m, f, poi) { - continue; - } - let p = [x, y, z]; - if tickets(m, w, p) >= poi.max_tickets() { - continue; - } - if accept(p) { - found.push((poi, p)); - } - } + if accept(p) { + found.push((poi, p)); } - } + }); } } - found.sort_by_key(|(_, p)| { - i64::from(p[0] - c[0]).pow(2) - + i64::from(p[1] - c[1]).pow(2) - + i64::from(p[2] - c[2]).pow(2) - }); + found.sort_by_key(|&(_, p)| dist_sqr(p, c)); found } /// `PoiManager.exists(pos, predicate)`. @@ -3389,26 +3378,23 @@ fn dist_sqr(a: [i32; 3], b: [i32; 3]) -> i64 { manhattan_sq(a, b) } /// Every bed head within `radius` (`PoiManager.getInRange(HOME, ..., ANY)`), -/// in scan order. +/// in the order of a scan of the cube: y, then z, then x. fn homes_in_range(m: &Mob, w: &MobWorld, radius: i32) -> Vec<[i32; 3]> { let c = block_of(m.position); let r2 = i64::from(radius) * i64::from(radius); let mut out = Vec::new(); let y0 = (c[1] - radius).max(crate::chunk::MIN_Y); let y1 = (c[1] + radius).min(crate::chunk::MIN_Y + crate::chunk::HEIGHT - 1); - for y in y0..=y1 { - for z in c[2] - radius..=c[2] + radius { - for x in c[0] - radius..=c[0] + radius { - let p = [x, y, z]; - if dist_sqr(p, c) <= r2 - && w.world.loaded(x, z) - && poi_at(w, x, y, z) == Some(Poi::Home) - { + for qz in (c[2] - radius) >> 4..=(c[2] + radius) >> 4 { + for qx in (c[0] - radius) >> 4..=(c[0] + radius) >> 4 { + chunk_pois(w, (qx, qz), y0, y1, |poi, p| { + if poi == Poi::Home && dist_sqr(p, c) <= r2 { out.push(p); } - } + }); } } + out.sort_unstable_by_key(|p| (p[1], p[2], p[0])); out } /// `MoveToSkySeeingSpot.hasNoBlocksAbove`. diff --git a/crates/horizon-client/src/poi_sections.rs b/crates/horizon-client/src/poi_sections.rs new file mode 100644 index 000000000..2116362e0 --- /dev/null +++ b/crates/horizon-client/src/poi_sections.rs @@ -0,0 +1,134 @@ +//! The points of interest of each resident section (`PoiSection`), so a +//! search visits the few POI blocks of the sections in range instead of +//! reading every block of them. +//! +//! Vanilla keeps its records up to date from `onBlockStateChange`; here a +//! section's list is rebuilt from its blocks after any edit. Resident +//! sections are immutable behind `Arc` and edited through `Arc::make_mut`, so +//! a weak reference tells an edited or replaced section from the one the list +//! was built from (see `random_tick_sections`), without keeping its blocks. +use crate::{chunk::Section, fast_hash::FxHashMap}; +use std::sync::{Arc, Mutex, Weak}; + +/// A section's POIs: the block index in the section (`y << 8 | z << 4 | x`) +/// and its kind, in ascending index order. +pub type SectionPois = Arc<[(u16, T)]>; + +struct Cached { + section: Weak
, + pois: SectionPois, +} +/// Cached POI lists by section, `(chunk x, section index, chunk z)`. +pub struct PoiSections { + sections: Mutex>, +} +struct Lists { + by_section: FxHashMap<(i32, i32, i32), Cached>, + /// Size above which lists of sections no longer resident are dropped. + prune_at: usize, +} +const MIN_PRUNE: usize = 4096; +impl Default for PoiSections { + fn default() -> Self { + Self { + sections: Mutex::new(Lists { + by_section: FxHashMap::default(), + prune_at: MIN_PRUNE, + }), + } + } +} +impl PoiSections { + /// The POIs of `section`, whose block states `kind` classifies. `kind` + /// must give the same answer for a state on every call. + pub fn get( + &self, + key: (i32, i32, i32), + section: &Arc
, + mut kind: impl FnMut(u32) -> Option, + ) -> SectionPois { + let mut lists = self.sections.lock().unwrap_or_else(|e| e.into_inner()); + if let Some(cached) = lists.by_section.get(&key) + && cached.section.as_ptr() == Arc::as_ptr(section) + { + return cached.pois.clone(); + } + let pois: SectionPois = if section.blocks.maybe_has(|v| kind(v).is_some()) { + let mut states = [0u16; 4096]; + section.unpack(&mut states); + states + .iter() + .enumerate() + .filter_map(|(i, &state)| kind(u32::from(state)).map(|poi| (i as u16, poi))) + .collect() + } else { + Arc::from([]) + }; + if lists.by_section.len() >= lists.prune_at { + lists.by_section.retain(|_, c| c.section.strong_count() > 0); + lists.prune_at = (lists.by_section.len() * 2).max(MIN_PRUNE); + } + lists.by_section.insert( + key, + Cached { + section: Arc::downgrade(section), + pois: pois.clone(), + }, + ); + pois + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::chunk::{Chunk, MIN_Y}; + + #[test] + fn lists_follow_edits_and_replacement() { + let index = PoiSections::::default(); + let kind = |v: u32| (v == 5 || v == 6).then_some(v as u8); + let mut chunk = Arc::new(Chunk::empty(0, 0)); + assert!(index.get((0, 0, 0), &chunk.sections[0], kind).is_empty()); + Arc::make_mut(&mut chunk).set(3, MIN_Y + 2, 1, 6); + Arc::make_mut(&mut chunk).set(0, MIN_Y, 0, 5); + let found = index.get((0, 0, 0), &chunk.sections[0], kind); + assert_eq!(&*found, &[(0, 5), (2 << 8 | 1 << 4 | 3, 6)]); + // Unchanged: the cached list, not a rescan. + let again = index.get((0, 0, 0), &chunk.sections[0], |_| panic!("rescanned")); + assert!(Arc::ptr_eq(&found, &again)); + // An edit in place (no other owner) still invalidates the list. + Arc::make_mut(&mut chunk).set(0, MIN_Y, 0, 1); + assert_eq!( + &*index.get((0, 0, 0), &chunk.sections[0], kind), + &[(2 << 8 | 1 << 4 | 3, 6)] + ); + // So does replacing the section, or the chunk. + Arc::make_mut(&mut chunk).sections[0] = Arc::new(Section::default()); + assert!(index.get((0, 0, 0), &chunk.sections[0], kind).is_empty()); + let mut other = Chunk::empty(0, 0); + other.set(1, MIN_Y, 1, 5); + chunk = Arc::new(other); + assert_eq!( + &*index.get((0, 0, 0), &chunk.sections[0], kind), + &[(1 << 4 | 1, 5)] + ); + // An unused palette entry alone yields no POI. + Arc::make_mut(&mut chunk).set(1, MIN_Y, 1, 2); + assert!(index.get((0, 0, 0), &chunk.sections[0], kind).is_empty()); + } + + #[test] + fn unloaded_sections_are_dropped() { + let index = PoiSections::::default(); + let kind = |v: u32| (v == 5).then_some(5); + let kept = Arc::new(Section::default()); + index.get((0, 0, 0), &kept, kind); + for i in 0..MIN_PRUNE as i32 { + index.get((1, i, 0), &Arc::new(Section::default()), kind); + } + let lists = index.sections.lock().unwrap(); + assert!(lists.by_section.len() <= 2); + assert!(lists.by_section.contains_key(&(0, 0, 0))); + } +} diff --git a/crates/horizon-client/src/world.rs b/crates/horizon-client/src/world.rs index 2d8213905..44e442ec1 100644 --- a/crates/horizon-client/src/world.rs +++ b/crates/horizon-client/src/world.rs @@ -46,6 +46,8 @@ pub struct World { /// Every block position written since the log was last drained, kept /// only while the world is open to the network (see `lan`). pub block_log: Option>, + /// The villager POIs of each section (`PoiManager`'s sections). + pub pois: crate::poi_sections::PoiSections, } /// ServerLevel weather state (advanceWeatherCycle). #[derive(Clone, Copy, Debug, Default)] @@ -130,6 +132,7 @@ impl World { day_time: 1000, weather: Weather::default(), block_log: None, + pois: Default::default(), } } /// A controlled blockstate scene for the native scene probes: material From 8f86098a02ffb3101fa35bcf1cff6a14b8bb3582 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 15:07:19 -0400 Subject: [PATCH 03/19] Show ominous banner names and rarity in HUD and Creative tooltips --- crates/horizon-client/src/game.rs | 10 +++--- crates/horizon-client/src/game/spill.rs | 8 +++++ crates/horizon-client/src/game/stations.rs | 16 +++------ crates/horizon-client/src/game/titles.rs | 21 ++++------- crates/horizon-client/src/item_tooltip.rs | 42 ++++++++++++++++++++++ 5 files changed, 66 insertions(+), 31 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 7072abeb5..c65c00d25 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -7999,7 +7999,7 @@ impl Game<'_> { self.creative_screen.search_focused.elapsed().as_millis(), ); } - let mut hovered: Option = None; + let mut hovered: Option = None; if tab.inventory { self.draw_player_preview( batch, @@ -8049,7 +8049,7 @@ impl Game<'_> { && self.cursor.1 < y + 16.0 { batch.fill(&self.res.atlas, x, y, 16.0, 16.0, rgba(255, 255, 255, 128)); - hovered = Some(stack.item.to_string()); + hovered = Some(stack.clone()); } } } @@ -8064,7 +8064,7 @@ impl Game<'_> { && self.cursor.1 >= y && self.cursor.1 < y + 16.0 { - hovered = Some(stack.item.to_string()); + hovered = Some(stack); } } let scrollable = self.creative_screen.rows(&self.res.names) > 5; @@ -8100,8 +8100,8 @@ impl Game<'_> { } else if self.carried.is_none() && let Some(item) = hovered { - let name = self.res.names.item(&item); - self.tooltip(batch, &name, self.cursor.0, self.cursor.1); + let lines = self.stack_tooltip(&item); + self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1); } self.draw_inventory_effects(batch, (ox, oy), Creative::WIDTH as i32); } diff --git a/crates/horizon-client/src/game/spill.rs b/crates/horizon-client/src/game/spill.rs index 5f10622f5..b64bcb9d7 100644 --- a/crates/horizon-client/src/game/spill.rs +++ b/crates/horizon-client/src/game/spill.rs @@ -608,6 +608,14 @@ mod tests { let mut dropped = ItemStack::new("minecraft:white_banner", 1); pending.attach([pos.0, pos.1, pos.2], &mut dropped); assert!(dropped.data().unwrap().ominous_banner); + assert_eq!( + horizon_client::item_tooltip::name_line(&dropped, &|_| None), + "Ominous Banner" + ); + assert_eq!( + horizon_client::item_tooltip::rarity(&dropped, "common"), + "uncommon" + ); assert_eq!( item_data::encode_components(&dropped), Some(Tag::Compound(components.clone())) diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs index d8a5d1416..1c253757d 100644 --- a/crates/horizon-client/src/game/stations.rs +++ b/crates/horizon-client/src/game/stations.rs @@ -1860,18 +1860,10 @@ impl Game<'_> { pub(super) fn stack_tooltip(&self, stack: &ItemStack) -> Vec<(String, u32)> { let e: &Enchantments = &self.res.stations.enchantments; let props = e.props(&stack.item); - let mut rarity = props.map_or("common", |p| p.rarity.as_str()); - // The ominous banner's rarity component. - if stack.data().is_some_and(|d| d.ominous_banner) { - rarity = "uncommon"; - } - if !stack.enchantments().is_empty() { - rarity = match rarity { - "common" | "uncommon" => "rare", - "rare" => "epic", - r => r, - }; - } + let rarity = horizon_client::item_tooltip::rarity( + stack, + props.map_or("common", |p| p.rarity.as_str()), + ); let color = match rarity { "uncommon" => rgba(255, 255, 85, 255), "rare" => rgba(85, 255, 255, 255), diff --git a/crates/horizon-client/src/game/titles.rs b/crates/horizon-client/src/game/titles.rs index 89e50c0d0..f0de6ad9e 100644 --- a/crates/horizon-client/src/game/titles.rs +++ b/crates/horizon-client/src/game/titles.rs @@ -6,6 +6,7 @@ use horizon_client::{ hud::HudBatch, hud_layout, hud_overlays::HeldName, + item_tooltip, text::{self, Text}, }; @@ -24,22 +25,14 @@ impl Game<'_> { fn held_name(&self) -> Option { let stack = self.inventory.get(self.selected)?.as_ref()?; let custom = stack.custom_name(); - // ItemStack.getRarity: enchanting raises common and uncommon to rare - // and rare to epic. - let mut rarity = self.item_rarity(&stack.item); - if !stack.enchantments().is_empty() { - rarity = match rarity.as_str() { - "common" | "uncommon" => "rare".into(), - "rare" => "epic".into(), - _ => rarity, - }; - } + let default_rarity = self.item_rarity(&stack.item); + let rarity = item_tooltip::rarity(stack, &default_rarity); Some(HeldName { item: stack.item.to_string(), - hover_name: Text::literal( - custom.map_or_else(|| self.res.names.item(&stack.item), str::to_owned), - ), - rarity_color: match rarity.as_str() { + hover_name: Text::literal(item_tooltip::name_line(stack, &|key| { + self.res.names.get(key).map(str::to_owned) + })), + rarity_color: match rarity { "uncommon" => text::YELLOW, "rare" => text::AQUA, "epic" => text::LIGHT_PURPLE, diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs index cd827d411..a039edfc5 100644 --- a/crates/horizon-client/src/item_tooltip.rs +++ b/crates/horizon-client/src/item_tooltip.rs @@ -102,6 +102,10 @@ pub fn name_line(stack: &ItemStack, translate: &dyn Fn(&str) -> Option) if let Some(name) = stack.custom_name() { return name.to_owned(); } + if stack.data().is_some_and(|d| d.ominous_banner) { + return translate("block.minecraft.ominous_banner") + .unwrap_or_else(|| "Ominous Banner".to_owned()); + } let key = if is_potion_item(&stack.item) { Some(crate::brewing::potion_name_key(&stack.item, stack.potion())) } else if let Some(pattern) = path.strip_suffix("_armor_trim_smithing_template") { @@ -120,6 +124,24 @@ pub fn name_line(stack: &ItemStack, translate: &dyn Fn(&str) -> Option) .unwrap_or_else(|| path.replace('_', " ")) } +/// ItemStack.getRarity: the ominous banner override, then the enchantment upgrade. +pub fn rarity<'a>(stack: &ItemStack, default: &'a str) -> &'a str { + let rarity = if stack.data().is_some_and(|d| d.ominous_banner) { + "uncommon" + } else { + default + }; + if stack.enchantments().is_empty() { + rarity + } else { + match rarity { + "common" | "uncommon" => "rare", + "rare" => "epic", + r => r, + } + } +} + /// The lines of `stack` below its name that its components give, in /// `ItemStack.addDetailsToTooltip` order. pub fn detail_lines( @@ -292,6 +314,26 @@ pub fn lines( mod tests { use super::*; + #[test] + fn ominous_banner_name_and_rarity_use_the_stack() { + let translate = |key: &str| match key { + "block.minecraft.ominous_banner" => Some("Ominous Banner".to_owned()), + "block.minecraft.white_banner" => Some("White Banner".to_owned()), + _ => None, + }; + let mut banner = crate::mobs::raider::ominous_banner(); + assert_eq!(name_line(&banner, &translate), "Ominous Banner"); + assert_eq!(name_line(&banner, &|_| None), "Ominous Banner"); + assert_eq!(rarity(&banner, "common"), "uncommon"); + banner.data_mut().custom_name = Some("Captain's Standard".into()); + assert_eq!(name_line(&banner, &translate), "Captain's Standard"); + banner.enchant("minecraft:unbreaking", 1); + assert_eq!(rarity(&banner, "common"), "rare"); + let plain = ItemStack::new("minecraft:white_banner", 1); + assert_eq!(name_line(&plain, &translate), "White Banner"); + assert_eq!(rarity(&plain, "common"), "common"); + } + #[test] fn container_lines_list_five_stacks_then_how_many_more() { let mut chest = ItemStack::new("minecraft:chest", 1); From 86ccd5d299b2752aca6c29cafd3d88601af9bf66 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 16:40:29 -0400 Subject: [PATCH 04/19] Render banner breaking cracks and oak-plank particles --- .../horizon-client/src/block_entity_render.rs | 155 +++++++++++++++++- crates/horizon-client/src/breaking.rs | 48 ++++++ crates/horizon-client/src/game.rs | 24 ++- crates/horizon-client/src/models/catalog.rs | 7 + 4 files changed, 227 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 9ffd888a1..85107c1cb 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -876,7 +876,7 @@ impl BlockEntityRenderer { .as_vec3(); let base = Mat4::from_translation(origin); let packed = scene.world.light(pos[0], pos[1], pos[2]); - self.render_one(scene, *pos, kind, base, packed, lights, out); + self.render_one(scene, *pos, kind, base, packed, lights, false, out); } } /// One block entity at `pos` drawn under `base` with the given packed light @@ -892,12 +892,39 @@ impl BlockEntityRenderer { ) { let kind = self.kind(state); let lights = diffuse_lights(scene.nether); - self.render_one(scene, pos, kind, base, packed, lights, out); + self.render_one(scene, pos, kind, base, packed, lights, false, out); } /// Whether this block state has a block-entity renderer here. pub fn renders(&self, state: u32) -> bool { !matches!(self.kind(state), Kind::None) } + /// BannerRenderer submits the support and animated flag once for crumbling. + pub fn render_banner_breaking( + &self, + scene: &Scene, + pos: [i32; 3], + state: u32, + out: &mut Vec, + ) { + if !matches!(self.kind(state), Kind::Banner { .. }) { + return; + } + let origin = (DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])) + - scene.camera) + .as_vec3(); + let start = out.len(); + self.render_one( + scene, + pos, + self.kind(state), + Mat4::from_translation(origin), + 0xff, + diffuse_lights(scene.nether), + true, + out, + ); + crate::breaking::entity_geometry(&mut out[start..], origin); + } /// `ChestRenderer.extractRenderState`'s openness for the chest of `state` /// at `pos`: `ChestBlock.combine` (`DoubleBlockCombiner.combineWithNeigbour`) /// pairs a double half with its neighbour only when that is the same @@ -970,7 +997,7 @@ impl BlockEntityRenderer { let kind = self.kind(state); if !matches!(kind, Kind::None) { let lights = diffuse_lights(scene.nether); - self.render_one(scene, [i32::MAX; 3], kind, base, packed, lights, out); + self.render_one(scene, [i32::MAX; 3], kind, base, packed, lights, false, out); } } #[allow(clippy::too_many_arguments)] @@ -982,11 +1009,24 @@ impl BlockEntityRenderer { base: Mat4, packed: u8, lights: (Vec3, Vec3), + crumbling: bool, out: &mut Vec, ) { let sprite = |name: &str| scene.sprites.get(name).copied(); let paint = |name: &str, tint: u32, packed: u8| { - sprite(name).map(|s| Paint { + let rect = if crumbling { + Some(Rect { + u0: 0.0, + v0: 0.0, + u1: 1.0, + v1: 1.0, + w: 16, + h: 16, + }) + } else { + sprite(name) + }; + rect.map(|s| Paint { sprite: s, tint, light: vertex_light(packed), @@ -1145,6 +1185,10 @@ impl BlockEntityRenderer { draw_part(main, "root", m, &none, paint, out); draw_part(flag, "root", m, &wave, paint, out); } + // Pattern passes must not multiply the crumbling decal. + if crumbling { + return; + } // BannerRenderer.submitPatterns: the base pattern layer in the dye colour, // then up to 16 pattern layers in order. if let Some(paint) = paint("entity/banner/base", *color, packed) { @@ -1673,6 +1717,109 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec) #[cfg(test)] mod tests { use super::*; + #[test] + #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"] + fn banner_particle_and_breaking_use_exported_models() -> crate::Result<()> { + use crate::{models::catalog::StateModels, sprites::Sprites}; + use horizon_world::{DATA_VERSION, chunk::BlockState, nbt::Tag}; + let root = std::path::PathBuf::from( + std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"), + ); + let names = ["white_banner", "white_wall_banner"]; + let mut facts: std::collections::BTreeMap = + serde_json::from_slice(&std::fs::read(root.join("model-states.json"))?)?; + let states = names.map(|name| { + let name = format!("minecraft:{name}"); + let first = facts[&name]["states"][0].clone(); + facts.get_mut(&name).unwrap()["states"] = serde_json::json!([first.clone()]); + BlockState { + name, + properties: serde_json::from_value(first).unwrap(), + } + .to_nbt() + }); + let registry = BlockRegistry::from_nbt(&Tag::compound([ + ("DataVersion", Tag::Int(DATA_VERSION)), + ("states", Tag::List(states.into())), + ( + "defaults", + Tag::compound([ + ("minecraft:white_banner", Tag::Int(0)), + ("minecraft:white_wall_banner", Tag::Int(1)), + ]), + ), + ]))?; + let mut sprites = Sprites::default(); + let catalog = StateModels::from_facts(&root, ®istry, &names, &mut sprites, &facts)?; + for id in 0..2 { + let models = catalog.collect( + BlockStateId(id), + horizon_core::position::BlockPos::default(), + )?; + assert!(models.iter().all(|(_, model)| model.faces.is_empty())); + assert_eq!( + models[0].1.particle, + Some(sprites.layers["minecraft:block/oak_planks"]) + ); + } + let all: Value = serde_json::from_slice(&std::fs::read(root.join("entity-models.json"))?)?; + let renderer = BlockEntityRenderer::new( + MODELS + .iter() + .filter_map(|(key, layer)| all.get(*layer).map(|v| (*key, ModelPart::parse(v)))) + .collect(), + ®istry, + ); + let world = World::new(BlockStateId(0), 1); + let base_sprites = HashMap::from([( + "entity/banner/banner_base".to_owned(), + Rect { + u0: 0.0, + v0: 0.0, + u1: 1.0, + v1: 1.0, + w: 16, + h: 16, + }, + )]); + let mut scene = Scene { + camera: DVec3::ZERO, + orientation: Quat::IDENTITY, + anim: &|_| BlockAnim::default(), + texts: None, + partial: 0.5, + game_time: 0, + max_y: 320, + world: &world, + sprites: &base_sprites, + nether: false, + lid: &|_| 0.0, + sign: &|_| None, + banner: &|_| Vec::new(), + glyph: &|_| (None, 0.0), + }; + for state in 0..2 { + let mut base = Vec::new(); + renderer.render_block(&scene, [0; 3], state, Mat4::IDENTITY, 0xff, &mut base); + let mut cracks = Vec::new(); + renderer.render_banner_breaking(&scene, [0; 3], state, &mut cracks); + assert!(!cracks.is_empty()); + assert_eq!( + base.iter().map(|v| v.pos).collect::>(), + cracks.iter().map(|v| v.pos).collect::>() + ); + assert!(cracks.iter().all(|v| v.layer == 11 + && v.color == u32::MAX + && v.uv.iter().all(|u| u.is_finite()))); + scene.game_time = 20; + let mut animated = Vec::new(); + renderer.render_banner_breaking(&scene, [0; 3], state, &mut animated); + assert!(cracks.iter().zip(&animated).any(|(a, b)| a.pos != b.pos)); + scene.game_time = 0; + } + Ok(()) + } + #[test] fn classifies_vanilla_block_names() { let props = |pairs: &'static [(&'static str, &'static str)]| { diff --git a/crates/horizon-client/src/breaking.rs b/crates/horizon-client/src/breaking.rs index 9dc948ae3..c7ee19206 100644 --- a/crates/horizon-client/src/breaking.rs +++ b/crates/horizon-client/src/breaking.rs @@ -41,6 +41,35 @@ pub fn geometry(model: &BakedModel, origin: glam::Vec3, translucent: bool, out: } } +/// Project a block entity's transformed quads onto the same destroy-stage pass. +pub fn entity_geometry(vertices: &mut [Vertex], origin: glam::Vec3) { + for quad in vertices.as_chunks_mut::<4>().0 { + let positions = [0, 1, 2].map(|i| glam::Vec3::from(quad[i].pos)); + let normal = (positions[1] - positions[0]).cross(positions[2] - positions[0]); + let mut facing = Direction::North; + let mut best = f32::from_bits(1); + for (direction, dot) in [ + (Direction::Down, -normal.y), + (Direction::Up, normal.y), + (Direction::North, -normal.z), + (Direction::South, normal.z), + (Direction::West, -normal.x), + (Direction::East, normal.x), + ] { + if dot > best { + facing = direction; + best = dot; + } + } + for vertex in quad { + vertex.uv = decal_uv((glam::Vec3::from(vertex.pos) - origin).to_array(), facing); + vertex.layer = 11; + vertex.color = 0xffff_ffff; + vertex.light = 240 | (240 << 8); + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -49,6 +78,7 @@ mod tests { fn slab_top() -> BakedModel { BakedModel { ambient_occlusion: true, + particle: None, cube: None, faces: vec![BakedFace { layer: 0, @@ -86,6 +116,24 @@ mod tests { assert_eq!(v.color, 0xffff_ffff); } } + #[test] + fn entity_overlay_uses_block_local_projected_uvs() { + let origin = glam::Vec3::new(12.0, -3.0, 8.0); + let mut expected = Vec::new(); + geometry(&slab_top(), origin, false, &mut expected); + let mut actual = expected.clone(); + for vertex in &mut actual { + vertex.uv = [0.0; 2]; + vertex.layer = 0; + vertex.color = 0; + } + entity_geometry(&mut actual, origin); + assert_eq!( + bytemuck::cast_slice::<_, u8>(&actual), + bytemuck::cast_slice::<_, u8>(&expected) + ); + } + #[test] fn small_faces_use_projected_not_stretched_uvs() { let a = decal_uv([0.0, 0.0, 0.0], Direction::North); diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index c65c00d25..21f59af94 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1377,9 +1377,13 @@ impl Game<'_> { .iter() .flat_map(|(_, m)| m.faces.iter()) .find(|f| f.quad.facing == horizon_assets::model::Direction::Up) - .or_else(|| models.iter().flat_map(|(_, m)| m.faces.iter()).next())?; - let name = self.res.layer_names.get(&face.layer)?.clone(); - let tint = if face.quad.tint_index >= 0 { + .or_else(|| models.iter().flat_map(|(_, m)| m.faces.iter()).next()); + // Entity-rendered blocks may have a particle texture without any faces. + let layer = face + .map(|face| face.layer) + .or_else(|| models.iter().find_map(|(_, model)| model.particle))?; + let name = self.res.layer_names.get(&layer)?.clone(); + let tint = if face.is_some_and(|face| face.quad.tint_index >= 0) { let n = &self.res.facts.get(state).name; if n.contains("leaves") || n.contains("vine") { 0x48B518 @@ -5515,6 +5519,20 @@ impl Game<'_> { .block_entity_render .render(&scene, visible, &mut out); } + if let Some(mining) = &self.mining + && mining.progress > 0.0 + && self.res.atlas.sprites.contains_key(&format!( + "block/destroy_stage_{}", + ((mining.progress * 10.0) as u32).min(9) + )) + { + let state = self + .world + .block(mining.pos[0], mining.pos[1], mining.pos[2]); + self.res + .block_entity_render + .render_banner_breaking(&scene, mining.pos, state.0, &mut out); + } } // Experience orbs (ExperienceOrbRenderer): pulsing billboards from a 4x4 icon sheet. if let Some(r) = self diff --git a/crates/horizon-client/src/models/catalog.rs b/crates/horizon-client/src/models/catalog.rs index 59a885821..abb9e6c50 100644 --- a/crates/horizon-client/src/models/catalog.rs +++ b/crates/horizon-client/src/models/catalog.rs @@ -34,6 +34,8 @@ pub struct BakedFace { } pub struct BakedModel { pub ambient_occlusion: bool, + /// The model's particle slot also exists for models without block faces. + pub particle: Option, pub faces: Vec, pub cube: Option<[super::cube::CubeStyle; 6]>, } @@ -188,6 +190,10 @@ impl StateModels { let mut baked = BTreeMap::new(); for (name, turns, lock) in variants { let model = library.resolve(&name)?; + let particle = model + .material("particle")? + .map(|material| sprites.insert(root, &material.sprite)) + .transpose()?; let faces: Vec = bake_block_model(&model, BlockModelTransform::new(turns, lock))? .into_iter() @@ -207,6 +213,7 @@ impl StateModels { (name, turns, lock), BakedModel { ambient_occlusion: model.ambient_occlusion, + particle, faces, cube, }, From 53955abf99941128c2c263cd046deb0a92958957 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 16:56:14 -0400 Subject: [PATCH 05/19] Hide ominous banner pattern descriptions in tooltips --- crates/horizon-client/src/banner.rs | 26 ++++++++++++++++++++++ crates/horizon-client/src/game/spill.rs | 1 + crates/horizon-client/src/game/stations.rs | 2 +- 3 files changed, 28 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/banner.rs b/crates/horizon-client/src/banner.rs index d2bc33fba..861294722 100644 --- a/crates/horizon-client/src/banner.rs +++ b/crates/horizon-client/src/banner.rs @@ -199,6 +199,14 @@ pub fn dye_rgb(name: &str) -> u32 { pub fn layers(stack: &ItemStack) -> &[BannerLayer] { stack.data().map_or(&[], |d| &d.banner_patterns) } +/// The ominous banner's component patch hides its pattern tooltip. +pub fn tooltip_layers(stack: &ItemStack) -> &[BannerLayer] { + if stack.data().is_some_and(|d| d.ominous_banner) { + &[] + } else { + layers(stack) + } +} /// `LoomMenu.setupResultSlot`: one banner with the pattern added in the dye colour. pub fn loom_result(banner: &ItemStack, dye: &str, pattern: &str) -> ItemStack { let mut result = ItemStack { @@ -302,6 +310,24 @@ mod tests { } assert!(has_max_layers(&banner)); } + #[test] + fn ominous_banner_hides_tooltip_layers_but_keeps_its_patterns() { + let mut banner = crate::mobs::raider::ominous_banner(); + (banner.damage, banner.extra) = crate::item_data::decode_components( + crate::item_data::encode_components(&banner).as_ref(), + ); + assert_eq!( + layers(&banner).len(), + crate::item_data::OMINOUS_LAYERS.len() + ); + assert!(tooltip_layers(&banner).is_empty()); + banner.data_mut().custom_name = Some("Captain's Standard".into()); + assert!(tooltip_layers(&banner).is_empty()); + banner.data_mut().ominous_banner = false; + assert_eq!(tooltip_layers(&banner), layers(&banner)); + assert!(!tooltip_layers(&banner).is_empty()); + } + #[test] fn layers_round_trip_through_nbt() { let l = vec![ diff --git a/crates/horizon-client/src/game/spill.rs b/crates/horizon-client/src/game/spill.rs index b64bcb9d7..20dcdf0de 100644 --- a/crates/horizon-client/src/game/spill.rs +++ b/crates/horizon-client/src/game/spill.rs @@ -608,6 +608,7 @@ mod tests { let mut dropped = ItemStack::new("minecraft:white_banner", 1); pending.attach([pos.0, pos.1, pos.2], &mut dropped); assert!(dropped.data().unwrap().ominous_banner); + assert!(horizon_client::banner::tooltip_layers(&dropped).is_empty()); assert_eq!( horizon_client::item_tooltip::name_line(&dropped, &|_| None), "Ominous Banner" diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs index 1c253757d..5e8952901 100644 --- a/crates/horizon-client/src/game/stations.rs +++ b/crates/horizon-client/src/game/stations.rs @@ -1944,7 +1944,7 @@ impl Game<'_> { )); } // BannerPatternLayers.addToTooltip: up to six layer names. - for layer in horizon_client::banner::layers(stack).iter().take(6) { + for layer in horizon_client::banner::tooltip_layers(stack).iter().take(6) { let key = self.res.stations.banners.layer_key(layer); lines.push((self.translate(&key, &key), rgba(170, 170, 170, 255))); } From bd0dd979a014f68fdc43188ef1dcdfbfc3b98186 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 23:45:06 +0200 Subject: [PATCH 06/19] Integrated server: build only the font, not the whole HUD atlas The integrated server draws nothing, but it built the window's full HUD atlas (GUI, item, block, entity and particle textures plus the run-time slots). It now builds an atlas of the font sheets only, reads the glyph widths from it and drops the pixels: text still measures the same (books split their pages with it), without holding the textures. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/integrated.rs | 3 +- crates/horizon-client/src/hud.rs | 149 ++++++++++++++----- 2 files changed, 110 insertions(+), 42 deletions(-) diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index 6edbb6e40..30b9ff23f 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -282,7 +282,8 @@ fn serve( flags: &Flags, ready: &Sender>, ) -> Result<()> { - let atlas = HudAtlas::build(&options.resources)?; + // It draws nothing: only the font, which books and chat measure with. + let atlas = HudAtlas::fonts(&options.resources)?; let audio = Audio::silent(&options.resources); let mut server = Game::new(res, pack, atlas, options, settings, audio)?; server.run_integrated(launch, flags, ready) diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 77ba0e342..c42f8c8bc 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -139,19 +139,74 @@ impl HudAtlas { (g.rect, g.advance) } pub fn build(root: &Path) -> Result { + Self::pack( + root, + &[ + "gui", + "item", + "block", + "font", + "environment", + "misc", + "painting", + "entity", + "particle", + "mob_effect", + "map", + ], + true, + ) + } + /// Empty slots written at run time: map textures (game/maps.rs), the + /// minimap, downloaded skins, world icons and the Horizon menu text. + fn slots(images: &mut Vec) { + for i in 0..MAP_SLOTS { + images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4])); + } + // The minimap extra's image (game/extras.rs). + images.push(( + MINIMAP_SPRITE.into(), + crate::minimap::SIZE as u32, + crate::minimap::SIZE as u32, + vec![0; crate::minimap::SIZE * crate::minimap::SIZE * 4], + )); + // Downloaded skins (game/scoreboard.rs). + for i in 0..SKIN_SLOTS { + images.push((format!("horizon/skin{i}"), 64, 64, vec![0; 64 * 64 * 4])); + } + for i in 0..WORLD_ICON_SLOTS { + images.push(( + format!("horizon/world-icon{i}"), + 64, + 64, + vec![0; 64 * 64 * 4], + )); + } + // Horizon-style menu text and corner masks (ui_theme), rasterized at run time. + images.push(( + "horizon/ui-text".into(), + 2048, + 1024, + vec![0; 2048 * 1024 * 4], + )); + } + /// Only the font's metrics, for a game that draws nothing (the + /// integrated server): text measures as with the full atlas, without + /// holding its textures. The pixels are dropped once the glyph widths are + /// read, since nothing uploads them. + pub fn fonts(root: &Path) -> Result { + let mut atlas = Self::pack(root, &["font"], false)?; + atlas.pixels = Vec::new(); + Ok(atlas) + } + /// Pack the textures under these folders of `textures/`, and for the + /// `full` atlas the generated sprites and the run-time slots too. + fn pack(root: &Path, folders: &[&str], full: bool) -> Result { let textures = root.join("assets/minecraft/textures"); let mut files = Vec::new(); - walk(&textures.join("gui"), &mut files); - walk(&textures.join("item"), &mut files); - walk(&textures.join("block"), &mut files); - walk(&textures.join("font"), &mut files); - walk(&textures.join("environment"), &mut files); - walk(&textures.join("misc"), &mut files); - walk(&textures.join("painting"), &mut files); - walk(&textures.join("entity"), &mut files); - walk(&textures.join("particle"), &mut files); - walk(&textures.join("mob_effect"), &mut files); - walk(&textures.join("map"), &mut files); + for folder in folders { + walk(&textures.join(folder), &mut files); + } files.retain(|p| { let s = p.to_string_lossy(); !s.contains("title/background") && !s.contains("realms") && !s.contains("presets") @@ -187,7 +242,9 @@ impl HudAtlas { .flat_map(|h| h.join().unwrap_or_default()) .collect() }); - images.extend(atlas_sprites(root, &images)); + if full { + images.extend(atlas_sprites(root, &images)); + } // The title screen's "JAVA EDITION" banner reads "RUST EDITION". if let Some(edition) = images .iter_mut() @@ -198,36 +255,9 @@ impl HudAtlas { edition.3 = pixels; } images.push(("horizon/white".into(), 4, 4, vec![255; 64])); - // Map textures (game/maps.rs) are written into these slots at run time. - for i in 0..MAP_SLOTS { - images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4])); + if full { + Self::slots(&mut images); } - // The minimap extra's image (game/extras.rs). - images.push(( - MINIMAP_SPRITE.into(), - crate::minimap::SIZE as u32, - crate::minimap::SIZE as u32, - vec![0; crate::minimap::SIZE * crate::minimap::SIZE * 4], - )); - // Downloaded skins (game/scoreboard.rs) likewise. - for i in 0..SKIN_SLOTS { - images.push((format!("horizon/skin{i}"), 64, 64, vec![0; 64 * 64 * 4])); - } - for i in 0..WORLD_ICON_SLOTS { - images.push(( - format!("horizon/world-icon{i}"), - 64, - 64, - vec![0; 64 * 64 * 4], - )); - } - // Horizon-style menu text and corner masks (ui_theme), rasterized at run time. - images.push(( - "horizon/ui-text".into(), - 2048, - 1024, - vec![0; 2048 * 1024 * 4], - )); images.sort_by(|a, b| b.2.cmp(&a.2).then(b.1.cmp(&a.1))); let width = 4096u32; let mut placements = Vec::with_capacity(images.len()); @@ -1023,6 +1053,43 @@ impl HudRenderer { mod tests { use super::*; + #[test] + fn the_fonts_only_atlas_measures_text_like_the_full_one() { + // A synthetic default font: two 8x8 glyphs, 3 and 5 pixels wide. + let root = std::env::temp_dir().join(format!("horizon-fonts-atlas-{}", std::process::id())); + let font = root.join("assets/minecraft/font"); + let textures = root.join("assets/minecraft/textures/font"); + fs::create_dir_all(&font).unwrap(); + fs::create_dir_all(&textures).unwrap(); + fs::write( + font.join("default.json"), + r#"{"providers":[{"type":"bitmap","file":"minecraft:font/test.png","ascent":7,"chars":["ab"]}]}"#, + ) + .unwrap(); + let mut pixels = vec![0u8; 16 * 8 * 4]; + for y in 0..8 { + for x in (0..3).chain(8..13) { + pixels[(y * 16 + x) * 4 + 3] = 255; + } + } + let mut encoder = + png::Encoder::new(fs::File::create(textures.join("test.png")).unwrap(), 16, 8); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + encoder + .write_header() + .unwrap() + .write_image_data(&pixels) + .unwrap(); + let full = HudAtlas::build(&root).unwrap(); + let fonts = HudAtlas::fonts(&root).unwrap(); + let _ = fs::remove_dir_all(&root); + assert!(fonts.pixels.is_empty()); + let width = full.font.width("abba"); + assert!(width > 0.0); + assert_eq!(fonts.font.width("abba"), width); + } + #[test] fn effect_icons_are_painted_from_the_mob_effect_directory() { use crate::{effects::EffectInstance, hud_layout, hud_overlays, inventory_effects}; From 30d11d6a2e87cb5cf4e64ec1c19d04be9f0fddc5 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 23:45:19 +0200 Subject: [PATCH 07/19] Integrated server: single-player pause menu labels On its server thread a single-player world is joined like a server, so the Horizon pause menu named it "Multiplayer" with a "Disconnect" button, and F3+Escape opened the full menu as on a server. The server thread now hands the window the world's name with its connection, the pause menu shows that name and "Save and quit", and `has_singleplayer_server` (Minecraft.hasSingleplayerServer) covers both ways of running a world for the pause checks. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 2 +- crates/horizon-client/src/game/debug_keys.rs | 2 +- crates/horizon-client/src/game/integrated.rs | 25 ++++++++++++++++---- crates/horizon-client/src/game/screens.rs | 17 ++++++------- 4 files changed, 29 insertions(+), 17 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 6b1c09b60..4429a88cb 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3643,7 +3643,7 @@ impl Game<'_> { } /// `Minecraft.pause`: a single-player game with a pausing screen open. fn pauses_game(&self) -> bool { - (self.remote.is_none() || self.integrated.is_some()) + self.has_singleplayer_server() && self.lan.is_none() && self.title.is_none() && (matches!( diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index 3aac02ae7..4008c33d9 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -38,7 +38,7 @@ impl DebugHost for Host<'_, '_> { // the menu as it always has (key_pressed). let g = &mut *self.game; if without_menu && g.screen == Screen::Playing { - g.pause_menu = !(g.remote.is_none() && g.lan.is_none()); + g.pause_menu = !(g.has_singleplayer_server() && g.lan.is_none()); g.screen = Screen::Paused; g.capture(false); g.mining = None; diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index 30b9ff23f..0366627e3 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -45,6 +45,8 @@ struct Flags { pub(super) struct Integrated { flags: Arc, thread: Option>, + /// The world's name (`level.dat`'s `LevelName`), for the pause menu. + pub world_name: String, } impl Integrated { /// `IntegratedServer.tickServer` skips the world while the game is paused. @@ -68,6 +70,10 @@ impl Drop for Integrated { } } +/// What the server thread hands the window once the world is open: its end +/// of the connection and the world's name, or why it failed. +type Ready = std::result::Result<(Pipe, String), String>; + /// The world to open and the player who owns it. struct Launch { folder: String, @@ -88,6 +94,11 @@ pub(super) fn wanted(options: &Options, world: &Path) -> bool { } impl Game<'_> { + /// `Minecraft.hasSingleplayerServer`: a world of this window's own, run + /// in the frame or on its server thread. + pub(super) fn has_singleplayer_server(&self) -> bool { + self.remote.is_none() || self.integrated.is_some() + } /// `Minecraft.doWorldLoad`: start the server thread on the world, wait /// until it can be joined, then join it through memory. pub(super) fn open_integrated( @@ -145,12 +156,16 @@ impl Game<'_> { let _ = ready_tx.send(Err(e.to_string())); } })?; - let handle = Integrated { + let mut handle = Integrated { flags, thread: Some(thread), + world_name: String::new(), }; let pipe = match ready.recv() { - Ok(Ok(pipe)) => pipe, + Ok(Ok((pipe, world_name))) => { + handle.world_name = world_name; + pipe + } Ok(Err(e)) => return Err(e.into()), Err(_) => return Err("the integrated server stopped".into()), }; @@ -165,7 +180,7 @@ impl Game<'_> { &mut self, launch: Launch, flags: &Flags, - ready: &Sender>, + ready: &Sender, ) -> Result<()> { self.open_world( &launch.folder, @@ -223,7 +238,7 @@ impl Game<'_> { }); host.hub.lan.connect_local()? }; - let _ = ready.send(Ok(pipe)); + let _ = ready.send(Ok((pipe, self.level.name.clone()))); self.settle_spawn()?; let mut next = Instant::now(); while !flags.stop.load(Ordering::Relaxed) { @@ -280,7 +295,7 @@ fn serve( settings: Settings, launch: Launch, flags: &Flags, - ready: &Sender>, + ready: &Sender, ) -> Result<()> { // It draws nothing: only the font, which books and chat measure with. let atlas = HudAtlas::fonts(&options.resources)?; diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index ac4d16274..0e0d63c23 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -60,17 +60,14 @@ impl Game<'_> { && horizon_client::ui_theme::horizon() } fn pause_labels(&self) -> (String, &'static str) { - let world = if self.remote.is_some() { - "Multiplayer".to_owned() + if let Some(server) = &self.integrated { + return (server.world_name.clone(), "Save and quit"); + } + if self.remote.is_some() { + ("Multiplayer".to_owned(), "Disconnect") } else { - self.level.name.clone() - }; - let quit = if self.remote.is_some() { - "Disconnect" - } else { - "Save and quit" - }; - (world, quit) + (self.level.name.clone(), "Save and quit") + } } pub(super) fn draw_pause_menu(&mut self, batch: &mut HudBatch) { if horizon_client::ui_theme::horizon() { From a71d148ca5a63b06543089aa686466cd34854cd2 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 00:22:53 +0200 Subject: [PATCH 08/19] Network players have status effects A player who joins over the network, which is now single player's own player on its server thread, had no status effects: what they drank, ate or were given went to the host, and their client never heard of any. - Each guest has their own effects. `as_guest` trades them, and what their body was given for them (attribute modifiers, armor protection, enchantment modifiers), with the host's while the guest acts. - They tick on the server with the guest's body (LivingEntity.baseTick's tickEffects), spectators included. - The client is told as vanilla's ServerPlayer does: every effect when placed (PlayerList.sendActivePlayerEffects), then added (blended), updated, refreshed every 600 ticks left, and removed. An effect that only counted down is not sent again. - The client keeps its own effects from those packets (LivingEntity.forceAddEffect), counts them down (tickClient), and its predicted movement, HUD icons and night vision follow them. A respawn starts without effects on both sides. - Guests save and load them in their player file. Saving also stops writing effects that have run out: the loaded player compound kept the old `active_effects`, and they came back on reopen. Potions in flight now tick on a server without a local player too. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/effects.rs | 41 +++++++ crates/horizon-client/src/game.rs | 16 +-- crates/horizon-client/src/game/lan_actions.rs | 33 +++++- crates/horizon-client/src/game/potions.rs | 49 ++++++-- crates/horizon-client/src/game/remote.rs | 36 ++++++ crates/horizon-client/src/lan/guest.rs | 18 +++ crates/horizon-client/src/lan/hub.rs | 108 +++++++++++++++++- crates/horizon-client/src/lan/playerdata.rs | 2 + crates/horizon-client/src/save.rs | 16 +++ 9 files changed, 288 insertions(+), 31 deletions(-) diff --git a/crates/horizon-client/src/effects.rs b/crates/horizon-client/src/effects.rs index 71a9377ed..2e600333a 100644 --- a/crates/horizon-client/src/effects.rs +++ b/crates/horizon-client/src/effects.rs @@ -68,6 +68,14 @@ impl EffectInstance { } changed } + /// `MobEffectInstance.tickClient`: a client counts its effects down + /// (the server removes them). + pub fn tick_client(&mut self) { + if self.infinite() || self.duration > 0 { + self.tick_down(); + self.downgrade(); + } + } fn tick_down(&mut self) { if let Some(h) = self.hidden.as_mut() { h.tick_down(); @@ -170,6 +178,39 @@ impl PlayerEffects { pub fn clear(&mut self) { self.list.clear(); } + /// The effects of a saved player (`Player.active_effects`: id, + /// duration, amplifier, ambient, visible). + pub fn from_saved(saved: &[(String, i32, i32, bool, bool)]) -> Self { + let mut effects = Self::default(); + for (id, duration, amplifier, ambient, _) in saved { + if let Some(def) = brewing::effect(id) { + let mut e = EffectInstance::new(def.id, *duration, *amplifier); + e.ambient = *ambient; + effects.add(e); + } + } + effects + } + /// `Player.active_effects` for the save. + pub fn saved(&self) -> Vec<(String, i32, i32, bool, bool)> { + self.list + .iter() + .map(|e| { + ( + format!("minecraft:{}", e.id), + e.duration, + e.amplifier, + e.ambient, + e.visible, + ) + }) + .collect() + } + /// ClientboundUpdateMobEffectPacket's flags without blending: ambient, + /// particles visible and the icon shown (always, for these effects). + pub fn flags(e: &EffectInstance) -> i8 { + i8::from(e.ambient) | i8::from(e.visible) << 1 | 4 + } /// `LivingEntity.tickEffects` (server part) with the omens' effect ticks: /// `omen` answers `BadOmenMobEffect` (every tick) and `RaidOmenMobEffect` /// (on its last tick). Returns the actions to apply, in order, and diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 4429a88cb..e03c71a48 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -8313,21 +8313,7 @@ impl Game<'_> { self.ender_items = items.clone(); } level.ender_items = self.ender_items.clone(); - level.active_effects = self - .potions - .effects - .list - .iter() - .map(|e| { - ( - format!("minecraft:{}", e.id), - e.duration, - e.amplifier, - e.ambient, - e.visible, - ) - }) - .collect(); + level.active_effects = self.potions.effects.saved(); } fn save_game(&mut self) -> Result<()> { self.save_game_with(true) diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 6bf76f160..1f6921e0c 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -43,6 +43,8 @@ pub(super) struct GuestPlay { pub(super) merchant: Option, /// The inventory menu and the crafting table the guest crafts in. pub(super) crafting: super::lan_crafting::GuestCrafting, + /// What the guest's body was given for its effects and enchantments. + potions: super::potions::BodyPotions, } struct ItemRules<'a>(&'a horizon_client::items::Items); @@ -92,7 +94,11 @@ impl Game<'_> { let mut play = host.play.remove(&conn).unwrap_or_default(); let g = &mut host.hub.guests[i]; // The guest's body. - let mut motion = g.motion.take()?; + let Some(mut motion) = g.motion.take() else { + host.play.insert(conn, play); + return None; + }; + self.potions.swap_player(&mut g.effects, &mut play.potions); motion.position = Vec3::new(g.position[0], g.position[1], g.position[2]); motion.ground.on_ground = g.on_ground; motion.yaw = g.yaw; @@ -188,6 +194,7 @@ impl Game<'_> { } let g = &mut host.hub.guests[i]; std::mem::swap(&mut self.ender_items, &mut g.ender_items); + self.potions.swap_player(&mut g.effects, &mut play.potions); if let Some(key) = host_ender { self.world .block_entities @@ -759,6 +766,10 @@ impl Game<'_> { g.saturation = 5.0; g.sent_health = None; g.motion = None; + // A new body: nothing given to the old one carries over. + if let Some(play) = host.play.get_mut(&conn) { + play.potions = Default::default(); + } host.hub.respawn(i, spawn); } @@ -846,12 +857,17 @@ impl Game<'_> { g.moves_from_ground }; if g.spectator() { + // Spectators' effects still run (LivingEntity.baseTick). + if !g.effects.list.is_empty() { + self.as_guest(host, conn, |game| game.tick_mob_effects()); + } return; } let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height()); let at = g.position; let sounds = self.as_guest(host, conn, |game| { - let (rules, health) = (game.world.health_rules, &game.motion.health); + let (rules, motion) = (game.world.health_rules, game.motion); + let health = &motion.health; let Some(player) = game.player.as_mut() else { return Vec::new(); }; @@ -889,9 +905,16 @@ impl Game<'_> { let _ = w.tick_environment_damage(); let _ = w.apply_fire_contact(); let _ = w.server_hazards_tick(in_wall); - let _ = w.player.peaceful_regeneration(rules); - let _ = w.player.food_tick(health, rules); - std::mem::take(&mut w.player.events) + let mut events = std::mem::take(&mut w.player.events); + // LivingEntity.baseTick ends with tickEffects. + game.tick_mob_effects(); + let Some(player) = game.player.as_mut() else { + return Vec::new(); + }; + let _ = player.peaceful_regeneration(rules); + let _ = player.food_tick(health, rules); + events.append(&mut player.events); + events .into_iter() .filter_map(|e| match e { MotionEvent::HurtSound(sound) => Some(sound), diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index fbc8556e7..a60926256 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -49,6 +49,14 @@ impl Game<'_> { }); } } +/// What a player's body was last given for its effects and enchantments: +/// a guest keeps their own while the host's are in `PotionState`. +#[derive(Default)] +pub(super) struct BodyPotions { + applied: Vec<(&'static str, &'static str, f64, &'static str)>, + protection_for: Option>>, + enchant_modifiers: Vec<(String, String, f64, String)>, +} /// Effects, thrown potions and the attribute modifiers last applied. #[derive(Default)] pub(super) struct PotionState { @@ -63,6 +71,14 @@ pub(super) struct PotionState { } impl PotionState { + /// Trade the player's own state (effects and what their body was given) + /// with a guest's, around `as_guest`. Potions in flight stay. + pub(super) fn swap_player(&mut self, effects: &mut PlayerEffects, body: &mut BodyPotions) { + std::mem::swap(&mut self.effects, effects); + std::mem::swap(&mut self.applied, &mut body.applied); + std::mem::swap(&mut self.protection_for, &mut body.protection_for); + std::mem::swap(&mut self.enchant_modifiers, &mut body.enchant_modifiers); + } /// Thrown potions in flight as (entity type, position, motion), for the /// dispenser parity fixture. pub(super) fn thrown_entities(&self) -> Vec<(&'static str, Vec3, Vec3)> { @@ -274,8 +290,16 @@ impl Game<'_> { } } } - /// `LivingEntity.tickEffects`, attribute modifiers and the status flags. + /// The local player's effects (`tick_mob_effects`), then the potions + /// in flight, which a server without a local player still has. pub(super) fn tick_effects(&mut self) { + self.tick_mob_effects(); + self.tick_thrown_potions(); + } + /// `LivingEntity.tickEffects` (server side) for `self.player`, the local + /// player or a guest acting (`as_guest`), then its attribute modifiers + /// and status flags. + pub(super) fn tick_mob_effects(&mut self) { let Some(player) = self.player.as_ref() else { return; }; @@ -294,6 +318,20 @@ impl Game<'_> { for action in actions { self.apply_effect_action(action); } + self.apply_effect_status(); + } + /// A client's own effects (`LivingEntity.tickEffects` on the client, + /// `MobEffectInstance.tickClient`): they count down, and the server + /// removes them. Their modifiers and flags move the predicted player. + pub(super) fn tick_client_effects(&mut self) { + for e in &mut self.potions.effects.list { + e.tick_client(); + } + self.apply_effect_status(); + } + /// The effects' attribute modifiers, armor protection and status flags + /// on `self.player`. + fn apply_effect_status(&mut self) { let modifiers = self.potions.effects.modifiers(); if modifiers != self.potions.applied && let Some(p) = self.player.as_mut() @@ -346,7 +384,6 @@ impl Game<'_> { status.protection = std::mem::take(&mut p.status.protection); p.status = status; } - self.tick_thrown_potions(); } fn tick_thrown_potions(&mut self) { let mut thrown = std::mem::take(&mut self.potions.thrown); @@ -606,13 +643,7 @@ impl Game<'_> { /// Effects saved in level.dat (`Player.active_effects`). pub(super) fn restore_effects(&mut self) { self.potions = PotionState::default(); - for (id, duration, amplifier, ambient, _) in self.level.active_effects.clone() { - if let Some(def) = brewing::effect(&id) { - let mut e = EffectInstance::new(def.id, duration, amplifier); - e.ambient = ambient; - self.potions.effects.add(e); - } - } + self.potions.effects = PlayerEffects::from_saved(&self.level.active_effects); } pub(super) fn effects_json(&self) -> serde_json::Value { serde_json::json!({ diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index e31e270b8..8e4e973f2 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -366,6 +366,31 @@ impl Game<'_> { .unwrap_or("minecraft:air"), ) } + /// A mob effect's network id as the effect (`brewing::EFFECTS` id). + fn remote_effect_id(&self, effect: i32) -> Option<&'static str> { + let r = self.remote.as_ref()?; + let name = r.builtin.get("minecraft:mob_effect")?.name(effect)?; + horizon_client::brewing::effect(name).map(|d| d.id) + } + /// ClientPacketListener.handleUpdateMobEffect for the player itself + /// (`LivingEntity.forceAddEffect`): the effect replaces any of its kind. + /// Other entities' effects are not shown. + fn remote_effect(&mut self, p: &play::UpdateMobEffect) { + if !self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) { + return; + } + let Some(id) = self.remote_effect_id(p.effect) else { + return; + }; + let mut e = horizon_client::effects::EffectInstance::new(id, p.duration, p.amplifier); + e.ambient = p.flags & 1 != 0; + e.visible = p.flags & 2 != 0; + let list = &mut self.potions.effects.list; + match list.iter_mut().find(|x| x.id == id) { + Some(existing) => *existing = e, + None => list.push(e), + } + } fn item_id(&self, name: &str) -> i32 { let r = self.remote.as_ref().expect("remote"); r.builtin @@ -806,6 +831,8 @@ impl Game<'_> { )); } C::Respawn(p) => { + // A new player, without effects: the server sends them again. + self.potions.effects.clear(); self.enter_remote_dimension(&p.spawn, true); self.screen = Screen::Playing; if let Some(r) = self.remote.as_mut() { @@ -1120,6 +1147,14 @@ impl Game<'_> { } } C::Animate(p) if p.action == 0 => {} + C::UpdateMobEffect(p) => self.remote_effect(&p), + C::RemoveMobEffect(p) => { + if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) + && let Some(id) = self.remote_effect_id(p.effect) + { + self.potions.effects.list.retain(|e| e.id != id); + } + } C::SetHealth(p) => { if let Some(r) = self.remote.as_mut() { r.health = (p.health, p.food, p.saturation); @@ -1789,6 +1824,7 @@ impl Game<'_> { self.tick_block_entity_anims(); self.tick_hand(); self.tick_particles(); + self.tick_client_effects(); let ghast_collisions = self.happy_ghast_player_collisions(); let Some(player) = self.player.as_mut() else { return Ok(()); diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 954ffc714..243c90d18 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -18,6 +18,16 @@ pub const CREATIVE: i32 = 1; pub const ADVENTURE: i32 = 2; pub const SPECTATOR: i32 = 3; +/// An effect as last sent in ClientboundUpdateMobEffectPacket. +#[derive(Clone, Debug, PartialEq)] +pub struct SentEffect { + pub id: &'static str, + pub amplifier: i32, + pub flags: i8, + pub duration: i32, + pub tick_count: i32, +} + pub struct Guest { pub conn: u32, /// The client's address (IP bans, `list`). @@ -92,6 +102,12 @@ pub struct Guest { pub xp_level: i32, pub xp_progress: f32, pub xp_total: i32, + /// Active status effects (`LivingEntity.activeEffects`). + pub effects: crate::effects::PlayerEffects, + /// What the client was told of each effect: id, amplifier, flags, and + /// the duration and `effects.tick_count` at the time, so a duration that + /// only counted down is not sent again (`ServerPlayer.onEffectUpdated`). + pub sent_effects: Vec, /// What the client believes the inventory menu holds (for change detection). pub menu_sent: Vec>, pub menu_state: i32, @@ -174,6 +190,8 @@ impl Guest { xp_level: 0, xp_progress: 0.0, xp_total: 0, + effects: Default::default(), + sent_effects: Vec::new(), menu_sent: vec![None; 46], menu_state: 0, sent_health: None, diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index fcae7c097..3f1f88c4a 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -9,9 +9,13 @@ use super::{ chunks::ChunkEncoder, data::SyncData, entity::EntityState, - guest::{Guest, stack_to_network}, + guest::{Guest, SentEffect, stack_to_network}, +}; +use crate::{ + effects::{EffectInstance, PlayerEffects}, + items::ItemStack, + world::World, }; -use crate::{items::ItemStack, world::World}; use horizon_protocol::ids::play::clientbound as ids; use horizon_protocol::{ entity_data::{Value, serializer}, @@ -553,11 +557,106 @@ impl Hub { })); g.center_sent = Some((cx, cz)); g.placed_at = self.ticks; + self.send_active_effects(i); // ServerPlayer.sendPostEffects and initInventoryMenu. self.guests[i].send(&raw(ids::POST_EFFECTS, vec![0])); self.send_inventory(i); } + /// ClientboundUpdateMobEffectPacket for one of the guest's effects. + fn send_effect(&mut self, i: usize, e: &EffectInstance, blend: bool) -> Option { + let effect = self + .sync + .id("minecraft:mob_effect", &format!("minecraft:{}", e.id))?; + let flags = PlayerEffects::flags(e); + let g = &self.guests[i]; + g.send(&C::UpdateMobEffect(play::UpdateMobEffect { + id: g.entity_id, + effect, + amplifier: e.amplifier, + duration: e.duration, + flags: flags | if blend { 8 } else { 0 }, + })); + Some(SentEffect { + id: e.id, + amplifier: e.amplifier, + flags, + duration: e.duration, + tick_count: g.effects.tick_count, + }) + } + + /// PlayerList.sendActivePlayerEffects: every effect, unblended, when the + /// player is placed (or respawns). + pub fn send_active_effects(&mut self, i: usize) { + let effects = self.guests[i].effects.list.clone(); + let sent = effects + .iter() + .filter_map(|e| self.send_effect(i, e, false)) + .collect(); + self.guests[i].sent_effects = sent; + } + + /// ServerPlayer.onEffectAdded (blended), onEffectUpdated and + /// onEffectsRemoved, from what changed since the client was told: an + /// effect that only counted down is not sent again, except at every + /// 600 ticks left (`LivingEntity.tickEffects`). + fn sync_effects(&mut self, i: usize) { + let g = &self.guests[i]; + if g.effects.list.is_empty() && g.sent_effects.is_empty() { + return; + } + let now = g.effects.tick_count; + let mut sent = Vec::with_capacity(g.effects.list.len()); + let mut changes = Vec::new(); + for e in &g.effects.list { + match g.sent_effects.iter().find(|s| s.id == e.id) { + None => changes.push((e.clone(), true)), + Some(s) => { + let ticked = now.wrapping_sub(s.tick_count); + let expected = if s.duration == -1 { + -1 + } else { + s.duration - ticked + }; + let refresh = ticked > 0 && e.duration > 0 && e.duration % 600 == 0; + if s.amplifier != e.amplifier + || s.flags != PlayerEffects::flags(e) + || e.duration != expected + || refresh + { + changes.push((e.clone(), false)); + } else { + sent.push(s.clone()); + } + } + } + } + let removed: Vec<&'static str> = g + .sent_effects + .iter() + .filter(|s| g.effects.get(s.id).is_none()) + .map(|s| s.id) + .collect(); + for id in removed { + let Some(effect) = self + .sync + .id("minecraft:mob_effect", &format!("minecraft:{id}")) + else { + continue; + }; + let g = &self.guests[i]; + g.send(&C::RemoveMobEffect(play::RemoveMobEffect { + id: g.entity_id, + effect, + })); + } + for (e, added) in changes { + sent.extend(self.send_effect(i, &e, added)); + } + self.guests[i].sent_effects = sent; + } + /// PlayerList.sendPlayerPermissionLevel: the op level as an entity event /// (24 + level), then the commands that level may use. fn send_permission_level(&self, i: usize) { @@ -789,6 +888,7 @@ impl Hub { for i in 0..self.guests.len() { if self.guests[i].placed { self.sync_player_state(i); + self.sync_effects(i); } } let latencies: Vec<_> = self @@ -1559,6 +1659,10 @@ impl Hub { spawn: info, keep: 0, })); + // The respawned player is a new one, without effects; so is the + // client's (ClientPacketListener.handleRespawn). + g.effects = Default::default(); + g.sent_effects.clear(); g.center = None; g.sent_chunks.clear(); g.chunk_queue.clear(); diff --git a/crates/horizon-client/src/lan/playerdata.rs b/crates/horizon-client/src/lan/playerdata.rs index 3554463ea..d824683d2 100644 --- a/crates/horizon-client/src/lan/playerdata.rs +++ b/crates/horizon-client/src/lan/playerdata.rs @@ -66,6 +66,7 @@ pub fn apply(guest: &mut Guest, level: &Level) { guest.xp_level = level.xp_level; guest.xp_progress = level.xp_progress; guest.xp_total = level.xp_total; + guest.effects = crate::effects::PlayerEffects::from_saved(&level.active_effects); guest.game_mode = level.mode(); guest.selected = (level.selected_slot.max(0) as usize).min(8); guest.saved = level.player_extra.clone(); @@ -119,6 +120,7 @@ pub fn store(guest: &Guest, level: &mut Level) { level.xp_level = guest.xp_level; level.xp_progress = guest.xp_progress; level.xp_total = guest.xp_total; + level.active_effects = guest.effects.saved(); level.game_mode = guest.game_mode; level.creative = guest.game_mode == 1; level.selected_slot = guest.selected as i32; diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index a3ee81912..ab3489328 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -2361,6 +2361,7 @@ impl Level { "Inventory", "EnderItems", "equipment", + "active_effects", "Pos", "respawn", "recipeBook", @@ -3191,4 +3192,19 @@ mod tests { assert!(dir.join("data/minecraft/world_gen_settings.dat").exists()); let _ = fs::remove_dir_all(&dir); } + + #[test] + fn effects_that_ended_are_not_saved_again() { + // A player loaded with an effect that has since run out: the loaded + // compound still holds it, but the save writes only what is active. + let mut level = Level { + active_effects: vec![("minecraft:speed".into(), 200, 1, false, true)], + ..Level::default() + }; + let loaded = level.player_tag(); + assert!(loaded.get("active_effects").is_some()); + level.player_extra = Some(loaded); + level.active_effects.clear(); + assert!(level.player_tag().get("active_effects").is_none()); + } } From 361c994d98b44ae94edb8e8bc130022c8760dc72 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 00:23:01 +0200 Subject: [PATCH 09/19] Draw the columns vanilla draws: ChunkTrackingView.isInViewDistance MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Vanilla draws a section when its column is within the render distance of the camera's column with a column of slack on each axis (SectionOcclusionGraph.isInViewDistance → ChunkTrackingView): 533 columns at render distance 12. Horizon meshed a circle of radius 12 (441 columns) and drew sections whose centre lay within 16 x distance + 24 blocks, so the edge of the world, mostly in fog, missed columns vanilla shows, and fell short of vanilla's corners. `streaming::in_view_distance` is vanilla's test. Streaming meshes the columns it accepts around the player (and forced ones), and the renderer's column walk draws the ones it accepts around the camera. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 2 +- crates/horizon-client/src/gfx/resident.rs | 58 ++++++++++++----------- crates/horizon-client/src/streaming.rs | 49 ++++++++++++++++--- 3 files changed, 74 insertions(+), 35 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 4401ea22d..f64200e5c 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -2217,7 +2217,7 @@ impl Renderer { visible.clear(); self.sections.visible( camera, - frame.distance, + (frame.distance / 16.0) as i32, &view, |k| !culling || reachable.contains(k), &mut visible, diff --git a/crates/horizon-client/src/gfx/resident.rs b/crates/horizon-client/src/gfx/resident.rs index 58e187090..71e6a5527 100644 --- a/crates/horizon-client/src/gfx/resident.rs +++ b/crates/horizon-client/src/gfx/resident.rs @@ -3,7 +3,7 @@ //! the render distance rejects all of its sections with one test, and the //! sections that remain are reached by index rather than by hashing keys. use super::{Frustum, SectionKey}; -use crate::fast_hash::FxHashMap; +use crate::{fast_hash::FxHashMap, streaming::in_view_distance}; use glam::{DVec3, Vec3}; /// One chunk column's resident sections. @@ -149,26 +149,28 @@ fn origin(key: SectionKey, camera: DVec3) -> DVec3 { ) - camera } -/// Whether the section at `key` is drawn: within `distance` blocks of the -/// camera horizontally (plus a section and a half), and partly inside the -/// frustum. `None` when it is not, else its squared centre distance and origin. -fn in_view( - key: SectionKey, - camera: DVec3, - distance: f32, - frustum: &Frustum, -) -> Option<(f64, Vec3)> { - let origin = origin(key, camera); - let center = origin + DVec3::splat(8.0); - let horizontal = (center.x * center.x + center.z * center.z).sqrt(); - if horizontal > f64::from(distance) + 24.0 { +/// The camera's chunk column. +fn camera_column(camera: DVec3) -> (i32, i32) { + ( + (camera.x.floor() as i32) >> 4, + (camera.z.floor() as i32) >> 4, + ) +} + +/// Whether the section at `key` is drawn: its column within the render +/// distance of the camera's (`SectionOcclusionGraph.isInViewDistance`), and +/// partly inside the frustum. `None` when it is not, else its squared centre +/// distance and origin. +fn in_view(key: SectionKey, camera: DVec3, radius: i32, frustum: &Frustum) -> Option<(f64, Vec3)> { + if !in_view_distance(camera_column(camera), radius, key.0, key.2) { return None; } + let origin = origin(key, camera); let min = origin.as_vec3(); if !frustum.intersects(min, min + Vec3::splat(16.0)) { return None; } - Some((center.length_squared(), min)) + Some(((origin + DVec3::splat(8.0)).length_squared(), min)) } impl Resident { @@ -178,22 +180,22 @@ impl Resident { /// Columns are tested first, with the same distance test (it depends /// only on x and z) and a box spanning their sections: every section box /// lies inside it and the frustum test rounds monotonically, so a column - /// the frustum rejects holds no section it would accept. + /// the frustum rejects holds no section it would accept. `radius` is the + /// render distance in chunks. pub fn visible( &self, camera: DVec3, - distance: f32, + radius: i32, frustum: &Frustum, reachable: impl Fn(SectionKey) -> bool, out: &mut Vec, ) { + let from = camera_column(camera); for column in &self.columns { - let low = origin((column.x, column.low, column.z), camera); - let center = low + DVec3::splat(8.0); - if (center.x * center.x + center.z * center.z).sqrt() > f64::from(distance) + 24.0 { + if !in_view_distance(from, radius, column.x, column.z) { continue; } - let min = low.as_vec3(); + let min = origin((column.x, column.low, column.z), camera).as_vec3(); let top = origin((column.x, column.high, column.z), camera).as_vec3(); if !frustum.intersects(min, top + Vec3::splat(16.0)) { continue; @@ -203,7 +205,7 @@ impl Resident { if !reachable(key) { continue; } - if let Some((d, o)) = in_view(key, camera, distance, frustum) { + if let Some((d, o)) = in_view(key, camera, radius, frustum) { out.push(Visible { distance: d.to_bits(), key, @@ -243,20 +245,20 @@ mod tests { (DVec3::new(8.0, 64.0, 8.0), 45.0, 89.0), ]; for (camera, yaw, pitch) in cameras { - for distance in [32.0, 96.0, 160.0] { + for radius in [2, 6, 10] { let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0); let view = crate::camera::view_matrix(yaw, pitch); let frustum = Frustum { planes: super::super::frustum(projection * view), }; let mut fast = Vec::new(); - r.visible(camera, distance, &frustum, reachable, &mut fast); + r.visible(camera, radius, &frustum, reachable, &mut fast); let mut slow: Vec<(SectionKey, f64, [f32; 3])> = r .items .iter() .filter(|(k, _)| reachable(*k)) .filter_map(|(k, _)| { - in_view(*k, camera, distance, &frustum).map(|(d, o)| (*k, d, o.to_array())) + in_view(*k, camera, radius, &frustum).map(|(d, o)| (*k, d, o.to_array())) }) .collect(); slow.sort_unstable_by(|a, b| a.1.total_cmp(&b.1).then(a.0.cmp(&b.0))); @@ -268,7 +270,7 @@ mod tests { }) .collect(); assert!(!slow.is_empty()); - assert_eq!(fast, slow, "{camera} {yaw} {pitch} {distance}"); + assert_eq!(fast, slow, "{camera} {yaw} {pitch} {radius}"); } } } @@ -356,7 +358,7 @@ mod tests { let t = Instant::now(); keys.clear(); keys.extend(map.keys().filter_map(|&k| { - in_view(k, camera, 512.0, &frustum).map(|(d, o)| (k, d, o.to_array())) + in_view(k, camera, 32, &frustum).map(|(d, o)| (k, d, o.to_array())) })); keys.sort_unstable_by(|a, b| a.1.total_cmp(&b.1)); for (k, _, _) in &keys { @@ -365,7 +367,7 @@ mod tests { old = old.min(t.elapsed()); let t = Instant::now(); list.clear(); - r.visible(camera, 512.0, &frustum, |_| true, &mut list); + r.visible(camera, 32, &frustum, |_| true, &mut list); for v in &list { sum += i64::from(r.get(v.slot)[1] + r.get(v.slot)[0]); } diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index df1001640..994316324 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -968,7 +968,8 @@ impl Streaming { return (uploads, removed); } // Meshing once the column and its neighbours are lit, and the column - // is within the render distance. Sections set aside past it come back + // is within the render distance (`in_view_distance`, the columns + // vanilla draws). Sections set aside past it come back // when the player moves: a column that loads with its light gets no // other request (#228). let area = (self.center, self.radius, self.forced.len()); @@ -981,7 +982,7 @@ impl Streaming { forced: &self.forced, }; self.waiting.retain(|&(x, sy, z)| { - let back = ranges.in_main_range(x, z, 0); + let back = ranges.in_view(x, z); if back { world.dirty_sections.insert((x, sy, z)); } @@ -996,7 +997,7 @@ impl Streaming { world.dirty_sections.remove(&(x, sy, z)); continue; } - if !self.in_main_range(x, z, 0) { + if !self.ranges().in_view(x, z) { world.dirty_sections.remove(&(x, sy, z)); self.waiting.insert((x, sy, z)); continue; @@ -1204,9 +1205,15 @@ impl Streaming { fn in_range(&self, x: i32, z: i32, margin: i32) -> bool { self.ranges().in_range(x, z, margin) } - fn in_main_range(&self, x: i32, z: i32, margin: i32) -> bool { - self.ranges().in_main_range(x, z, margin) - } +} +/// `ChunkTrackingView.isInViewDistance`: whether the column (x, z) is drawn +/// at this render distance around `center`, the camera's column +/// (`SectionOcclusionGraph.isInViewDistance`). Each axis gets a column of +/// slack, so this reaches past the circle of `radius` columns. +pub fn in_view_distance(center: (i32, i32), radius: i32, x: i32, z: i32) -> bool { + let gap = |d: i32| i64::from((d.abs() - 1).max(0)); + let (dx, dz) = (gap(x - center.0), gap(z - center.1)); + dx * dx + dz * dz < i64::from(radius) * i64::from(radius) } /// The areas kept loaded: circles around the player and `extra`, and forced chunks. struct Ranges<'a> { @@ -1271,6 +1278,11 @@ impl Ranges<'_> { dx * dx + dz * dz <= r * r }) } + /// The columns meshed for drawing: those vanilla draws around the + /// player (`in_view_distance`), and forced ones. + fn in_view(&self, x: i32, z: i32) -> bool { + in_view_distance(self.center, self.radius, x, z) || self.forced.contains(&(x, z)) + } fn in_main_range(&self, x: i32, z: i32, margin: i32) -> bool { let r = i64::from(self.radius + margin); let (dx, dz) = (i64::from(x - self.center.0), i64::from(z - self.center.1)); @@ -1306,6 +1318,31 @@ impl Drop for Streaming { mod tests { use super::*; + #[test] + fn view_distance_is_vanillas_shape() { + // ChunkTrackingView.isInViewDistance at render distance 12: a column + // of slack on each axis, so 533 columns rather than the 441 of a + // circle of radius 12. + let count = |r: i32| { + (-40..=40) + .flat_map(|x| (-40..=40).map(move |z| (x, z))) + .filter(|&(x, z)| in_view_distance((5, -7), r, x + 5, z - 7)) + .count() + }; + assert_eq!(count(12), 533); + assert_eq!(count(2), 25); + for (x, z, inside) in [(12, 0, true), (13, 0, false), (9, 9, true), (10, 9, false)] { + assert_eq!(in_view_distance((0, 0), 12, x, z), inside, "({x}, {z})"); + assert_eq!( + in_view_distance((0, 0), 12, -z, -x), + inside, + "({}, {})", + -z, + -x + ); + } + } + struct GenerationFixture { world: World, center: (i32, i32), From dc42425c0197c5918ba3739d5aa20b8678af6199 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 01:33:24 +0200 Subject: [PATCH 10/19] Integrated server: Open to LAN Single player on its server thread could not be opened to the LAN: the window is a client of that server, and Open to LAN, /publish and `horizon-ctl lan` tried to start a second hub on the window's side. The server thread now publishes itself, as IntegratedServer.publishServer does: - The window asks its server with `Integrated::call` (executeBlocking): a task run between two ticks, while paused too, with its answer. - Publishing binds the port at once (a busy port fails right away), then the hub starts listening and announcing the world (LanServerPinger) with the MOTD " - ". Until then only the owner may log in; afterwards anyone may, and status pings are answered. - Unpublishing stops the listener and sends every player but the owner away (multiplayer.disconnect.server_shutdown). - /publish and /unpublish run on the server for the player who types them, and the integrated server's command tree (with publish, without the dedicated-only commands) is what its players get. - The owner's level follows Allow Commands; other players get game master commands only when guests may use commands and the world allows them (IntegratedServer.getCustomPermissionLevel). Every player's command runs at their own level. - The world options screen reads and applies its settings on the server: difficulty, default and personal game mode, Allow Commands and the LAN settings; the window shows the outcome. - A published world does not pause (Minecraft.pause needs !isPublished), and F3+Escape follows the same rule. - Memory connections are never compressed, whatever the threshold (Connection.isMemoryConnection), so network players get the usual 256. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/examples/lan_flat.rs | 1 + crates/horizon-client/src/game.rs | 5 +- .../horizon-client/src/game/commands/extra.rs | 26 +- crates/horizon-client/src/game/debug_keys.rs | 2 +- crates/horizon-client/src/game/dedicated.rs | 1 + crates/horizon-client/src/game/integrated.rs | 285 ++++++++++++++++-- crates/horizon-client/src/game/lan.rs | 122 +++++--- crates/horizon-client/src/game/lan_actions.rs | 25 ++ crates/horizon-client/src/game/lan_screen.rs | 86 ++++-- crates/horizon-client/src/lan/conn.rs | 3 +- crates/horizon-client/src/lan/hub.rs | 15 +- crates/horizon-client/src/lan/mod.rs | 113 ++++--- crates/horizon-client/tests/lan_bot.rs | 1 + crates/horizon-protocol/src/connection.rs | 4 + 14 files changed, 571 insertions(+), 118 deletions(-) diff --git a/crates/horizon-client/examples/lan_flat.rs b/crates/horizon-client/examples/lan_flat.rs index 63ea9f136..16fc36b95 100644 --- a/crates/horizon-client/examples/lan_flat.rs +++ b/crates/horizon-client/examples/lan_flat.rs @@ -88,6 +88,7 @@ fn main() -> Result<(), Box> { seed: 0, max_players: 8, dedicated: false, + integrated: false, }, ); let mut next_entity = 100u32; diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index e03c71a48..b63c29c29 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1085,6 +1085,8 @@ struct Game<'a> { lan: Option, /// Single player's server thread, which `remote` is connected to. integrated: Option, + /// This game is that server thread's (game/integrated.rs). + serving: Option, /// The open world is shared behind an invite code (game/friends.rs). friends: Option, world_options: Option, @@ -3644,7 +3646,7 @@ impl Game<'_> { /// `Minecraft.pause`: a single-player game with a pausing screen open. fn pauses_game(&self) -> bool { self.has_singleplayer_server() - && self.lan.is_none() + && !self.is_published() && self.title.is_none() && (matches!( self.screen, @@ -10073,6 +10075,7 @@ impl<'a> Game<'a> { remote: None, lan: None, integrated: None, + serving: None, world_options: None, options_to_world_options: false, command_block_screen: None, diff --git a/crates/horizon-client/src/game/commands/extra.rs b/crates/horizon-client/src/game/commands/extra.rs index ab41596ee..a90648043 100644 --- a/crates/horizon-client/src/game/commands/extra.rs +++ b/crates/horizon-client/src/game/commands/extra.rs @@ -758,18 +758,25 @@ impl Game<'_> { .and_then(|l| l.local_addr()) .map_or(25564, |a| i32::from(a.port())), }; - if let Some(lan) = &self.lan { - return Err(err( - "commands.publish.alreadyPublished.lan", - &[&lan.settings.port], - )); + let published = if self.serving() { + self.published_port() + } else { + self.lan.as_ref().map(|l| l.settings.port) + }; + if let Some(port) = published { + return Err(err("commands.publish.alreadyPublished.lan", &[&port])); } let settings = super::super::lan::LanSettings { port: port as u16, guest_commands: allow, force_game_mode: false, }; - if self.lan_start(settings).is_err() { + let started = if self.serving() { + self.publish(settings).is_ok() + } else { + self.lan_start(settings).is_ok() + }; + if !started { return Err(err("commands.publish.failed", &[])); } let port_text = port.to_string(); @@ -785,6 +792,13 @@ impl Game<'_> { Ok(port) } pub(super) fn cmd_unpublish(&mut self) -> R { + if self.serving() { + if !self.unpublish() { + return Err(err("commands.unpublish.notPublished", &[])); + } + self.feedback(Text::translate("commands.unpublish.success", &[])); + return Ok(1); + } if self.lan.is_none() { return Err(err("commands.unpublish.notPublished", &[])); } diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index 4008c33d9..94fd59f61 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -38,7 +38,7 @@ impl DebugHost for Host<'_, '_> { // the menu as it always has (key_pressed). let g = &mut *self.game; if without_menu && g.screen == Screen::Playing { - g.pause_menu = !(g.has_singleplayer_server() && g.lan.is_none()); + g.pause_menu = !(g.has_singleplayer_server() && !g.is_published()); g.screen = Screen::Paused; g.capture(false); g.mining = None; diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs index 01728b351..062bb71c8 100644 --- a/crates/horizon-client/src/game/dedicated.rs +++ b/crates/horizon-client/src/game/dedicated.rs @@ -441,6 +441,7 @@ impl Game<'_> { seed: self.level.seed, max_players: props.max_players.max(0) as usize, dedicated: true, + integrated: false, }; let settings = LanSettings { port, diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index 0366627e3..ac2121e2e 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -2,6 +2,10 @@ //! its own "Server thread", as vanilla's does, and the window joins it as a //! player through memory, so a world tick never holds up a frame. //! +//! The window asks its server for what only the server knows (Open to LAN, +//! the world's options) with [`Integrated::call`], as vanilla's client calls +//! into its `IntegratedServer`. +//! //! Opt-in for now (`--server-thread` or `HORIZON_SERVER_THREAD=1`): the //! player joins as a network player, and the server side of a network player //! does not do everything single player does yet. Worlds whose player is @@ -15,7 +19,7 @@ use horizon_client::{ Result, audio::Audio, hud::HudAtlas, - lan::{MAX_PLAYERS, NetConfig, hub::HubConfig}, + lan::{Lan, MAX_PLAYERS, NetConfig, hub::HubConfig}, save::Level, settings::Settings, title::WorldOptions, @@ -23,11 +27,12 @@ use horizon_client::{ use horizon_protocol::connection::Pipe; use horizon_protocol::{crypto::offline_uuid, text::translatable}; use std::{ + net::TcpListener, path::Path, sync::{ Arc, - atomic::{AtomicBool, Ordering}, - mpsc::{Sender, channel}, + atomic::{AtomicBool, AtomicU16, Ordering}, + mpsc::{Receiver, Sender, channel, sync_channel}, }, thread::JoinHandle, time::{Duration, Instant}, @@ -39,12 +44,19 @@ struct Flags { /// `Minecraft.pause`: a single-player pause screen is open. paused: AtomicBool, stop: AtomicBool, + /// `IntegratedServer.getPort`: the port it is open to the LAN on, 0 + /// while it is not. + published: AtomicU16, } +/// Work the window hands its server thread (`MinecraftServer.execute`). +type Task = Box) + Send>; + /// The window's handle on its server thread. pub(super) struct Integrated { flags: Arc, thread: Option>, + tasks: Sender, /// The world's name (`level.dat`'s `LevelName`), for the pause menu. pub world_name: String, } @@ -53,6 +65,24 @@ impl Integrated { pub fn set_paused(&self, paused: bool) { self.flags.paused.store(paused, Ordering::Relaxed); } + /// `IntegratedServer.getPort` while `isPublished`. + pub fn published(&self) -> Option { + Some(self.flags.published.load(Ordering::Relaxed)).filter(|&p| p != 0) + } + /// `executeBlocking`: run `f` on the server thread between two ticks and + /// wait for its answer; `None` once the server has stopped. + pub fn call( + &self, + f: impl FnOnce(&mut Game<'_>) -> T + Send + 'static, + ) -> Option { + let (tx, rx) = sync_channel(1); + self.tasks + .send(Box::new(move |g| { + let _ = tx.send(f(g)); + })) + .ok()?; + rx.recv_timeout(Duration::from_secs(10)).ok() + } /// `IntegratedServer.halt(true)`: returns once the world is saved and let go. pub fn stop(mut self) { self.halt(); @@ -70,6 +100,21 @@ impl Drop for Integrated { } } +/// The server thread's side of the window's handle (`Game::serving`). +pub(super) struct Serving { + flags: Arc, + tasks: Receiver, + /// The window's profile. + owner: u128, + /// Open to LAN or closed from inside a player's command, while the hub + /// is out of its place: applied after the tick. + pending: Option, +} +enum Publish { + Open(TcpListener, LanSettings), + Close, +} + /// What the server thread hands the window once the world is open: its end /// of the connection and the world's name, or why it failed. type Ready = std::result::Result<(Pipe, String), String>; @@ -81,8 +126,11 @@ struct Launch { seed: Option, creative: bool, create: Option, - /// The window's profile: the only one let in, and the world's player. + /// The window's profile: the only one let in until the world is open to + /// the LAN, and the world's player. owner: u128, + /// Its name, for the LAN's MOTD. + player: String, } /// Whether this world opens on a server thread: asked for, and its player @@ -99,6 +147,14 @@ impl Game<'_> { pub(super) fn has_singleplayer_server(&self) -> bool { self.remote.is_none() || self.integrated.is_some() } + /// `IntegratedServer.isPublished`: the world is open to the network. + pub(super) fn is_published(&self) -> bool { + self.lan.is_some() + || self + .integrated + .as_ref() + .is_some_and(|s| s.published().is_some()) + } /// `Minecraft.doWorldLoad`: start the server thread on the world, wait /// until it can be joined, then join it through memory. pub(super) fn open_integrated( @@ -121,6 +177,7 @@ impl Game<'_> { create: create.cloned(), // An offline-mode server names its players by their offline profile. owner: offline_uuid(&player), + player: player.clone(), }; let mut options = self.options.clone(); // A server without a console: no local player, no window, no control socket. @@ -138,6 +195,7 @@ impl Game<'_> { let (res, pack, settings) = (self.res.clone(), self.pack.clone(), self.settings.clone()); let flags = Arc::new(Flags::default()); let (ready_tx, ready) = channel(); + let (tasks, server_tasks) = channel(); let server_flags = flags.clone(); let thread = std::thread::Builder::new() .name("Server thread".into()) @@ -148,7 +206,8 @@ impl Game<'_> { options, settings, launch, - &server_flags, + server_flags, + server_tasks, &ready_tx, ); if let Err(e) = result { @@ -159,6 +218,7 @@ impl Game<'_> { let mut handle = Integrated { flags, thread: Some(thread), + tasks, world_name: String::new(), }; let pipe = match ready.recv() { @@ -179,7 +239,8 @@ impl Game<'_> { fn run_integrated( &mut self, launch: Launch, - flags: &Flags, + flags: Arc, + tasks: Receiver, ready: &Sender, ) -> Result<()> { self.open_world( @@ -193,7 +254,8 @@ impl Game<'_> { let view_distance = self.settings.render_distance.clamp(2, 32); let config = HubConfig { default_game_mode: self.level.mode(), - guest_commands: true, + // Only the owner until it is opened to the LAN. + guest_commands: false, force_game_mode: false, hardcore: self.level.hardcore, view_distance, @@ -203,23 +265,28 @@ impl Game<'_> { max_players: MAX_PLAYERS, // No player of its own: the hub runs without a host. dedicated: true, + integrated: true, }; let owner = launch.owner; + let published = flags.clone(); let net = NetConfig { - // No network until it is opened to the LAN. + // No network until it is opened to the LAN; the memory connection + // is not compressed (`Connection.isMemoryConnection`). listen: false, - // A memory connection is not compressed (`Connection.isMemoryConnection`). - compression_threshold: -1, - enable_status: false, - announce: false, gate: Some(Arc::new(move |_, uuid, _| { - (uuid != owner).then(|| translatable("multiplayer.disconnect.not_whitelisted", &[])) + (uuid != owner && published.published.load(Ordering::Relaxed) == 0) + .then(|| translatable("multiplayer.disconnect.not_whitelisted", &[])) })), - ..NetConfig::lan(0, self.level.name.clone(), MAX_PLAYERS) + // IntegratedServer.initServer: the MOTD names the owner and the world. + ..NetConfig::lan( + 0, + format!("{} - {}", launch.player, self.level.name), + MAX_PLAYERS, + ) }; let settings = LanSettings { port: 0, - guest_commands: true, + guest_commands: false, force_game_mode: false, }; self.lan_host(settings, net, config, None)?; @@ -238,10 +305,17 @@ impl Game<'_> { }); host.hub.lan.connect_local()? }; + self.serving = Some(Serving { + flags: flags.clone(), + tasks, + owner, + pending: None, + }); let _ = ready.send(Ok((pipe, self.level.name.clone()))); self.settle_spawn()?; let mut next = Instant::now(); while !flags.stop.load(Ordering::Relaxed) { + self.run_tasks(); self.update_dedicated_streaming(); self.update_world(); if flags.paused.load(Ordering::Relaxed) { @@ -250,6 +324,7 @@ impl Game<'_> { } else { self.tick()?; } + self.apply_publish(); let rate = self.clock.rate().max(1.0); next += Duration::from_secs_f64(1.0 / f64::from(rate)); let now = Instant::now(); @@ -265,6 +340,10 @@ impl Game<'_> { /// `MinecraftServer.stopServer`: the players are saved and sent away, /// then the world is saved. fn stop_integrated(&mut self) -> Result<()> { + // IntegratedServer.stopServer: teardownPublishedState. + if let Some(s) = self.serving.take() { + s.flags.published.store(0, Ordering::Relaxed); + } if let Some(mut host) = self.lan.take() { for g in &host.hub.guests { self.save_guest(&host, g); @@ -287,19 +366,191 @@ impl Game<'_> { } } +/// What the world options screen shows of an integrated server. +#[derive(Clone, Copy, Debug)] +pub(super) struct ServerOptions { + pub default_mode: i32, + /// The owner's own game mode. + pub personal_mode: i32, + pub cheats: bool, + pub difficulty: u8, + pub hardcore: bool, + pub difficulty_locked: bool, + pub port: Option, + pub guest_commands: bool, + pub force: bool, +} + +/// The server thread's side. +impl Game<'_> { + /// Whether this game is an integrated server's. + pub(super) fn serving(&self) -> bool { + self.serving.is_some() + } + /// The window's requests, between two ticks. + fn run_tasks(&mut self) { + let tasks: Vec = match &self.serving { + Some(s) => s.tasks.try_iter().collect(), + None => return, + }; + for task in tasks { + task(self); + self.apply_publish(); + } + } + /// `IntegratedServer.getPort` while published. + pub(super) fn published_port(&self) -> Option { + let s = self.serving.as_ref()?; + Some(s.flags.published.load(Ordering::Relaxed)).filter(|&p| p != 0) + } + /// `IntegratedServer.publishServer`: listen on `settings.port` (0 picks + /// one) and announce the world. The socket is bound at once so a busy + /// port fails here; the hub starts listening once it is at hand. + pub(super) fn publish(&mut self, settings: LanSettings) -> std::result::Result { + let Some(s) = self.serving.as_mut() else { + return Err("not an integrated server".into()); + }; + if s.flags.published.load(Ordering::Relaxed) != 0 { + return Err("already published".into()); + } + let listener = Lan::bind(None, settings.port).map_err(|e| e.to_string())?; + let port = listener.local_addr().map_err(|e| e.to_string())?.port(); + log::info!("Published LAN server on port {port}"); + s.flags.published.store(port, Ordering::Relaxed); + s.pending = Some(Publish::Open(listener, LanSettings { port, ..settings })); + self.apply_publish(); + Ok(port) + } + /// `IntegratedServer.unpublishServer`: stop listening and send every + /// player but the owner away. False when it was not published. + pub(super) fn unpublish(&mut self) -> bool { + let Some(s) = self.serving.as_mut() else { + return false; + }; + if s.flags.published.swap(0, Ordering::Relaxed) == 0 { + return false; + } + s.pending = Some(Publish::Close); + self.apply_publish(); + true + } + /// Publish or unpublish for real, once the hub is in its place (a + /// player's `/publish` runs while it is out). + fn apply_publish(&mut self) { + if self.lan.is_none() { + return; + } + let Some(s) = self.serving.as_mut() else { + return; + }; + let (Some(pending), owner) = (s.pending.take(), s.owner) else { + return; + }; + let allow_commands = self.allow_commands(); + let Some(host) = self.lan.as_mut() else { + return; + }; + match pending { + Publish::Open(listener, settings) => { + if let Err(e) = host.hub.lan.listen_on(listener, true) { + log::error!("Horizon: Open to LAN: {e}"); + } + host.settings = settings; + host.hub.config.force_game_mode = settings.force_game_mode; + // IntegratedServer.setGuestCommandAccess, then updatePermissions. + host.hub.config.guest_commands = settings.guest_commands && allow_commands; + host.hub.resend_commands(); + } + Publish::Close => { + host.hub.lan.stop_listening(); + log::info!( + "Unpublishing integrated server (was on port {})", + host.settings.port + ); + let others: Vec = host + .hub + .guests + .iter() + .filter(|g| g.uuid != owner) + .map(|g| g.conn) + .collect(); + for conn in others { + host.hub.kick( + conn, + translatable("multiplayer.disconnect.server_shutdown", &[]), + ); + } + } + } + } + /// The world options screen's state, read on the server. + pub(super) fn server_options(&self) -> ServerOptions { + let owner = self.serving.as_ref().map(|s| s.owner); + let host = self.lan.as_ref(); + let personal_mode = host + .and_then(|h| h.hub.guests.iter().find(|g| Some(g.uuid) == owner)) + .map_or(self.level.mode(), |g| g.game_mode); + let published = self.published_port(); + ServerOptions { + default_mode: self.level.mode(), + personal_mode, + cheats: self.allow_commands(), + difficulty: self.ui.difficulty, + hardcore: self.level.hardcore, + difficulty_locked: self.level.difficulty_locked, + port: published, + guest_commands: published.is_some() && host.is_some_and(|h| h.settings.guest_commands), + force: published.is_none() || host.is_some_and(|h| h.settings.force_game_mode), + } + } + /// `IntegratedServer.setPersonalGameType`: the owner's game mode. + pub(super) fn set_owner_mode(&mut self, mode: i32) { + let Some(owner) = self.serving.as_ref().map(|s| s.owner) else { + return; + }; + if let Some(host) = self.lan.as_mut() + && let Some(conn) = host + .hub + .guests + .iter() + .find(|g| g.uuid == owner) + .map(|g| g.conn) + { + host.hub.set_game_mode(conn, mode); + } + } + /// `IntegratedServer.setWorldAllowCommands`: the owner is an operator + /// while the world allows commands; everyone's level is sent again. + pub(super) fn owner_allow_commands(&mut self, allow: bool) { + let Some(owner) = self.serving.as_ref().map(|s| s.owner) else { + return; + }; + let published = self.published_port().is_some(); + if let Some(host) = self.lan.as_mut() { + host.hub.ops.insert(owner, if allow { 4 } else { 0 }); + if published { + host.hub.config.guest_commands = allow && host.settings.guest_commands; + } + host.hub.resend_commands(); + } + } +} + /// The server thread: a game of its own over the shared resources. +#[allow(clippy::too_many_arguments)] fn serve( res: &Arc, pack: PackResources, options: Options, settings: Settings, launch: Launch, - flags: &Flags, + flags: Arc, + tasks: Receiver, ready: &Sender, ) -> Result<()> { // It draws nothing: only the font, which books and chat measure with. let atlas = HudAtlas::fonts(&options.resources)?; let audio = Audio::silent(&options.resources); let mut server = Game::new(res, pack, atlas, options, settings, audio)?; - server.run_integrated(launch, flags, ready) + server.run_integrated(launch, flags, tasks, ready) } diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index c416c202f..1d00134e4 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -31,7 +31,7 @@ use std::{ static SYNC: OnceLock, String>> = OnceLock::new(); /// The settings of the open world (WorldOptionsScreen's multiplayer section). -#[derive(Clone, Debug)] +#[derive(Clone, Copy, Debug)] pub struct LanSettings { pub port: u16, pub guest_commands: bool, @@ -316,6 +316,15 @@ impl Game<'_> { if words[0] != "lan" { return Ok(None); } + if let Some(server) = &self.integrated + && words.get(1) == Some(&"status") + { + // The hub is the server thread's. + let status = server + .call(|g| g.lan_status()) + .ok_or("the integrated server stopped")?; + return Ok(Some(status)); + } match words.get(1).copied() { Some("open") => { if self.title.is_some() { @@ -337,43 +346,58 @@ impl Game<'_> { self.lan_close(true); Ok(Some(json!({ "ok": true }))) } - Some("status") => Ok(Some(match &self.lan { - Some(h) => json!({ - "open": true, - "host": h.host_name, - "port": h.settings.port, - "guests": h.hub.guests.iter().map(|g| json!({ - "name": g.name, - "position": g.position, - "placed": g.placed, - "loaded": g.loaded, - "game_mode": g.game_mode, - "sneaking": g.sneaking, - "health": g.health, - // FoodData: food level, saturation and exhaustion. - "food": [ - f64::from(g.food), - f64::from(g.saturation), - g.motion.as_ref().map_or(0.0, |m| f64::from(m.health.food.exhaustion)), - ], - "chunks": g.sent_chunks.len(), - "tracked": g.tracker.len(), - // The armour the host draws on this guest, head to feet. - "model_armor": h.models.get(&g.conn).map(|m| { - [&m.extra.head, &m.extra.chest, &m.extra.legs, &m.extra.feet] - .map(|s| s.as_deref()) - }), - })).collect::>(), - }), - None => json!({ "open": false }), - })), + Some("status") => Ok(Some(self.lan_status())), _ => Err("lan open|close|status".into()), } } + /// `horizon-ctl lan status`. + fn lan_status(&self) -> serde_json::Value { + use serde_json::json; + match &self.lan { + Some(h) if !self.serving() || self.published_port().is_some() => json!({ + "open": true, + "host": h.host_name, + "port": h.settings.port, + "guests": h.hub.guests.iter().map(|g| json!({ + "name": g.name, + "position": g.position, + "placed": g.placed, + "loaded": g.loaded, + "game_mode": g.game_mode, + "sneaking": g.sneaking, + "health": g.health, + // FoodData: food level, saturation and exhaustion. + "food": [ + f64::from(g.food), + f64::from(g.saturation), + g.motion.as_ref().map_or(0.0, |m| f64::from(m.health.food.exhaustion)), + ], + "chunks": g.sent_chunks.len(), + "tracked": g.tracker.len(), + // The armour the host draws on this guest, head to feet. + "model_armor": h.models.get(&g.conn).map(|m| { + [&m.extra.head, &m.extra.chest, &m.extra.legs, &m.extra.feet] + .map(|s| s.as_deref()) + }), + })).collect::>(), + }), + _ => json!({ "open": false }), + } + } + pub(super) fn lan_open(&mut self, settings: LanSettings) -> Result<()> { - self.lan_start(settings)?; - let port = self.lan.as_ref().map_or(0, |l| l.settings.port); + let port = if let Some(server) = &self.integrated { + // ShareToLanScreen: IntegratedServer.publishServer. + server + .call(move |g| g.publish(settings)) + .ok_or("the integrated server stopped")?? + } else if self.serving() { + return self.publish(settings).map(drop).map_err(Into::into); + } else { + self.lan_start(settings)?; + self.lan.as_ref().map_or(0, |l| l.settings.port) + }; self.system_message(Text::translate( "menu.multiplayerOptions.publish.started.lan", &[Text::literal(port.to_string())], @@ -408,6 +432,7 @@ impl Game<'_> { seed: self.level.seed, max_players: MAX_PLAYERS, dedicated: false, + integrated: false, }; let net = NetConfig::lan(settings.port, motd, MAX_PLAYERS); self.lan_host(settings, net, config, Some(host_uuid)) @@ -484,6 +509,22 @@ impl Game<'_> { /// IntegratedServer.unpublishServer: the guests are sent away. pub(super) fn lan_close(&mut self, announce: bool) { + if self.integrated.is_some() || self.serving() { + let closed = match &self.integrated { + Some(server) => server.call(|g| g.unpublish()).unwrap_or(false), + None => self.unpublish(), + }; + if closed { + self.friends_lan_closed(); + } + if closed && announce && self.integrated.is_some() { + self.system_message(Text::translate( + "menu.multiplayerOptions.publish.stopped", + &[], + )); + } + return; + } self.friends_lan_closed(); let Some(mut host) = self.lan.take() else { return; @@ -541,16 +582,29 @@ impl Game<'_> { /// New command access and game mode forcing settings of the open world. pub(super) fn lan_apply_settings(&mut self, guest_commands: bool, force: bool) { + if let Some(server) = &self.integrated { + server.call(move |g| g.lan_apply_settings(guest_commands, force)); + return; + } + // An integrated server gives guests commands only where the world + // allows them (IntegratedServer.getCustomPermissionLevel). + let effective = guest_commands && (!self.serving() || self.allow_commands()); if let Some(host) = self.lan.as_mut() { host.settings.guest_commands = guest_commands; host.settings.force_game_mode = force; - host.hub.config.guest_commands = guest_commands; + host.hub.config.guest_commands = effective; host.hub.config.force_game_mode = force; host.hub.resend_commands(); } } pub(super) fn lan_port(&self) -> Option { + if let Some(server) = &self.integrated { + return server.published(); + } + if self.serving() { + return self.published_port(); + } self.lan.as_ref().map(|h| h.settings.port) } diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 1f6921e0c..176108372 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -676,6 +676,31 @@ impl Game<'_> { ); return; } + // An integrated server runs every player's commands at their own + // permission level (`CommandSourceStack.permissions`). + if host.hub.config.integrated { + let Some(level) = host.hub.guest(conn).map(|g| g.permission) else { + return; + }; + let command = command.trim_start_matches('/').to_owned(); + let lines = self.as_guest(host, conn, |g| { + let console = std::mem::replace(&mut g.ui.registries.permission, level); + g.chat_capture = Some(Vec::new()); + g.run_command(&command); + g.ui.registries.permission = console; + g.chat_capture.take().unwrap_or_default() + }); + for line in lines.unwrap_or_default() { + host.hub.send_to( + conn, + &C::SystemChat(play::SystemChat { + content: horizon_client::lan::data::component_nbt(&line.component()), + overlay: false, + }), + ); + } + return; + } // A LAN world follows its Allow Commands; a dedicated server leaves // it to the ops list (the guest's permission level). let allowed = self.options.dedicated.is_some() || self.allow_commands(); diff --git a/crates/horizon-client/src/game/lan_screen.rs b/crates/horizon-client/src/game/lan_screen.rs index 2402a5286..7c4533a16 100644 --- a/crates/horizon-client/src/game/lan_screen.rs +++ b/crates/horizon-client/src/game/lan_screen.rs @@ -7,6 +7,7 @@ use super::{ Game, Screen, game_rules_screen::{Exit, RulesScreen}, + integrated::ServerOptions, lan::LanSettings, }; use horizon_client::{ @@ -50,7 +51,7 @@ enum View { Restrictions, GameRules, } -#[derive(Clone, PartialEq)] +#[derive(Clone, Copy, PartialEq)] struct Snapshot { default_mode: i32, personal_mode: i32, @@ -406,28 +407,32 @@ impl Restrictions { impl Game<'_> { pub(super) fn open_world_options(&mut self) { let hint = horizon_client::lan::available_port(); - let lan = self.lan.is_some(); let mut port = EditBox::new(0.0, 0.0, 150.0, 20.0); port.max_length = 5; - let (guest_commands, force) = self.lan.as_ref().map_or((false, true), |h| { - (h.settings.guest_commands, h.settings.force_game_mode) - }); - if let Some(p) = self.lan_port() { + // The world is the server thread's when there is one. + let state = match &self.integrated { + Some(server) => match server.call(|g| g.server_options()) { + Some(state) => state, + None => return, + }, + None => self.local_server_options(), + }; + if let Some(p) = state.port { port.set_value(&p.to_string()); } let mut options = WorldOptions { - default_mode: self.level.mode(), - personal_mode: self.mode_id(), - cheats: self.allow_commands(), - difficulty: self.ui.difficulty, - lan, + default_mode: state.default_mode, + personal_mode: state.personal_mode, + cheats: state.cheats, + difficulty: state.difficulty, + lan: state.port.is_some(), port, hint, - guest_commands, - force, - hardcore: self.level.hardcore, - difficulty_locked: self.level.difficulty_locked, - locked: self.level.difficulty_locked || self.level.hardcore, + guest_commands: state.guest_commands, + force: state.force, + hardcore: state.hardcore, + difficulty_locked: state.difficulty_locked, + locked: state.difficulty_locked || state.hardcore, scroll: 0.0, view: View::Options, rules: None, @@ -808,7 +813,7 @@ impl Game<'_> { fn apply_and_close_world_options(&mut self, o: WorldOptions) { let wanted = o.snapshot(); - let before = o.initial.clone(); + let before = o.initial; self.world_options = Some(o); self.apply_world_options(&before, &wanted); self.close_world_options(); @@ -891,7 +896,47 @@ impl Game<'_> { } } + /// The world options of a world run in the frame. + fn local_server_options(&self) -> ServerOptions { + let (guest_commands, force) = self.lan.as_ref().map_or((false, true), |h| { + (h.settings.guest_commands, h.settings.force_game_mode) + }); + ServerOptions { + default_mode: self.level.mode(), + personal_mode: self.mode_id(), + cheats: self.allow_commands(), + difficulty: self.ui.difficulty, + hardcore: self.level.hardcore, + difficulty_locked: self.level.difficulty_locked, + port: self.lan_port(), + guest_commands, + force, + } + } + fn apply_world_options(&mut self, before: &Snapshot, wanted: &Snapshot) { + if let Some(server) = &self.integrated { + // The server applies them; the window tells what came of + // Open to LAN (ShareToLanScreen's messages). + let (b, w) = (*before, *wanted); + server.call(move |g| g.apply_world_options(&b, &w)); + if w.lan != b.lan || (w.lan && w.port != b.port) { + match (w.lan, self.lan_port()) { + (true, Some(port)) => self.system_message(Text::translate( + "menu.multiplayerOptions.publish.started.lan", + &[Text::literal(port.to_string())], + )), + (true, None) => { + self.system_message(Text::translate("commands.publish.failed", &[])); + } + (false, _) => self.system_message(Text::translate( + "menu.multiplayerOptions.publish.stopped", + &[], + )), + } + } + return; + } if wanted.difficulty != before.difficulty { let name = DIFFICULTIES[usize::from(wanted.difficulty) & 3]; self.as_console(|g| g.run_command(&format!("difficulty {name}"))); @@ -904,10 +949,15 @@ impl Game<'_> { self.set_default_game_mode(wanted.default_mode); } if wanted.personal_mode != before.personal_mode { - self.set_mode_id(wanted.personal_mode); + if self.serving() { + self.set_owner_mode(wanted.personal_mode); + } else { + self.set_mode_id(wanted.personal_mode); + } } if wanted.cheats != before.cheats { self.set_allow_commands(wanted.cheats); + self.owner_allow_commands(wanted.cheats); } let settings_changed = wanted.guest_commands != before.guest_commands || wanted.force != before.force; diff --git a/crates/horizon-client/src/lan/conn.rs b/crates/horizon-client/src/lan/conn.rs index 0688db0c6..a1ffac4fa 100644 --- a/crates/horizon-client/src/lan/conn.rs +++ b/crates/horizon-client/src/lan/conn.rs @@ -361,8 +361,9 @@ fn login_and_configure( name: &str, ) -> Result, String> { let e = |e: horizon_protocol::Error| e.to_string(); + // ServerLoginPacketListenerImpl: memory connections are not compressed. let threshold = shared.config.compression_threshold; - if threshold >= 0 { + if threshold >= 0 && !c.is_memory() { c.send(&login::Clientbound::Compression(login::Compression { threshold }).encode()) .map_err(e)?; c.set_compression(threshold); diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index 3f1f88c4a..cb438508e 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -48,6 +48,10 @@ pub struct HubConfig { pub max_players: usize, /// A dedicated server: operators from `ops`, the dedicated-only commands. pub dedicated: bool, + /// An integrated server (`dedicated` too, since it has no host player): + /// the owner's level from `ops`, the others' from Allow Commands and + /// the guests' command access, and the integrated-only commands. + pub integrated: bool, } /// The host player as the other players see them. @@ -445,7 +449,11 @@ impl Hub { /// (IntegratedServer.setGuestCommandAccess); a dedicated server its /// operators' level (`ops`). fn default_permission(&self, uuid: u128) -> u8 { - if self.config.dedicated { + if self.config.integrated { + // IntegratedServer.getProfilePermissions / getCustomPermissionLevel. + let guests = if self.config.guest_commands { 2 } else { 0 }; + self.ops.get(&uuid).copied().unwrap_or(guests) + } else if self.config.dedicated { self.ops.get(&uuid).copied().unwrap_or(0) } else if self.config.guest_commands { 2 @@ -682,7 +690,10 @@ impl Hub { fn send_commands(&self, i: usize) { let g = &self.guests[i]; let packet = match &self.sync.commands { - Some(tree) => tree.packet(g.permission, self.config.dedicated, &self.sync.builtin), + Some(tree) => { + let dedicated = self.config.dedicated && !self.config.integrated; + tree.packet(g.permission, dedicated, &self.sync.builtin) + } None => play::Commands { nodes: vec![play::CommandNode { kind: 0, diff --git a/crates/horizon-client/src/lan/mod.rs b/crates/horizon-client/src/lan/mod.rs index f4211c6ea..7084f20a6 100644 --- a/crates/horizon-client/src/lan/mod.rs +++ b/crates/horizon-client/src/lan/mod.rs @@ -310,6 +310,8 @@ pub struct Lan { events: Receiver, pub port: u16, listener: Option>, + /// Stops the accept loop alone: local connections stay. + listener_stop: Arc, /// The multicast announcement (LanServerPinger); absent when the socket failed. _pinger: Option, } @@ -325,26 +327,8 @@ impl Lan { } /// ServerConnectionListener.startTcpServerListener with a configuration. pub fn start_with(sync: Arc, config: NetConfig) -> io::Result { - let listener = if config.listen { - let bind = config - .bind - .unwrap_or(std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED)); - let listener = TcpListener::bind((bind, config.port))?; - listener.set_nonblocking(true)?; - Some(listener) - } else { - None - }; - let port = match &listener { - Some(l) => l.local_addr()?.port(), - None => 0, - }; - let _pinger = if config.announce && listener.is_some() { - discovery::Pinger::start(config.motd.clone(), port).ok() - } else { - None - }; let (tx, events) = channel(); + let (listen, port, announce) = (config.listen, config.port, config.announce); let shared = Arc::new(Shared { sync, events: tx, @@ -357,21 +341,77 @@ impl Lan { random: Mutex::new(crate::server::java_properties::now_millis() as u64 | 1), config, }); - let accept_shared = shared.clone(); - let listener = listener - .map(|listener| { - std::thread::Builder::new() - .name("horizon-lan-accept".into()) - .spawn(move || accept_loop(listener, accept_shared)) - }) - .transpose()?; - Ok(Self { + let mut lan = Self { shared, events, - port, - listener, - _pinger, - }) + port: 0, + listener: None, + listener_stop: Arc::new(AtomicBool::new(false)), + _pinger: None, + }; + if listen { + lan.listen(port, announce)?; + } + Ok(lan) + } + /// Start accepting connections on `port` (0 picks a free one), and + /// announce the world on the local network when `announce` + /// (`IntegratedServer.publishServer`'s LanServerPinger). Returns the port. + pub fn listen(&mut self, port: u16, announce: bool) -> io::Result { + if self.listener.is_some() { + return Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "already listening", + )); + } + let listener = Self::bind(self.shared.config.bind, port)?; + self.listen_on(listener, announce) + } + /// The socket [`Lan::listen`] accepts on, bound ahead so that a failure + /// can be reported before the hub is at hand. + pub fn bind(address: Option, port: u16) -> io::Result { + let bind = address.unwrap_or(std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED)); + let listener = TcpListener::bind((bind, port))?; + listener.set_nonblocking(true)?; + Ok(listener) + } + /// [`Lan::listen`] on a socket already bound. + pub fn listen_on(&mut self, listener: TcpListener, announce: bool) -> io::Result { + if self.listener.is_some() { + return Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "already listening", + )); + } + let port = listener.local_addr()?.port(); + let stop = Arc::new(AtomicBool::new(false)); + let (accept_shared, accept_stop) = (self.shared.clone(), stop.clone()); + let thread = std::thread::Builder::new() + .name("horizon-lan-accept".into()) + .spawn(move || accept_loop(listener, accept_shared, &accept_stop))?; + self._pinger = if announce { + discovery::Pinger::start(self.shared.motd(), port).ok() + } else { + None + }; + self.listener = Some(thread); + self.listener_stop = stop; + self.port = port; + Ok(port) + } + /// Stop accepting connections and announcing; connections already in + /// (the local one included) stay. + pub fn stop_listening(&mut self) { + self.listener_stop.store(true, Ordering::Relaxed); + if let Some(t) = self.listener.take() { + let _ = t.join(); + } + self._pinger = None; + self.port = 0; + } + /// Whether connections from the network are accepted. + pub fn listening(&self) -> bool { + self.listener.is_some() } /// `Connection.connectToLocalServer`: a connection through memory, its /// server end served on its own thread like an accepted socket. @@ -402,10 +442,7 @@ impl Lan { } pub fn stop(&mut self) { self.shared.stop.store(true, Ordering::Relaxed); - if let Some(t) = self.listener.take() { - let _ = t.join(); - } - self._pinger = None; + self.stop_listening(); } } impl Drop for Lan { @@ -414,8 +451,8 @@ impl Drop for Lan { } } -fn accept_loop(listener: TcpListener, shared: Arc) { - while !shared.stop.load(Ordering::Relaxed) { +fn accept_loop(listener: TcpListener, shared: Arc, stop: &AtomicBool) { + while !shared.stop.load(Ordering::Relaxed) && !stop.load(Ordering::Relaxed) { match listener.accept() { Ok((stream, addr)) => { let shared = shared.clone(); diff --git a/crates/horizon-client/tests/lan_bot.rs b/crates/horizon-client/tests/lan_bot.rs index 7a4a4a3c4..36f53444c 100644 --- a/crates/horizon-client/tests/lan_bot.rs +++ b/crates/horizon-client/tests/lan_bot.rs @@ -241,6 +241,7 @@ fn server(resources: &Path) -> Server { view_distance: 3, simulation_distance: 3, dedicated: false, + integrated: false, dimension: "minecraft:overworld".into(), seed: 1234, max_players: 8, diff --git a/crates/horizon-protocol/src/connection.rs b/crates/horizon-protocol/src/connection.rs index 3c6087f2e..687839416 100644 --- a/crates/horizon-protocol/src/connection.rs +++ b/crates/horizon-protocol/src/connection.rs @@ -227,6 +227,10 @@ impl Connection { }, }) } + /// `Connection.isMemoryConnection`: through a [`Pipe`] rather than a socket. + pub fn is_memory(&self) -> bool { + matches!(self.reader.stream, Stream::Memory(_)) + } /// ClientboundLoginCompressionPacket: negative thresholds disable compression. pub fn set_compression(&mut self, threshold: i32) { let t = usize::try_from(threshold).ok(); From ac2cc43aa663a66417739333bab5fcbf848c58e5 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 19:35:47 -0400 Subject: [PATCH 11/19] Add mod management to Classic Options --- crates/horizon-client/src/game/control.rs | 3 +- crates/horizon-client/src/options_ui.rs | 136 +++++++++++++++++++++- 2 files changed, 137 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index e1169b2c8..495e6422b 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -29,7 +29,7 @@ const HELP: &[&str] = &[ "chat TEXT send a chat line or /command as if typed", "type TEXT type into the open chat box (key enter tap sends)", "chat-log [N] the newest N chat messages (default 10)", - "options [PAGE] open the options (video sound controls keybinds mouse chat accessibility language font packs graphics graphics-advanced)", + "options [PAGE] open the options (video sound controls keybinds mouse chat accessibility language font packs mods graphics graphics-advanced)", "stats [reset] frame-time summary since the last reset", "bench SECONDS reset stats, wait, then reply with the summary", "fly X1 Y1 Z1 X2 Y2 Z2 SECONDS [PITCH [raw]] fly the camera along a line at constant speed, then reply with the frame summary (raw: every frame time too)", @@ -462,6 +462,7 @@ impl Game<'_> { "language" => Page::Language, "font" => Page::Font, "packs" => Page::Packs, + "mods" => Page::Mods, "graphics" => Page::Graphics, "graphics-advanced" => Page::GraphicsAdvanced, other => return Err(format!("unknown options page {other}").into()), diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 38be29576..71ca2d2cc 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -708,6 +708,7 @@ pub enum Page { Language, Font, Packs, + Mods, /// Horizon's graphics settings (`graphics_ui`). Graphics, GraphicsAdvanced, @@ -730,6 +731,7 @@ enum Act { ResetPadKeys, /// Back to Horizon's own menus (Horizon only, see `list_rows`). HorizonMenus, + ToggleMod(usize), } enum WKind { Button { @@ -971,6 +973,7 @@ impl OptionsUi { Page::Language => "options.language.title", Page::Font => "options.font.title", Page::Packs => "resourcePack.title", + Page::Mods => "Mods", Page::Graphics | Page::GraphicsAdvanced => "options.videoTitle", Page::Controller => "Controller Settings", Page::PadBinds => "Controller Binds", @@ -1161,6 +1164,36 @@ impl OptionsUi { Opt::AutoJump, ]), Page::Font => pairs(&[Opt::ForceUnicode, Opt::JapaneseGlyphs]), + Page::Mods => { + if s.mods.installed.is_empty() { + return vec![Row::Header( + "No mods: put .hmod files in the horizon-mods folder", + )]; + } + s.mods + .installed + .iter() + .enumerate() + .map(|(i, installed)| { + let mut label = Text::literal(format!("{}: ", installed.title)) + .append(on_off(s.mods.is_on(i))); + if installed.problem.is_some() { + label = label.append(" (Stopped)"); + } else if installed.dev { + label = label.append(" (Dev)"); + } + let widget = button(0.0, 0.0, 310.0, label, Act::ToggleMod(i)); + Row::Buttons( + if installed.dev || installed.id.is_empty() { + inactive(widget) + } else { + widget + }, + None, + ) + }) + .collect() + } _ => { let _ = s; Vec::new() @@ -1206,7 +1239,7 @@ impl OptionsUi { ("options.chat", Some(Page::Chat)), ("options.resourcepack", Some(Page::Packs)), ("options.accessibility", Some(Page::Accessibility)), - ("options.telemetry", None), + ("Mods...", Some(Page::Mods)), ("options.credits_and_attribution", None), ]; let gy = (61.0 + 30.0f32).min(h - 33.0 - 120.0); @@ -1650,6 +1683,21 @@ impl OptionsUi { if let Some(key) = key.filter(|key| lang::has(key)) { tooltip = Some(atlas.font.split(&tr(&key), 170.0)); } + if let WKind::Button { + act: Act::ToggleMod(i), + .. + } = &wd.kind + && let Some(installed) = s.mods.installed.get(*i) + { + let description = installed + .problem + .as_deref() + .unwrap_or(&installed.description); + tooltip = Some(atlas.font.split( + &Text::literal(format!("{}\n{description}", installed.title)), + 170.0, + )); + } } match &wd.kind { WKind::Button { label, active, act } => { @@ -1944,6 +1992,10 @@ impl OptionsUi { crate::ui_theme::save_preferences(&dir); } } + Act::ToggleMod(i) => { + s.mods.toggle(i); + events.push(Event::Changed); + } Act::None => {} } } @@ -2201,6 +2253,88 @@ mod tests { HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap() } + #[test] + fn classic_mods_page_toggles_mods_and_keeps_dev_and_invalid_entries_inactive() { + let atlas = atlas(); + let mut s = Settings::default(); + let mut ui = OptionsUi::default(); + let size = (480.0, 240.0); + assert!(ui.layout(&s, size.0, size.1).0.iter().any(|w| { + matches!( + w.kind, + WKind::Button { + active: true, + act: Act::Push(Page::Mods), + .. + } + ) + })); + ui.show(Page::Mods); + let empty = ui.layout(&s, size.0, size.1).0; + assert!(empty.iter().any(|w| { + matches!(&w.kind, WKind::Text { text, .. } if text.plain().contains(".hmod")) + })); + for (id, dev) in [("normal", false), ("dev", true), ("", false)] { + s.mods.installed.push(crate::mod_list::Installed { + id: id.into(), + title: id.into(), + description: "May show HUD panels.".into(), + problem: id.is_empty().then(|| "Invalid package".into()), + dev, + }); + } + let (widgets, ..) = ui.layout(&s, size.0, size.1); + let rows: Vec<_> = widgets + .iter() + .filter(|w| { + matches!( + w.kind, + WKind::Button { + act: Act::ToggleMod(_), + .. + } + ) + }) + .collect(); + assert_eq!(rows.len(), 3); + for (i, row) in rows.iter().enumerate() { + let events = ui.click( + &mut s, + &atlas, + row.x + 1.0, + row.y + 1.0, + size, + [480, 240], + false, + false, + ); + if i == 0 { + assert!(events.contains(&Event::Changed)); + assert!(events.contains(&Event::ButtonClick)); + } else { + assert!(events.is_empty()); + } + } + assert!(s.mods.is_on(0)); + assert!(s.mods.is_on(1)); + assert!(!s.mods.is_on(2)); + assert_eq!(s.mods.serialize(), "mod.normal:true\n"); + let row = rows[0]; + ui.click( + &mut s, + &atlas, + row.x + 1.0, + row.y + 1.0, + size, + [480, 240], + false, + false, + ); + assert!(!s.mods.is_on(0)); + assert!(!ui.back(&mut s).contains(&Event::Close)); + assert_eq!(ui.page(), Page::Main); + } + #[test] fn option_tooltip_keys_follow_value_dependent_descriptions() { let mut s = Settings::default(); From 7e430564a6d62dbc0816c735bda0bc36bb2e9cd3 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 00:11:57 +0200 Subject: [PATCH 12/19] Returning to the Overworld reuses its stronghold ring positions Each dimension change builds the destination's generator again, and with it a new structure state, so the 128 stronghold ring searches ran again on every return to the Overworld (about 1.5 s on two workers) and held up the first new chunks. The ring positions depend only on the shared generator data, the seed and the dimension's generator definition, so the generator data now keeps them by those (the last eight), and later generators for the same world and dimension share them. Co-Authored-By: Claude Opus 5.5 --- .../horizon-world/src/worldgen/generator.rs | 82 ++++++++++++++++++- .../src/worldgen/generator_structures.rs | 8 +- 2 files changed, 85 insertions(+), 5 deletions(-) diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs index 65d872c85..12dfc10d9 100644 --- a/crates/horizon-world/src/worldgen/generator.rs +++ b/crates/horizon-world/src/worldgen/generator.rs @@ -51,7 +51,7 @@ use std::{ collections::{BTreeMap, BTreeSet, HashMap}, fs, io, path::Path, - sync::{Arc, Mutex}, + sync::{Arc, Mutex, OnceLock}, }; #[derive(Debug)] @@ -184,7 +184,13 @@ pub struct GeneratorData { /// Block shape-update behaviour (`block-behaviours.json` next to the /// worldgen directory) for template placement's neighbor updates. pub(super) behaviours: Option>, + /// Concentric ring positions by seed and dimension generator (see + /// `rings_for`), most recent last. + ring_cache: Mutex>, } +type RingCacheEntry = ((i64, String), Arc>); +/// Generators whose ring positions are kept: the dimensions of a few worlds. +const RING_CACHE_LIMIT: usize = 8; type Bundle = BTreeMap; fn read_bundle(dir: &Path, name: &str) -> Result { let path = dir.join(format!("{name}.json")); @@ -458,8 +464,30 @@ impl GeneratorData { block_tags, biome_tags, feature_resources, + ring_cache: Mutex::new(Vec::new()), })) } + /// The concentric ring positions (strongholds) of the generator for + /// `seed` and the dimension `generator` definition, shared by every + /// generator built for them. They depend on nothing else, so returning + /// to a dimension, which builds its generator again, finds them done. + pub(super) fn rings_for( + &self, + seed: i64, + generator: &Value, + ) -> Arc> { + let key = (seed, generator.to_string()); + let mut cache = self.ring_cache.lock().unwrap_or_else(|e| e.into_inner()); + let rings = match cache.iter().position(|(k, _)| *k == key) { + Some(i) => cache.remove(i).1, + None => Arc::new(OnceLock::new()), + }; + if cache.len() >= RING_CACHE_LIMIT { + cache.remove(0); + } + cache.push((key, rings.clone())); + rings + } pub fn registry(&self) -> &'static BlockRegistry { self.registry } @@ -821,8 +849,9 @@ where .into_iter() .filter_map(|name| pipeline.data.biome_id(name)) .collect(); + let rings = pipeline.data.rings_for(seed, generator); pipeline.structures = - super::generator_structures::StructureState::new(&pipeline.data, &possible)?; + super::generator_structures::StructureState::new(&pipeline.data, &possible, rings)?; } Ok(pipeline) } @@ -1906,6 +1935,55 @@ impl GeneratorWorker { mod tests { use super::*; + /// Generators of one seed and dimension share their ring positions; + /// another seed or generator gets its own, and old entries go. + #[test] + fn ring_positions_are_shared_by_seed_and_dimension() { + let root = std::env::var_os("HORIZON_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: &'static BlockRegistry = Box::leak(Box::new( + crate::level::data::load_registry(&root).expect("registry"), + )); + let data = GeneratorData::load(&root.join("worldgen"), registry).expect("worldgen data"); + let first = OverworldGenerator::new(data.clone(), 1234).expect("generator"); + let again = OverworldGenerator::new(data.clone(), 1234).expect("generator"); + { + let cache = data.ring_cache.lock().unwrap(); + assert_eq!(cache.len(), 1); + // The cache's handle and the two generators'. + assert_eq!(Arc::strong_count(&cache[0].1), 3); + } + drop((first, again)); + let a = data.rings_for(1, &serde_json::json!({ "settings": "a" })); + assert!(Arc::ptr_eq( + &a, + &data.rings_for(1, &serde_json::json!({ "settings": "a" })) + )); + assert!(!Arc::ptr_eq( + &a, + &data.rings_for(2, &serde_json::json!({ "settings": "a" })) + )); + assert!(!Arc::ptr_eq( + &a, + &data.rings_for(1, &serde_json::json!({ "settings": "b" })) + )); + for seed in 10..10 + RING_CACHE_LIMIT as i64 { + data.rings_for(seed, &serde_json::json!({ "settings": "a" })); + } + assert_eq!(data.ring_cache.lock().unwrap().len(), RING_CACHE_LIMIT); + assert!(!Arc::ptr_eq( + &a, + &data.rings_for(1, &serde_json::json!({ "settings": "a" })) + )); + } + #[test] fn parameter_reports_quantize_like_vanilla() { let report = r#"{"biomes":[{"biome":"minecraft:plains","parameters":{ diff --git a/crates/horizon-world/src/worldgen/generator_structures.rs b/crates/horizon-world/src/worldgen/generator_structures.rs index 4f804712f..f5487dc33 100644 --- a/crates/horizon-world/src/worldgen/generator_structures.rs +++ b/crates/horizon-world/src/worldgen/generator_structures.rs @@ -31,8 +31,9 @@ pub(super) struct StructureState { /// Structure indices of each decoration step, in registry order. pub(super) by_step: Vec>, starts: Mutex>, - /// Concentric ring positions, computed on first use. - rings: OnceLock, + /// Concentric ring positions, computed on first use and shared with + /// later generators of the same seed and dimension. + rings: Arc>, /// Their biome searches while they are computed. ring_work: OnceLock, } @@ -131,6 +132,7 @@ impl StructureState { pub(super) fn new( data: &Arc, possible_biomes: &BTreeSet, + rings: Arc>, ) -> Result, GeneratorError> { let (Some(resources), Some(raw)) = (&data.structures, &data.structure_resources) else { return Ok(None); @@ -166,7 +168,7 @@ impl StructureState { possible_sets, by_step, starts: Mutex::new(HashMap::new()), - rings: OnceLock::new(), + rings, ring_work: OnceLock::new(), })) } From f03990f663e658379dd51790342205a57b263871 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 01:45:15 +0200 Subject: [PATCH 13/19] Integrated server: control socket and chat read the server's side With single player on its server thread, the window is the server's client, and some of what it answered was its own empty side: - `horizon-ctl save` and `save-all` returned ok without saving: the window's save skips worlds it is connected to. They now save on the server thread (`Integrated::call`). - `horizon-ctl chat-log` read the window's local chat, which never showed what the server said (command feedback, joins). It reads the connection's chat, as the agent's chat query already did. - The game's own messages (Open to LAN, screenshots...) went to that local chat, which is not drawn while connected: they now join the connection's chat. - `state` names the world (the server thread's `LevelName`). - The client follows its permission level (EntityEvent 24..28, LocalPlayer.setPermissionLevel), which the commands the chat offers and checks depend on. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/agent.rs | 5 ++- crates/horizon-client/src/game/chat.rs | 6 ++++ crates/horizon-client/src/game/control.rs | 38 ++++++++++++++++------- crates/horizon-client/src/game/remote.rs | 10 +++++- 4 files changed, 45 insertions(+), 14 deletions(-) diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index cd39606b3..48b24bbb3 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -460,7 +460,10 @@ impl Game<'_> { json!({ "screen": self.screen_label(), "menu": self.title.as_ref().map(|_| self.title_value()), - "world": (self.title.is_none()).then(|| self.level.name.clone()), + "world": (self.title.is_none()).then(|| match &self.integrated { + Some(server) => server.world_name.clone(), + None => self.level.name.clone(), + }), "dimension": self.dim.id(), "gamemode": format!("{:?}", self.mode).to_lowercase(), "time": { "day_time": self.world.day_time, "day": self.world.day_time.div_euclid(24000), "time_of_day": self.world.day_time.rem_euclid(24000) }, diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index 8f6bed0ca..bcf6426e1 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -425,6 +425,12 @@ impl Game<'_> { capture.push(text); return; } + // Connected to a server (single player's own included), the chat on + // screen is the connection's: the game's own messages join it. + if self.remote.is_some() { + self.chat_line(text.plain()); + return; + } let focused = self.screen == Screen::Chat; let heard = self.mods.mods.is_running().then(|| text.plain()); self.ui.chat.add( diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index e1169b2c8..7b51fe8ee 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -475,7 +475,10 @@ impl Game<'_> { } "chat-log" => { let n = words.get(1).map_or(Ok(10), |n| n.parse())?; - Ok(Some(json!({ "chat": self.ui.chat.recent_lines(n) }))) + let lines = self + .remote_chat(n) + .unwrap_or_else(|| self.ui.chat.recent_lines(n)); + Ok(Some(json!({ "chat": lines }))) } "stats" => { let summary = self.frame_stats.summary(); @@ -549,18 +552,20 @@ impl Game<'_> { self.leave_server(None)?; ok() } - "save" => { + "save" | "save-all" => { self.require_world()?; - self.save_game()?; - ok() - } - "save-all" => { - // Like `save-all flush`: also rewrite chunks that were not modified - // (the save round-trip harness compares them with vanilla's files). - self.require_world()?; - let keys: Vec<_> = self.world.chunks.keys().copied().collect(); - self.world.modified.extend(keys); - self.save_game()?; + // `save-all` is like `save-all flush`: it also rewrites chunks + // that were not modified (the save round-trip harness compares + // them with vanilla's files). + let all = words[0] == "save-all"; + // Single player's world is its server thread's. + if let Some(server) = &self.integrated { + server + .call(move |g| g.control_save(all).map_err(|e| e.to_string())) + .ok_or("the integrated server stopped")??; + } else { + self.control_save(all)?; + } ok() } "dragon-hurt" => { @@ -581,6 +586,15 @@ impl Game<'_> { } } + /// `horizon-ctl save` and `save-all`. + fn control_save(&mut self, all: bool) -> Result<()> { + if all { + let keys: Vec<_> = self.world.chunks.keys().copied().collect(); + self.world.modified.extend(keys); + } + self.save_game() + } + fn require_world(&self) -> Result<()> { if self.title.is_some() { return Err("no world open; use: open WORLD [SEED] [creative]".into()); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 8e4e973f2..c0829b43b 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -426,7 +426,7 @@ impl Game<'_> { } Some(stack) } - fn chat_line(&mut self, text: String) { + pub(super) fn chat_line(&mut self, text: String) { log::info!("[chat] {text}"); if let Some(r) = self.remote.as_mut() { r.chat.push((text, Instant::now())); @@ -1133,6 +1133,14 @@ impl Game<'_> { } } C::EntityEvent(p) => { + // EntityEvent.PERMISSION_LEVEL_ALL..OWNERS (24..=28) for this + // player: LocalPlayer.setPermissionLevel, which the commands + // the chat offers and checks follow. + if (24..=28).contains(&p.event) + && self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) + { + self.ui.registries.permission = (p.event - 24) as u8; + } if p.event == 1 && let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) && m.species() == horizon_client::mobs::Species::Rabbit From b2f0af559b3244dc07caedd1cfcbd33b0cc92bb1 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:34:18 -0400 Subject: [PATCH 14/19] Accept and handle mouse bindings for Extras --- crates/horizon-client/src/game.rs | 3 + crates/horizon-client/src/game/extras.rs | 6 +- crates/horizon-client/src/game/options.rs | 11 +-- crates/horizon-client/src/game/tweaks.rs | 10 ++- crates/horizon-client/src/options_horizon.rs | 11 ++- crates/horizon-client/src/options_ui.rs | 83 +++++++++++++++++--- 6 files changed, 100 insertions(+), 24 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index e552eb118..4496e6e73 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9360,6 +9360,9 @@ impl ApplicationHandler for Game<'_> { } WindowEvent::MouseInput { state, button, .. } => { let pressed = state == ElementState::Pressed; + if pressed && self.sort_mouse_press(button) { + return Ok(()); + } match self.screen { Screen::Playing => { if pressed && !self.captured { diff --git a/crates/horizon-client/src/game/extras.rs b/crates/horizon-client/src/game/extras.rs index c6ac6d25e..712796a81 100644 --- a/crates/horizon-client/src/game/extras.rs +++ b/crates/horizon-client/src/game/extras.rs @@ -58,8 +58,12 @@ impl Game<'_> { pub(super) fn extras_scroll(&mut self, steps: f32) -> bool { self.settings.extras.zoom && self.extras.zoom.scroll(steps) } - /// Mouse buttons while playing, for the keystroke overlay. + /// Mouse buttons while playing, for zoom and the keystroke overlay. pub(super) fn extras_mouse(&mut self, button: MouseButton, pressed: bool) { + let e = &self.settings.extras; + if e.zoom && e.zoom_key == keybinds::mouse_name(button) { + self.extras.zoom.key(pressed, false, true, e.zoom_level); + } let i = match button { MouseButton::Left => 0, MouseButton::Right => 1, diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs index dcc7bb23b..e8057cf31 100644 --- a/crates/horizon-client/src/game/options.rs +++ b/crates/horizon-client/src/game/options.rs @@ -186,16 +186,11 @@ impl Game<'_> { } /// Mouse buttons pressed while a key is being bound. pub(super) fn options_waiting_for_key(&self) -> bool { - self.ui.options.selected_key.is_some() && self.ui.options.page() == Page::KeyBinds + self.ui.options.selected_key.is_some() } pub(super) fn options_bind_mouse(&mut self, button: MouseButton) -> Result<()> { - if let Some(name) = self.ui.options.selected_key.take() { - self.settings - .keys - .set(name, &horizon_client::keybinds::mouse_name(button)); - self.handle_option_events(vec![Event::Changed])?; - } - Ok(()) + let events = self.ui.options.bind_mouse(&mut self.settings, button); + self.handle_option_events(events) } pub(super) fn handle_option_events(&mut self, events: Vec) -> Result<()> { for e in events { diff --git a/crates/horizon-client/src/game/tweaks.rs b/crates/horizon-client/src/game/tweaks.rs index dc87a13bf..018b6640b 100644 --- a/crates/horizon-client/src/game/tweaks.rs +++ b/crates/horizon-client/src/game/tweaks.rs @@ -28,7 +28,7 @@ use horizon_client::{ menu::Input, stations::hover_name, }; -use winit::keyboard::KeyCode; +use winit::{event::MouseButton, keyboard::KeyCode}; /// A sort button's side in GUI pixels. const SORT_BUTTON: f32 = 9.0; @@ -377,8 +377,14 @@ impl Game<'_> { /// The sort key: sorts the part under the cursor (the container when /// the cursor is over no slot). pub(super) fn sort_key_press(&mut self, key: KeyCode) -> bool { + keybinds::key_name(key).is_some_and(|name| self.sort_input(name)) + } + pub(super) fn sort_mouse_press(&mut self, button: MouseButton) -> bool { + self.sort_input(&keybinds::mouse_name(button)) + } + fn sort_input(&mut self, name: &str) -> bool { let e = &self.settings.extras; - if !e.sort || keybinds::key_code(&e.sort_key) != Some(key) || self.recipe_search_focused() { + if !e.sort || e.sort_key != name || self.recipe_search_focused() { return false; } let buttons = self.sort_buttons(); diff --git a/crates/horizon-client/src/options_horizon.rs b/crates/horizon-client/src/options_horizon.rs index bfaf05c9b..634bb8d75 100644 --- a/crates/horizon-client/src/options_horizon.rs +++ b/crates/horizon-client/src/options_horizon.rs @@ -587,9 +587,16 @@ impl OptionsUi { } return events; } - // A click anywhere stops waiting for an extra's key. + // Rebinding consumes the click before sidebar or widget actions. if matches!(self.selected_key, Some(extras::ZOOM_KEY | extras::SORT_KEY)) { - self.selected_key = None; + return self.bind_mouse( + s, + if right { + winit::event::MouseButton::Right + } else { + winit::event::MouseButton::Left + }, + ); } match self.horizon_target(s, atlas, x, y) { Some(Target::Nav(i)) => { diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 38be29576..6606d31fd 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -1876,15 +1876,13 @@ impl OptionsUi { return events; } // Key Binds: a mouse button pressed while waiting binds it. - if let Some(name) = self.selected_key.take() { + if self.selected_key.is_some() { let button = if right { - "key.mouse.right" + winit::event::MouseButton::Right } else { - "key.mouse.left" + winit::event::MouseButton::Left }; - s.keys.set(name, button); - events.push(Event::Changed); - return events; + return self.bind_mouse(s, button); } // AbstractWidget accepts only the primary button. Rebinding above // accepts other mouse buttons, but is not a widget activation. @@ -2126,6 +2124,23 @@ impl OptionsUi { } false } + fn bind_key(&mut self, s: &mut Settings, value: String) -> Vec { + let Some(name) = self.selected_key.take() else { + return Vec::new(); + }; + if !s.extras.set_key(name, value.clone()) { + s.keys.set(name, &value); + } + vec![Event::Changed] + } + /// Mouse bindings use the same settings and persistence as keyboard bindings. + pub fn bind_mouse( + &mut self, + s: &mut Settings, + button: winit::event::MouseButton, + ) -> Vec { + self.bind_key(s, keybinds::mouse_name(button)) + } /// Keys while the options are open. Returns events; `handled` false lets /// Escape fall through. pub fn key( @@ -2160,7 +2175,7 @@ impl OptionsUi { } return vec![Event::Changed]; } - if let Some(name) = self.selected_key.take() { + if self.selected_key.is_some() { // KeyBindsScreen.keyPressed: Escape unbinds. let value = if key == K::Escape { "key.keyboard.unknown".to_owned() @@ -2169,10 +2184,7 @@ impl OptionsUi { .unwrap_or("key.keyboard.unknown") .to_owned() }; - if !s.extras.set_key(name, value.clone()) { - s.keys.set(name, &value); - } - return vec![Event::Changed]; + return self.bind_key(s, value); } if key == K::Escape { return self.back(s); @@ -2831,6 +2843,55 @@ mod tests { } } + #[test] + fn extras_and_vanilla_bindings_accept_mouse_buttons() { + use crate::extras::{Extras, SORT_KEY, ZOOM_KEY}; + use winit::event::MouseButton; + for button in [ + MouseButton::Left, + MouseButton::Right, + MouseButton::Middle, + MouseButton::Back, + MouseButton::Forward, + ] { + for name in [SORT_KEY, ZOOM_KEY, "key.jump"] { + let mut ui = OptionsUi::default(); + let mut s = Settings::default(); + ui.selected_key = Some(name); + assert_eq!(ui.bind_mouse(&mut s, button), vec![Event::Changed]); + assert_eq!(ui.selected_key, None); + let value = keybinds::mouse_name(button); + match name { + SORT_KEY => assert_eq!(s.extras.sort_key, value), + ZOOM_KEY => assert_eq!(s.extras.zoom_key, value), + _ => assert_eq!(s.keys.get(name), value), + } + assert_eq!(Extras::parse(&s.extras.serialize()), s.extras); + if name != "key.jump" { + assert_eq!(s.keys, Settings::default().keys); + } + assert!(ui.bind_mouse(&mut s, button).is_empty()); + } + } + } + + #[test] + fn horizon_extra_mouse_binding_consumes_the_click() { + let atlas = atlas(); + let mut s = Settings::default(); + let mut ui = OptionsUi::default(); + for (right, expected) in [(false, "key.mouse.left"), (true, "key.mouse.right")] { + ui.selected_key = Some(crate::extras::SORT_KEY); + assert_eq!( + ui.click_horizon(&mut s, &atlas, 2.0, 2.0, [960, 480], false, right), + vec![Event::Changed] + ); + assert_eq!(s.extras.sort_key, expected); + assert_eq!(ui.selected_key, None); + assert_eq!(ui.section, 0); + } + } + #[test] fn key_rebinding_takes_precedence_over_scrollbar_dragging() { let atlas = atlas(); From b174299f2527fd55cd5d988c2a16ad9040131c8d Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:37:36 -0400 Subject: [PATCH 15/19] Match vanilla player render scale and inventory title height --- crates/horizon-client/src/game.rs | 9 +-------- crates/horizon-client/src/game/perspective.rs | 17 +++++++++++++++++ crates/horizon-client/src/mobs/render.rs | 4 ++++ 3 files changed, 22 insertions(+), 8 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 5ffcd9124..e4fd53062 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4336,14 +4336,7 @@ impl Game<'_> { } else { ("Crafting", 97.0) }; - batch.text( - atlas, - title, - ox + tx, - oy + if self.craft_size == 3 { 6.0 } else { 8.0 }, - grey, - false, - ); + batch.text(atlas, title, ox + tx, oy + 6.0, grey, false); if self.craft_size == 3 { batch.text(atlas, "Inventory", ox + 8.0, oy + 72.0, grey, false); } diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index a66ca487d..e09d06244 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -619,6 +619,23 @@ fn player_preview_quads( #[cfg(test)] mod preview_tests { use super::*; + #[test] + #[ignore = "requires prepared model data in HORIZON_TEST_RESOURCES"] + fn player_render_transform_uses_vanilla_avatar_scale() { + let root = std::path::PathBuf::from( + std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"), + ); + let mut m = Mob::new(1, player_type(&root).unwrap(), Vec3::ZERO, 0.0); + for (id, expected) in [("minecraft:player", 0.9375), ("minecraft:zombie", 1.0)] { + Arc::make_mut(&mut m.kind).id = id.into(); + let transform = + horizon_client::mobs::render::base_transform_at(&m, 1.0, glam::Mat4::IDENTITY); + for axis in [glam::Vec3::X, glam::Vec3::Y, glam::Vec3::Z] { + assert!((transform.transform_vector3(axis).length() - expected).abs() < 1e-6); + } + } + } + #[test] fn burning_inventory_preview_keeps_visible_fullbright_flames() { let rect = |u0| horizon_client::hud::Rect { diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 4c312e5fd..e8120e92e 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -847,6 +847,10 @@ fn red_overlay(m: &Mob) -> bool { m.hurt_time > 0 || (m.death_time > 0 && !super::creaking::tearing_down(m)) } fn species_scale(m: &Mob, alpha: f32) -> glam::Mat4 { + if m.kind.id == "minecraft:player" { + // AvatarRenderer.scale, shared by the inventory and world renderer. + return glam::Mat4::from_scale(glam::Vec3::splat(0.9375)); + } match m.species() { Species::Wither => { glam::Mat4::from_scale(glam::Vec3::splat(super::wither::scale(m, alpha))) From 8fa5c3866328ea6ae2879a0b750f3726a9a4eeba Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:42:01 -0400 Subject: [PATCH 16/19] Add an optional Fullbright extra --- crates/horizon-client/src/extras.rs | 18 ++++++++++++++++-- crates/horizon-client/src/game/options.rs | 1 + crates/horizon-client/src/gfx.rs | 6 ++++++ docs/extras.md | 7 ++++++- 4 files changed, 29 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/extras.rs b/crates/horizon-client/src/extras.rs index 264456c1a..ee142486c 100644 --- a/crates/horizon-client/src/extras.rs +++ b/crates/horizon-client/src/extras.rs @@ -68,6 +68,7 @@ impl Corner { #[derive(Clone, Debug, PartialEq)] pub struct Extras { + pub fullbright: bool, pub zoom: bool, /// A vanilla key name (`key.keyboard.z`). pub zoom_key: String, @@ -108,6 +109,7 @@ pub struct Extras { impl Default for Extras { fn default() -> Self { Self { + fullbright: false, zoom: false, zoom_key: "key.keyboard.z".into(), zoom_level: 4, @@ -155,6 +157,7 @@ impl Extras { _ => d, }; match key.trim() { + "fullbright" => e.fullbright = flag(e.fullbright), "zoom" => e.zoom = flag(e.zoom), "zoomKey" if value.starts_with("key.") => e.zoom_key = value.to_owned(), "zoomLevel" => { @@ -198,7 +201,8 @@ impl Extras { } pub fn serialize(&self) -> String { format!( - "zoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n", + "fullbright:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n", + bool_text(self.fullbright), bool_text(self.zoom), self.zoom_key, self.zoom_level, @@ -418,6 +422,7 @@ impl Cps { /// The settings the Extras page shows, one per row. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Item { + Fullbright, Zoom, ZoomKey, ZoomLevel, @@ -445,6 +450,8 @@ pub enum Item { pub fn rows() -> Vec> { use Item::*; vec![ + Err("Lighting"), + Ok(Fullbright), Err("Zoom"), Ok(Zoom), Ok(ZoomKey), @@ -493,6 +500,7 @@ fn next(all: &[T], current: T, back: bool) -> T { impl Item { pub fn caption(self) -> &'static str { match self { + Item::Fullbright => "Fullbright", Item::Zoom => "Zoom", Item::ZoomKey => "Zoom key", Item::ZoomLevel => "Starting zoom", @@ -518,6 +526,7 @@ impl Item { /// What the row says under its caption. pub fn description(self) -> &'static str { match self { + Item::Fullbright => "Show blocks and entities at full light, even in dark areas.", Item::Zoom => "Hold the zoom key to zoom; the wheel changes it while held.", Item::ZoomKey => "Click, then press a key. Escape unbinds it.", Item::ZoomLevel => "The zoom the key starts at.", @@ -556,7 +565,7 @@ impl Item { pub fn cost(self) -> Option { use crate::graphics_style::Cost; match self { - Item::Zoom | Item::Fps | Item::Keystrokes => Some(Cost::None), + Item::Fullbright | Item::Zoom | Item::Fps | Item::Keystrokes => Some(Cost::None), Item::Minimap => Some(Cost::Low), Item::AutoReconnect | Item::MouseTweaks | Item::Sort => Some(Cost::None), _ => None, @@ -565,6 +574,7 @@ impl Item { /// On/off items and their value. pub fn switch(self, e: &Extras) -> Option { Some(match self { + Item::Fullbright => e.fullbright, Item::Zoom => e.zoom, Item::ZoomSmooth => e.zoom_smooth, Item::ZoomSensitivity => e.zoom_sensitivity, @@ -606,6 +616,7 @@ impl Item { /// A click (`back` for the right button). The zoom key binds instead. pub fn cycle(self, e: &mut Extras, back: bool) { match self { + Item::Fullbright => e.fullbright = !e.fullbright, Item::Zoom => e.zoom = !e.zoom, Item::ZoomSmooth => e.zoom_smooth = !e.zoom_smooth, Item::ZoomSensitivity => e.zoom_sensitivity = !e.zoom_sensitivity, @@ -651,11 +662,14 @@ mod tests { #[test] fn everything_is_off_by_default_and_round_trips() { let d = Extras::default(); + assert!(!d.fullbright); assert!(!d.zoom && !d.fps && !d.keystrokes && !d.minimap && !d.auto_reconnect); assert!(!d.mouse_tweaks && !d.sort); assert_eq!(Extras::parse(""), d); assert_eq!(Extras::parse(&d.serialize()), d); let mut e = d.clone(); + Item::Fullbright.cycle(&mut e, false); + assert_eq!(Item::Fullbright.switch(&e), Some(true)); e.zoom = true; e.zoom_key = "key.keyboard.c".into(); e.zoom_level = 6; diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs index dcc7bb23b..86a2f789e 100644 --- a/crates/horizon-client/src/game/options.rs +++ b/crates/horizon-client/src/game/options.rs @@ -244,6 +244,7 @@ impl Game<'_> { let s = &self.settings; if let Some(r) = self.renderer.as_mut() { r.gamma = s.gamma; + r.fullbright = s.extras.fullbright; r.set_present_mode(s.vsync, s.horizon.present_mode); r.animated_textures = s.horizon.animated_textures; r.set_mipmap_levels(s.mipmap_levels.max(0) as u32); diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 4401ea22d..26f596185 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -348,6 +348,8 @@ pub struct Renderer { pub screenshot_result: Option>, /// Brightness option (lightmap gamma), 0..1. pub gamma: f32, + /// Optional full-light lightmap (Horizon Extras). + pub fullbright: bool, /// Advance animated block textures (Horizon setting; vanilla always does). pub animated_textures: bool, present_modes: Vec, @@ -1616,6 +1618,7 @@ impl Renderer { screenshot: None, screenshot_result: None, gamma: 0.5, + fullbright: false, animated_textures: true, present_modes, }) @@ -1972,6 +1975,9 @@ impl Renderer { pixels[i + 3] = 255; } } + if self.fullbright { + pixels.fill(255); + } // The lightmap changes with the time of day, flicker and effects, // not every frame: upload only what differs from the texture. if pixels == self.lightmap_pixels && self.lightmap_uploaded { diff --git a/docs/extras.md b/docs/extras.md index 4129a88eb..3c952d5ac 100644 --- a/docs/extras.md +++ b/docs/extras.md @@ -1,6 +1,6 @@ # Horizon extras -Optional conveniences built into the client: zoom, a minimap, an FPS counter, a +Optional conveniences built into the client: fullbright, zoom, a minimap, an FPS counter, a keystroke overlay, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. **Every one is off by default**: a fresh install looks and behaves exactly like vanilla 26.3, and turning an extra off @@ -36,6 +36,11 @@ Horizon category in Controls, and adding one would put a non-vanilla mapping int ## The extras +### Fullbright (`fullbright`, default off) +- Displays blocks and entities with a fully bright lightmap, including in dark caves. +- Turning it off restores the normal lightmap using the current brightness, + time of day and effects. The brightness slider keeps its normal range. + ### Zoom (`zoom`, default off) - Hold the zoom key (default **Z**, unused by every vanilla 26.3 key mapping; C is `key.saveToolbarActivator`) to zoom. The key does nothing while zoom is off. From cf7ed868b90cdd64c7434708ca8a9d9fa5585644 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:46:47 -0400 Subject: [PATCH 17/19] Light redstone ore when mining begins --- crates/horizon-client/src/game.rs | 7 +++++++ crates/horizon-client/src/game/hand.rs | 5 ++++- crates/horizon-world/src/level/interact.rs | 16 ++++++++++++++++ crates/horizon-world/src/level/tests.rs | 21 +++++++++++++++++++++ 4 files changed, 48 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 5ffcd9124..cc17dc64a 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1777,6 +1777,12 @@ impl Game<'_> { }); self.process_level_events() } + fn attack_block(&mut self, pos: [i32; 3]) -> Result<()> { + self.with_level(|b, level, ticks| { + b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2])); + }); + self.process_level_events() + } /// Track which chunks are ticking (Ticks needs chunk load/unload). fn sync_tick_chunks(&mut self) { if !self.tick_chunks.synchronize(&self.world.chunks) { @@ -2885,6 +2891,7 @@ impl Game<'_> { return Ok(()); } if self.mining.as_ref().is_none_or(|m| m.pos != hit.pos) { + self.attack_block(hit.pos)?; self.mining = Some(Mining { pos: hit.pos, progress: 0.0, diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs index 431e6661a..a932913af 100644 --- a/crates/horizon-client/src/game/hand.rs +++ b/crates/horizon-client/src/game/hand.rs @@ -409,7 +409,10 @@ impl HandWorld for GameHands<'_, '_> { fn within_border(&mut self, _: [i32; 3]) -> bool { true } - fn attack_block(&mut self, _: [i32; 3]) {} + fn attack_block(&mut self, pos: [i32; 3]) { + let result = self.game.attack_block(pos); + self.keep(result); + } fn destroy_progress(&mut self, pos: [i32; 3]) -> f32 { self.game.destroy_progress(pos) } diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs index 791daf7c2..c38d81f26 100644 --- a/crates/horizon-world/src/level/interact.rs +++ b/crates/horizon-world/src/level/interact.rs @@ -513,6 +513,22 @@ impl Behaviours { sim.game_event_state(pos, "minecraft:block_change", next); } + /// The state change of `RedStoneOreBlock.attack` when mining begins. + pub fn attack_block( + &self, + level: &mut L, + ticks: &mut Ticks, + pos: BlockPos, + ) { + let mut sim = self.sim(level, ticks); + let state = sim.state(pos); + if self.data(state).chain.contains(&Class::RedStoneOre) + && !self.table.bool(state, self.props.lit) + { + sim.set_block_and_update(pos, self.table.set_bool(state, self.props.lit, true)); + } + } + /// `BlockState.useWithoutItem` for a right-click on `pos` (hit face and /// absolute hit location as in `BlockHitResult`). pub fn use_without_item( diff --git a/crates/horizon-world/src/level/tests.rs b/crates/horizon-world/src/level/tests.rs index 270ee48fa..c0ceddc6f 100644 --- a/crates/horizon-world/src/level/tests.rs +++ b/crates/horizon-world/src/level/tests.rs @@ -634,6 +634,27 @@ impl World<'_> { } } +#[test] +fn mining_lights_redstone_ore_until_its_random_tick() { + let mut w = world!(); + let pos = BlockPos::new(0, 1, 0); + for ore in ["redstone_ore", "deepslate_redstone_ore"] { + let unlit = w.id(ore, &[("lit", "false")]); + let lit = w.id(ore, &[("lit", "true")]); + w.put(pos, unlit); + w.b().attack_block(&mut w.level, &mut w.ticks, pos); + assert_eq!(w.get(pos), lit); + w.b().attack_block(&mut w.level, &mut w.ticks, pos); + assert_eq!(w.get(pos), lit); + w.b().random_tick(&mut w.level, &mut w.ticks, pos); + assert_eq!(w.get(pos), unlit); + } + let stone = w.id("stone", &[]); + w.put(pos, stone); + w.b().attack_block(&mut w.level, &mut w.ticks, pos); + assert_eq!(w.get(pos), stone); +} + #[test] fn placement_orients_blocks() { let mut w = world!(); From 6d8b1742167d79e619aa3abe34367c377072f4e6 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 22:03:57 -0400 Subject: [PATCH 18/19] Depth-test inventory preview equipment and clip it with a scissor --- crates/horizon-client/src/game/perspective.rs | 51 +++++- crates/horizon-client/src/gfx.rs | 1 + crates/horizon-client/src/hud.rs | 166 +++++++++++++++--- crates/horizon-client/src/hud.wgsl | 4 +- crates/horizon-client/src/ui_theme.rs | 1 + 5 files changed, 194 insertions(+), 29 deletions(-) diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index e09d06244..bb463547f 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -427,7 +427,7 @@ impl Game<'_> { } /// `extractEntityInInventoryFollowsMouse`: the player in the box /// `[x0, x1) x [y0, y1)`, `size` pixels per block, turned toward the - /// cursor; drawn as depth-sorted, back-face-culled quads. + /// cursor; drawn with a depth buffer and back-face culling. #[allow(clippy::too_many_arguments)] pub(super) fn draw_player_preview( &self, @@ -495,9 +495,9 @@ impl Game<'_> { let quads = player_preview_quads(verts, gui, fire, &atlas.sprites); let start = batch.vertices.len(); for (_, p, uv, color) in quads { - batch.quad(p, uv, color); + batch.quad_3d(p, uv, color); } - batch.clip_since(start, x0, y0, x1, y1); + batch.depth_since(start, [x0, y0, x1, y1]); } /// The survival inventory's player box (`InventoryScreen`). pub(super) fn draw_inventory_player(&self, batch: &mut HudBatch, ox: f32, oy: f32) { @@ -570,7 +570,7 @@ fn player_preview_quads( gui: glam::Mat4, fire: Option<(f32, f32)>, sprites: &std::collections::HashMap, -) -> Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], u32)> { +) -> Vec<(f32, [[f32; 3]; 4], [[f32; 2]; 4], u32)> { let flame_start = verts.len(); if let Some((width, height)) = fire { horizon_client::fire_render::flames( @@ -584,7 +584,7 @@ fn player_preview_quads( &mut verts, ); } - let mut quads: Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], u32)> = Vec::new(); + let mut quads: Vec<(f32, [[f32; 3]; 4], [[f32; 2]; 4], u32)> = Vec::new(); for (index, q) in verts.as_chunks::<4>().0.iter().enumerate() { let p: [glam::Vec3; 4] = std::array::from_fn(|i| gui.transform_point3(glam::Vec3::from_array(q[i].pos))); @@ -606,12 +606,12 @@ fn player_preview_quads( let depth = p.iter().map(|v| v.z).sum::() / 4.0; quads.push(( depth, - p.map(|v| [v.x, v.y]), + p.map(|v| v.to_array()), std::array::from_fn(|i| q[i].uv), color, )); } - // Far (low z) first: the viewer is on the +z side. + // Keep far-to-near order for translucent faces; opaque overlap uses depth. quads.sort_by(|a, b| a.0.total_cmp(&b.0)); quads } @@ -619,6 +619,43 @@ fn player_preview_quads( #[cfg(test)] mod preview_tests { use super::*; + #[test] + fn preview_keeps_crossing_faces_depth_and_clips_without_dropping_faces() { + use horizon_client::{ + hud::{Blend, HudBatch}, + mesher::Vertex, + }; + let face = |z: [f32; 4]| { + [[-2.0, -1.0], [-2.0, 1.0], [2.0, 1.0], [2.0, -1.0]] + .into_iter() + .zip(z) + .map(|([x, y], z)| Vertex { + pos: [x, y, z], + uv: [0.0; 2], + layer: 0, + color: u32::MAX, + light: 0, + normal: [0; 4], + }) + }; + // A shield and arm can intersect: neither average depth orders both ends. + let verts = face([1.0, 1.0, -1.0, -1.0]).chain(face([0.0; 4])).collect(); + let quads = player_preview_quads(verts, glam::Mat4::IDENTITY, None, &Default::default()); + assert_eq!(quads.len(), 2); + let mut batch = HudBatch::new([320, 240]); + for (_, p, uv, color) in quads { + batch.quad_3d(p, uv, color); + } + // Its centre is outside this scissor; the visible part must still be drawn. + batch.depth_since(0, [1.0, 0.0, 2.0, 1.0]); + assert_eq!(batch.vertices.len(), 12); + let shield = &batch.vertices[..6]; + let arm = &batch.vertices[6..]; + assert!(shield[0].depth < arm[0].depth); + assert!(shield[2].depth > arm[2].depth); + assert_eq!(batch.runs(), vec![(0..12, Blend::Depth([1, 0, 1, 1]))]); + } + #[test] #[ignore = "requires prepared model data in HORIZON_TEST_RESOURCES"] fn player_render_transform_uses_vanilla_avatar_scale() { diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 4401ea22d..0e1ccb920 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -2776,6 +2776,7 @@ impl Renderer { &mut self.uploads, &mut encoder, &view_target, + &self.depth, frame.hud, [self.config.width, self.config.height], ); diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 77ba0e342..c5462eaee 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -319,6 +319,7 @@ pub struct HudVertex { pub pos: [f32; 2], pub uv: [f32; 2], pub color: u32, + pub depth: f32, } /// The GUI Scale option (0 = auto). pub static GUI_SCALE: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0); @@ -330,10 +331,10 @@ pub struct HudBatch { pub height: f32, /// Glyph pixels to upload into the atlas before drawing. pub patches: Vec, - /// Vertex ranges drawn with another blend than alpha blending, in order. + /// Vertex ranges with another blend or depth/scissor state, in order. pub blends: Vec<(std::ops::Range, Blend)>, } -/// How a run of HUD vertices blends with what is under it. +/// How a run of HUD vertices blends and tests depth. #[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum Blend { /// `BlendFunction.TRANSLUCENT`. @@ -342,6 +343,8 @@ pub enum Blend { Invert, /// `BlendFunction.ADDITIVE` (`RenderPipelines.GUI_TEXT_HIGHLIGHT`). Additive, + /// Alpha blending with an isolated depth buffer and a pixel scissor. + Depth([u32; 4]), } pub fn rgba(r: u8, g: u8, b: u8, a: u8) -> u32 { u32::from(a) << 24 | u32::from(b) << 16 | u32::from(g) << 8 | u32::from(r) @@ -430,9 +433,44 @@ impl HudBatch { pos: p[i], uv: uv[i], color, + depth: 0.0, }); } } + pub fn quad_3d(&mut self, p: [[f32; 3]; 4], uv: [[f32; 2]; 4], color: u32) { + for i in [0, 1, 2, 0, 2, 3] { + self.vertices.push(HudVertex { + pos: [p[i][0], p[i][1]], + uv: uv[i], + color, + depth: p[i][2], + }); + } + } + /// Keep per-vertex depth for an orthographic GUI model, with +z toward the viewer. + pub fn depth_since(&mut self, start: usize, clip: [f32; 4]) { + let vertices = &mut self.vertices[start..]; + if vertices.is_empty() { + return; + } + let min = vertices + .iter() + .map(|v| v.depth) + .fold(f32::INFINITY, f32::min); + let max = vertices + .iter() + .map(|v| v.depth) + .fold(f32::NEG_INFINITY, f32::max); + for v in vertices { + v.depth = (max - v.depth) / (max - min).max(f32::EPSILON); + } + let [x0, y0, x1, y1] = clip.map(|v| (v * self.scale).max(0.0) as u32); + // Separate previews clear depth independently, even if their scissors match. + self.blends.push(( + start as u32..self.vertices.len() as u32, + Blend::Depth([x0, y0, x1.saturating_sub(x0), y1.saturating_sub(y0)]), + )); + } pub fn rect_uv(&mut self, x: f32, y: f32, w: f32, h: f32, r: Rect, color: u32) { self.quad( [[x, y], [x + w, y], [x + w, y + h], [x, y + h]], @@ -569,6 +607,7 @@ impl HudBatch { pos: p[i], uv, color: c[i], + depth: 0.0, }); } } @@ -729,6 +768,7 @@ pub struct HudRenderer { /// `RenderPipelines.CROSSHAIR`. invert_pipeline: wgpu::RenderPipeline, additive_pipeline: wgpu::RenderPipeline, + depth_pipeline: wgpu::RenderPipeline, group: wgpu::BindGroup, uniform: wgpu::Buffer, buffer: wgpu::Buffer, @@ -808,8 +848,8 @@ impl HudRenderer { bind_group_layouts: &[Some(&layout)], ..Default::default() }); - let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4]; - let create = |label, blend, fragment_entry| { + let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32]; + let create = |label, blend, fragment_entry, depth: bool| { device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some(label), layout: Some(&pipeline_layout), @@ -824,7 +864,13 @@ impl HudRenderer { })], }, primitive: Default::default(), - depth_stencil: None, + depth_stencil: depth.then_some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(true), + depth_compare: Some(wgpu::CompareFunction::LessEqual), + stencil: Default::default(), + bias: Default::default(), + }), multisample: Default::default(), fragment: Some(wgpu::FragmentState { module: &shader, @@ -840,7 +886,13 @@ impl HudRenderer { cache: None, }) }; - let pipeline = create("HUD", wgpu::BlendState::ALPHA_BLENDING, "fs_main"); + let pipeline = create("HUD", wgpu::BlendState::ALPHA_BLENDING, "fs_main", false); + let depth_pipeline = create( + "HUD model", + wgpu::BlendState::ALPHA_BLENDING, + "fs_main", + true, + ); // BlendFunction.INVERT: ONE_MINUS_DST_COLOR, ONE_MINUS_SRC_COLOR, // ONE, ZERO. let invert_pipeline = create( @@ -858,6 +910,7 @@ impl HudRenderer { }, }, "fs_crosshair", + false, ); // BlendFunction.ADDITIVE: ONE, ONE. let add = wgpu::BlendComponent { @@ -872,6 +925,7 @@ impl HudRenderer { alpha: add, }, "fs_main", + false, ); let capacity = 1 << 16; let buffer = device.create_buffer(&wgpu::BufferDescriptor { @@ -886,6 +940,7 @@ impl HudRenderer { pipeline, invert_pipeline, additive_pipeline, + depth_pipeline, group, uniform, buffer, @@ -935,6 +990,7 @@ impl HudRenderer { uploads: &mut crate::gfx::upload::Uploads, encoder: &mut wgpu::CommandEncoder, target: &wgpu::TextureView, + depth: &wgpu::TextureView, batch: &HudBatch, size: [u32; 2], ) { @@ -965,7 +1021,7 @@ impl HudRenderer { ); } } - if batch.vertices.is_empty() { + if batch.vertices.is_empty() || size.contains(&0) { return; } let count = batch.vertices.len() as u64; @@ -1001,20 +1057,55 @@ impl HudRenderer { store: wgpu::StoreOp::Store, }, })]; - let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { - label: Some("HUD"), - color_attachments: &attachments, - ..Default::default() - }); - pass.set_bind_group(0, &self.group, &[]); - pass.set_vertex_buffer(0, self.buffer.slice(..)); - for (range, blend) in batch.runs() { - pass.set_pipeline(match blend { - Blend::Alpha => &self.pipeline, - Blend::Invert => &self.invert_pipeline, - Blend::Additive => &self.additive_pipeline, + let runs = batch.runs(); + let mut at = 0; + while at < runs.len() { + let clip = match runs[at].1 { + Blend::Depth(clip) => Some(clip), + _ => None, + }; + let end = if clip.is_some() { + at + 1 + } else { + runs[at..] + .iter() + .position(|(_, b)| matches!(b, Blend::Depth(_))) + .map_or(runs.len(), |n| at + n) + }; + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("HUD"), + color_attachments: &attachments, + depth_stencil_attachment: clip.map(|_| wgpu::RenderPassDepthStencilAttachment { + view: depth, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Clear(1.0), + store: wgpu::StoreOp::Discard, + }), + stencil_ops: None, + }), + ..Default::default() }); - pass.draw(range, 0..1); + pass.set_bind_group(0, &self.group, &[]); + pass.set_vertex_buffer(0, self.buffer.slice(..)); + if let Some([x, y, w, h]) = clip { + let (x, y) = (x.min(size[0]), y.min(size[1])); + let (w, h) = (w.min(size[0] - x), h.min(size[1] - y)); + if w == 0 || h == 0 { + at = end; + continue; + } + pass.set_scissor_rect(x, y, w, h); + } + for (range, blend) in &runs[at..end] { + pass.set_pipeline(match blend { + Blend::Alpha => &self.pipeline, + Blend::Invert => &self.invert_pipeline, + Blend::Additive => &self.additive_pipeline, + Blend::Depth(_) => &self.depth_pipeline, + }); + pass.draw(range.clone(), 0..1); + } + at = end; } } } @@ -1092,6 +1183,41 @@ mod tests { fs::remove_dir_all(root).unwrap(); } + #[test] + fn gui_models_keep_separate_depth_runs_between_overlay_draws() { + let mut batch = HudBatch::new([640, 480]); + batch.scale = 2.0; + let p = [ + [0.0, 0.0, 2.0], + [0.0, 1.0, 2.0], + [1.0, 1.0, 2.0], + [1.0, 0.0, 2.0], + ]; + let uv = [[0.0; 2]; 4]; + batch.quad([[0.0; 2]; 4], uv, u32::MAX); + for _ in 0..2 { + let start = batch.vertices.len(); + batch.quad_3d(p, uv, u32::MAX); + batch.depth_since(start, [1.0, 2.0, 4.0, 6.0]); + } + batch.quad([[0.0; 2]; 4], uv, u32::MAX); + assert_eq!( + batch.runs(), + vec![ + (0..6, Blend::Alpha), + (6..12, Blend::Depth([2, 4, 6, 8])), + (12..18, Blend::Depth([2, 4, 6, 8])), + (18..24, Blend::Alpha), + ] + ); + assert!( + batch + .vertices + .iter() + .all(|v| v.depth.is_finite() && (0.0..=1.0).contains(&v.depth)) + ); + } + #[test] fn hud_shader_validates_both_fragment_entries() { let module = naga::front::wgsl::parse_str(include_str!("hud.wgsl")).unwrap(); diff --git a/crates/horizon-client/src/hud.wgsl b/crates/horizon-client/src/hud.wgsl index 055bfc1f1..17d50d51a 100644 --- a/crates/horizon-client/src/hud.wgsl +++ b/crates/horizon-client/src/hud.wgsl @@ -7,10 +7,10 @@ struct Out { @location(0) uv: vec2, @location(1) color: vec4, } -@vertex fn vs_main(@location(0) pos: vec2, @location(1) uv: vec2, @location(2) color: vec4) -> Out { +@vertex fn vs_main(@location(0) pos: vec2, @location(1) uv: vec2, @location(2) color: vec4, @location(3) depth: f32) -> Out { let pixels = pos * hud.size.z; var out: Out; - out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, 0.0, 1.0); + out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, depth, 1.0); out.uv = uv; out.color = color; return out; diff --git a/crates/horizon-client/src/ui_theme.rs b/crates/horizon-client/src/ui_theme.rs index 1c41add9d..d5073bec9 100644 --- a/crates/horizon-client/src/ui_theme.rs +++ b/crates/horizon-client/src/ui_theme.rs @@ -690,6 +690,7 @@ impl<'a> Ui<'a> { pos: p[i], uv: [cu, cv], color: c[i], + depth: 0.0, }); } } From 0da61e660b3dc636e1583c5ebf687d54f9c6e923 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 04:08:08 +0200 Subject: [PATCH 19/19] CI parity: raise the per-harness timeout to 2400 s world_spawn now takes about 1480 s on a loaded Mac mini runner, just under the old 1500 s limit, so PRs failed on a timeout rather than a mismatch (#567, #514). Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index bbb8b3b84..5d5e285c5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -83,7 +83,7 @@ jobs: - name: The harnesses this change can affect env: PARITY_HOSTS: '' - run: python3 tools/parity.py --changed ${{ github.event.pull_request.base.sha }} --timeout 1500 + run: python3 tools/parity.py --changed ${{ github.event.pull_request.base.sha }} --timeout 2400 # world_spawn takes ~1480 s on a busy runner - name: Logs of the failed harnesses if: failure() uses: actions/upload-artifact@v4