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/28] 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/28] 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/28] 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/28] 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/28] 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 ddc115e969690c3a868283b540af534cc9465310 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 23:24:34 +0200 Subject: [PATCH 06/28] Content mods: load real carried-over mods (large tables, convention tags, mod recipes) Loading seven real NeoForge mods carried over by horizon-port-pack (about 1,000 blocks) broke the content root in four places: - The per-state NBT tables (cached collision, occlusion, movement, worldgen block properties and support) passed the NBT reader's 1M-node cap once mod states were appended. They are trusted prepared tables with a row per state, so they now read and write with Limits::tables() (16M nodes, 256 MiB) everywhere they are loaded. - The overlay linked the base root by the path it was given, so a relative base gave dangling links. The base is made absolute first. - Carried-over tags name blocks the port left out and other mods' items. Vanilla fails such a tag as a whole; entries naming ids nobody registers (or tags nobody defines) are now dropped, so the rest loads. - Mods use the convention tags (c:dyes/red, c:glass_blocks/colorless). Content mods may add to data/c/tags/ as to vanilla's, and with content mods loaded the tag loaders read the c namespace and the mods' own. Stonecutter and smithing recipes in mod namespaces load too (ids :), as crafting and cooking ones already did. With no content mod nothing changes: the loaders read the minecraft namespace only. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/collisions.rs | 2 +- crates/horizon-client/src/items.rs | 20 +++-- crates/horizon-client/src/light.rs | 2 +- crates/horizon-client/src/mod_content.rs | 83 ++++++++++++++++++- .../horizon-client/src/mod_content_tests.rs | 22 ++++- crates/horizon-client/src/models.rs | 2 +- crates/horizon-client/src/motion.rs | 2 +- crates/horizon-client/src/stations.rs | 27 +++--- crates/horizon-mods/src/content.rs | 16 ++-- crates/horizon-world/src/nbt.rs | 12 +++ .../src/worldgen/generator_blocks.rs | 14 ++-- docs/mods.md | 9 +- 12 files changed, 168 insertions(+), 43 deletions(-) diff --git a/crates/horizon-client/src/collisions.rs b/crates/horizon-client/src/collisions.rs index 39fde56b5..d3e00daca 100644 --- a/crates/horizon-client/src/collisions.rs +++ b/crates/horizon-client/src/collisions.rs @@ -28,7 +28,7 @@ use std::{fs, io, path::Path, sync::Arc}; pub fn load<'r>(root: &Path, registry: &'r BlockRegistry) -> Result> { let data = nbt::read_named( &fs::read(root.join("cached-collision.nbt"))?, - Limits::default(), + Limits::tables(), )? .0 .tag; diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs index 0aca99cef..54a505ab9 100644 --- a/crates/horizon-client/src/items.rs +++ b/crates/horizon-client/src/items.rs @@ -274,16 +274,20 @@ pub(crate) fn load_tags(root: &Path, kind: &str) -> Result Result>> { - let dir = root.join(format!("data/minecraft/tags/{kind}")); let mut raw: HashMap> = HashMap::new(); - fn walk(dir: &Path, base: &Path, raw: &mut HashMap>) -> Result<()> { + fn walk( + dir: &Path, + base: &Path, + namespace: &str, + raw: &mut HashMap>, + ) -> Result<()> { for entry in fs::read_dir(dir)?.flatten() { let p = entry.path(); if p.is_dir() { - walk(&p, base, raw)?; + walk(&p, base, namespace, raw)?; } else if p.extension().is_some_and(|e| e == "json") { let name = format!( - "minecraft:{}", + "{namespace}:{}", p.strip_prefix(base)? .with_extension("") .to_string_lossy() @@ -301,8 +305,12 @@ pub(crate) fn load_tag_lists(root: &Path, kind: &str) -> Result>, out: &mut Vec, depth: u32) { if depth > 32 { diff --git a/crates/horizon-client/src/light.rs b/crates/horizon-client/src/light.rs index 936bc9655..fd271f40f 100644 --- a/crates/horizon-client/src/light.rs +++ b/crates/horizon-client/src/light.rs @@ -71,7 +71,7 @@ impl LightTables { }; let data = nbt::read_named( &std::fs::read(root.join("occlusion.nbt"))?, - Limits::default(), + Limits::tables(), )? .0 .tag; diff --git a/crates/horizon-client/src/mod_content.rs b/crates/horizon-client/src/mod_content.rs index 3a8c2920e..4556a4d6c 100644 --- a/crates/horizon-client/src/mod_content.rs +++ b/crates/horizon-client/src/mod_content.rs @@ -638,6 +638,19 @@ pub fn namespaces(root: &Path) -> Vec { .unwrap_or_default() } +/// The namespaces whose tags loaders read in `root`: `minecraft`, and in a +/// root built by [`build`] the convention tags (`c`, shared between mods as +/// on NeoForge and Fabric) and the content mods' own. +pub fn tag_namespaces(root: &Path) -> Vec { + let mods = namespaces(root); + let mut out = vec!["minecraft".to_owned()]; + if !mods.is_empty() { + out.push("c".to_owned()); + out.extend(mods); + } + out +} + /// Bundles of block tag files (tag id → the tag file's text). const TAG_BUNDLES: [&str; 2] = ["block-tags.json", "worldgen/block_tags.json"]; @@ -735,8 +748,67 @@ fn merge_tag(text: Option<&str>, more: &[J], what: &str) -> Result { Ok(serde_json::to_string_pretty(&doc)?) } +/// The block and item ids and tags a content root has, for tag entries. +struct Known { + blocks: std::collections::BTreeSet, + items: std::collections::BTreeSet, + /// `data//tags//.json` files the mods add. + tag_files: std::collections::BTreeSet, +} +impl Known { + fn new(base: &Path, plan: &Plan, tags: &BTreeMap>) -> Result { + let mut blocks: std::collections::BTreeSet = + plan.defaults.keys().cloned().collect(); + blocks.extend(plan.blocks.iter().map(|b| b.decl.id.clone())); + let mut items = std::collections::BTreeSet::new(); + if let J::Obj(o) = read_json(&base.join("items.json"))? { + items.extend(o.into_iter().map(|(k, _)| k)); + } + items.extend(plan.items.iter().map(|i| i.rename.to.clone())); + Ok(Known { + blocks, + items, + tag_files: tags.keys().cloned().collect(), + }) + } + /// Whether tag `file` keeps entry `v`: a known id or an existing tag, + /// for block and item tags (other registries are kept as they are). + fn keeps(&self, file: &str, v: &J) -> bool { + let id = match v { + J::Str(s) => s.as_str(), + J::Obj(_) => match v.get("id") { + Some(J::Str(s)) => s.as_str(), + _ => return true, + }, + _ => return true, + }; + let Some(kind) = file + .strip_prefix("data/") + .and_then(|r| r.split_once("/tags/")) + .and_then(|(_, rest)| Some(rest.split_once('/')?.0)) + else { + return true; + }; + let ids = match kind { + "block" => &self.blocks, + "item" => &self.items, + _ => return true, + }; + match id.strip_prefix('#') { + Some(tag) => { + let (tns, path) = tag.split_once(':').unwrap_or(("minecraft", tag)); + let rel = format!("data/{tns}/tags/{kind}/{path}.json"); + self.tag_files.contains(&rel) || tns == "minecraft" + } + None => ids.contains(id), + } + } +} + /// Builds the content root for `mods` over `base` in `out`. pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> { + // The overlay links to the base: a relative base would leave them dangling. + let base = &std::path::absolute(base)?; let plan = Plan::new(base, mods)?; let overlay = Overlay::new(base, out)?; for name in JSON_TABLES { @@ -754,11 +826,11 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> { if !path.exists() { continue; } - let (mut named, _) = nbt::read_named(&fs::read(&path)?, Limits::default()) + let (mut named, _) = nbt::read_named(&fs::read(&path)?, Limits::tables()) .map_err(|e| format!("{name}: {e}"))?; plan.nbt(&mut named.tag); let bytes = - nbt::write_named(&named, Limits::default()).map_err(|e| format!("{name}: {e}"))?; + nbt::write_named(&named, Limits::tables()).map_err(|e| format!("{name}: {e}"))?; overlay.write(name, &bytes)?; } // Mod files, and every tag addition gathered per tag file. @@ -788,6 +860,13 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> { } } } + // A tag naming an id nobody registers fails as a whole in vanilla, and + // carried-over mods name blocks left out or other mods' ids: such + // entries are dropped instead, so the rest of the tag holds. + let known = Known::new(base, &plan, &tags)?; + for (file, values) in &mut tags { + values.retain(|v| known.keeps(file, v)); + } let mut bundles: Vec<(&str, J)> = Vec::new(); for name in TAG_BUNDLES { if base.join(name).exists() { diff --git a/crates/horizon-client/src/mod_content_tests.rs b/crates/horizon-client/src/mod_content_tests.rs index 6dd92ecfd..d7627fa27 100644 --- a/crates/horizon-client/src/mod_content_tests.rs +++ b/crates/horizon-client/src/mod_content_tests.rs @@ -56,7 +56,7 @@ fn prepared() -> Option { /// A content mod folder: a full block, a door and an item-less glass from /// templates, an item, a vanilla tag addition and a language file. fn ruby_mod(dir: &Path) -> ContentMod { - let files: [(&str, &str); 7] = [ + let files: [(&str, &str); 8] = [ ( "horizon-mod.toml", "id = \"ruby\"\nname = \"Ruby\"\nversion = \"0.1.0\"\napi = \"0.2\"\nside = \"both\"\ncapabilities = [\"registries\"]\n", @@ -78,9 +78,15 @@ fn ruby_mod(dir: &Path) -> ContentMod { "data/ruby/horizon/item/ruby.json", r#"{"template": "minecraft:diamond", "max_stack_size": 16, "rarity": "rare"}"#, ), + // Carried-over tags name blocks left out and other mods' ids too. ( "data/minecraft/tags/block/mineable/pickaxe.json", - r#"{"values": ["ruby:ruby_block"]}"#, + r##"{"values": ["ruby:ruby_block", "ruby:left_out", "othermod:thing", + {"id": "othermod:optional", "required": false}, "#c:storage_blocks/ruby"]}"##, + ), + ( + "data/c/tags/item/gems/ruby.json", + r#"{"values": ["ruby:ruby", "othermod:ruby"]}"#, ), ( "assets/ruby/lang/en_us.json", @@ -110,7 +116,10 @@ fn content_root_loads_with_every_table() { let scratch = std::env::temp_dir().join(format!("horizon-mod-content-{}", std::process::id())); let _ = fs::remove_dir_all(&scratch); let m = ruby_mod(&scratch.join("ruby")); - let root = resource_root(&base, std::slice::from_ref(&m), &scratch.join("cache")).unwrap(); + // The base as a relative path (cargo runs tests in the crate's folder): + // the overlay's links still resolve. + let relative = Path::new("../../.local/horizon-client/26.3"); + let root = resource_root(relative, std::slice::from_ref(&m), &scratch.join("cache")).unwrap(); assert_ne!(root, base); let vanilla = Assets::load(&base).unwrap(); @@ -169,7 +178,12 @@ fn content_root_loads_with_every_table() { let gem = &items.items["ruby:ruby"]; assert_eq!(gem.max_stack, 16); assert!(!items.items.contains_key("ruby:ruby_glass")); - assert!(items.block_tags["minecraft:mineable/pickaxe"].contains("ruby:ruby_block")); + let pickaxe = &items.block_tags["minecraft:mineable/pickaxe"]; + assert!(pickaxe.contains("ruby:ruby_block")); + assert!(!pickaxe.contains("ruby:left_out") && !pickaxe.contains("othermod:thing")); + assert!(pickaxe.contains("minecraft:stone")); + // Convention tags load, with the ids nobody registers dropped. + assert_eq!(items.item_tag_order["c:gems/ruby"], ["ruby:ruby"]); crate::collisions::load(&root, new).unwrap(); crate::models::load_visibility(&root, new).unwrap(); diff --git a/crates/horizon-client/src/models.rs b/crates/horizon-client/src/models.rs index ba5bffefb..110166f29 100644 --- a/crates/horizon-client/src/models.rs +++ b/crates/horizon-client/src/models.rs @@ -120,7 +120,7 @@ pub fn load_visibility( nbt::{self, Limits}, }; use std::{collections::BTreeMap, fs}; - let data = nbt::read_named(&fs::read(root.join("occlusion.nbt"))?, Limits::default())? + let data = nbt::read_named(&fs::read(root.join("occlusion.nbt"))?, Limits::tables())? .0 .tag; let occlusion = CachedCollisionRegistry::from_nbt(&data, registry)?; diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index b098142dc..ae2486351 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -63,7 +63,7 @@ impl MotionResources { )?)?)?); let data = nbt::read_named( &fs::read(root.join("movement-properties.nbt"))?, - Limits::default(), + Limits::tables(), )? .0 .tag; diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs index 35b02c12e..613086112 100644 --- a/crates/horizon-client/src/stations.rs +++ b/crates/horizon-client/src/stations.rs @@ -481,23 +481,30 @@ fn ingredient(v: &Value, items: &Items) -> Ingredient { } impl StationRecipes { pub fn load(root: &Path, items: &Items) -> Self { - let mut files: Vec<_> = fs::read_dir(root.join("data/minecraft/recipe")) - .into_iter() - .flatten() - .flatten() - .map(|e| e.path()) - .filter(|p| p.extension().is_some_and(|e| e == "json")) - .collect(); - files.sort(); + // Vanilla's recipes, then the content mods' (docs/modpacks.md). + let mut files = Vec::new(); + let namespaces = + std::iter::once("minecraft".to_owned()).chain(crate::mod_content::namespaces(root)); + for namespace in namespaces { + let mut more: Vec<_> = fs::read_dir(root.join(format!("data/{namespace}/recipe"))) + .into_iter() + .flatten() + .flatten() + .map(|e| e.path()) + .filter(|p| p.extension().is_some_and(|e| e == "json")) + .collect(); + more.sort(); + files.extend(more.into_iter().map(|p| (namespace.clone(), p))); + } let mut smithing = Vec::new(); let mut stonecutting = Vec::new(); - for p in files { + for (namespace, p) in files { let Ok(bytes) = fs::read(&p) else { continue }; let Ok(v) = serde_json::from_slice::(&bytes) else { continue; }; let id = format!( - "minecraft:{}", + "{namespace}:{}", p.file_stem().and_then(|s| s.to_str()).unwrap_or("") ); match v["type"].as_str().unwrap_or("") { diff --git a/crates/horizon-mods/src/content.rs b/crates/horizon-mods/src/content.rs index 411fa7277..40b641759 100644 --- a/crates/horizon-mods/src/content.rs +++ b/crates/horizon-mods/src/content.rs @@ -4,7 +4,7 @@ //! //! Content is data, not code: nothing here runs in the sandbox. What a mod //! may add is fenced instead. Its own namespace, plus additions to vanilla -//! tags. Paths are plain, files and totals are capped, and vanilla ids +//! tags and to the convention tags (`c`, which NeoForge and Fabric mods share). Paths are plain, files and totals are capped, and vanilla ids //! cannot be redefined. use crate::manifest::{Capability, MANIFEST, Manifest}; use serde::Deserialize; @@ -242,12 +242,13 @@ impl Content { parts.next().unwrap_or(""), ); let own = namespace == id; - // Vanilla's own files stay vanilla's; a mod may only add to its tags. - let allowed = - own || (top == "data" && namespace == "minecraft" && rest.starts_with("tags/")); + // Vanilla's own files stay vanilla's; a mod may only add to its + // tags, and to the convention tags mods share. + let shared = matches!(namespace, "minecraft" | "c"); + let allowed = own || (top == "data" && shared && rest.starts_with("tags/")); if !allowed { return Err(format!( - "{name}: a mod adds files in its own namespace ({top}/{id}/) or to vanilla tags" + "{name}: a mod adds files in its own namespace ({top}/{id}/) or to vanilla and convention (c) tags" )); } let Some(decl) = (own && top == "data") @@ -417,10 +418,11 @@ capabilities = ["registries"] ("data/ruby/horizon/item/ruby.json", ITEM), ("data/ruby/recipe/ruby_block.json", b"{}"), ("data/minecraft/tags/block/mineable/pickaxe.json", b"{}"), + ("data/c/tags/item/gems/ruby.json", b"{}"), ("assets/ruby/textures/block/ruby_block.png", b"png"), ]; let content = hmod("ok", MANIFEST_TEXT, files).unwrap(); - assert_eq!(content.files.len(), 5); + assert_eq!(content.files.len(), 6); assert_eq!( content.blocks, [Block { @@ -471,6 +473,8 @@ capabilities = ["registries"] "vanilla-recipe", &[("data/minecraft/recipe/stone.json", b"{}")], ); + refused("convention-recipe", &[("data/c/recipe/stone.json", b"{}")]); + refused("convention-asset", &[("assets/c/lang/en_us.json", b"{}")]); let e = refused( "modded-template", &[( diff --git a/crates/horizon-world/src/nbt.rs b/crates/horizon-world/src/nbt.rs index 9d5b9355a..7e4d76a41 100644 --- a/crates/horizon-world/src/nbt.rs +++ b/crates/horizon-world/src/nbt.rs @@ -97,6 +97,18 @@ impl Default for Limits { } } } +impl Limits { + /// The prepared per-state block tables (`cached-collision.nbt`, + /// `block-properties.nbt`, ...): trusted files with a row per block + /// state, which content mods' states grow past the default caps. + pub fn tables() -> Self { + Self { + max_bytes: 1 << 28, + max_nodes: 16_000_000, + max_depth: 512, + } + } +} #[derive(Clone, Debug, PartialEq, Eq)] pub struct Error { diff --git a/crates/horizon-world/src/worldgen/generator_blocks.rs b/crates/horizon-world/src/worldgen/generator_blocks.rs index 6085183ec..dc7db7d20 100644 --- a/crates/horizon-world/src/worldgen/generator_blocks.rs +++ b/crates/horizon-world/src/worldgen/generator_blocks.rs @@ -103,14 +103,12 @@ impl BlockBehavior { return Ok(None); } let read = |name: &str| -> Result { - let limits = Limits { - max_bytes: 1 << 28, - ..Limits::default() - }; - Ok(nbt::read_named(&fs::read(dir.join(name))?, limits) - .map_err(|e| resource(format!("{name}: {e:?}")))? - .0 - .tag) + Ok( + nbt::read_named(&fs::read(dir.join(name))?, Limits::tables()) + .map_err(|e| resource(format!("{name}: {e:?}")))? + .0 + .tag, + ) }; let json = |name: &str| -> Result { Ok(serde_json::from_str(&fs::read_to_string(dir.join(name))?)?) diff --git a/docs/mods.md b/docs/mods.md index 6203c4066..d1556abd7 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -277,12 +277,15 @@ blocks and items by declaring them in `data//horizon/block/*.json` and ``` The fence: files go in the mod's own namespace (`assets//`, -`data//`), plus additions to vanilla tags (`data/minecraft/tags/`). +`data//`), plus additions to vanilla tags (`data/minecraft/tags/`) and +to the convention tags NeoForge and Fabric mods share (`data/c/tags/`). Templates and `sounds` name vanilla blocks; unknown keys are refused. Paths use vanilla's resource characters, at most 65,536 files, 16 MiB each and 512 MiB in all. A mod whose content is refused stays off, with the reason on -its row. The game reading this content into its block and item tables comes -next (docs/modpacks.md). +its row. The game reads this content into its block and item tables +(`horizon_client::mod_content`, docs/modpacks.md). A tag entry naming an id +nobody registers (a block a port left out, another mod's item) is dropped, +so the rest of the tag still loads; vanilla would drop the whole tag. ## Versions and compatibility From 886def4360a904802f30d1e053281ef35cf6b4d6 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 23:25:54 +0200 Subject: [PATCH 07/28] horizon-port-pack carry: templates and numbers from the NeoForge oracle, 1.21.1 loot upgraded Carrying over seven real ATM10 mods (Cloud Glass, Factory Blocks, Glassential, Macaw's Doors, Fences, Paths and Trapdoors) showed what the guesses missed: - Loot tables: 1.21.1's `conditions` lists, `functions` and `condition`/`function` kinds are now 26.3's single `condition`, `modifier` and `type`; silk-touch and shears tool matches become `minecraft:tool/can_silk_touch` and `can_shear`. Before, every drop condition was ignored (glass dropped itself by hand, upper door halves dropped doors, double slabs dropped one). - With the oracle's facts (/oracle/facts.json, from tools/neoforge_oracle.py in the next PR), every registered block gets the vanilla template of the same vanilla class and states that matches its shapes, sounds, BlockSetType and WoodType best, and the mod's own hardness, blast resistance, light, tool need, friction, map colour and sounds. Items get stack size and rarity. The carry report lists what a template does not reproduce and why a block was left out. - Convention tags a recipe uses (c:dyes/red) are written from the oracle's tags, vanilla and own members only; the jar's own c tags stay inside the mod. - Without the oracle, blockstates that omit properties their models ignore (powered, waterlogged) still find their template, and names pick between fences and panes, doors and trapdoors. - `version = "${file.jarVersion}"` is read from MANIFEST.MF. - `--resources ` limits templates to blocks Horizon has. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-port-pack/src/carry.rs | 393 ++++++++++++++++++++++--- crates/horizon-port-pack/src/jar.rs | 16 + crates/horizon-port-pack/src/main.rs | 63 +++- crates/horizon-port-pack/src/oracle.rs | 384 ++++++++++++++++++++++++ docs/modpacks.md | 29 +- 5 files changed, 835 insertions(+), 50 deletions(-) create mode 100644 crates/horizon-port-pack/src/oracle.rs diff --git a/crates/horizon-port-pack/src/carry.rs b/crates/horizon-port-pack/src/carry.rs index 42c457f02..a637d6246 100644 --- a/crates/horizon-port-pack/src/carry.rs +++ b/crates/horizon-port-pack/src/carry.rs @@ -3,7 +3,7 @@ //! upgraded from 1.21.1 to 26.3, item models get their `items/` client //! definitions, and each blockstate gets a vanilla template guessed from its //! properties until the oracle's facts replace the guess. -use crate::jar::JarInfo; +use crate::{jar::JarInfo, oracle::Facts}; use serde::Serialize; use serde_json::{Value, json}; use std::{ @@ -20,14 +20,26 @@ pub struct Report { /// data other than tags), kept in `outside/` for review. pub outside: Vec, pub recipes_upgraded: usize, + pub loot_tables_upgraded: usize, + /// Worldgen and structure files (`data//worldgen/`, `structure/`). + pub worldgen: usize, /// Recipes left as they were: custom types, NeoForge conditions. pub recipes_kept: Vec, pub item_definitions_added: usize, - /// Declared blocks and their guessed templates. + /// Templates and properties came from the NeoForge oracle's facts, not + /// from guesses. + pub oracle: bool, + /// Declared blocks and their templates. pub blocks: BTreeMap, - /// Blockstates whose properties match no template. - pub blocks_unknown: Vec, + /// What a declared block's template does not reproduce (oracle only). + pub differences: BTreeMap>, + /// Blocks left out, and why. + pub blocks_unknown: BTreeMap, pub items: usize, + /// Items left out, and why (oracle only). + pub items_unknown: BTreeMap, + /// Convention (`c:`) tags the recipes use, filled in from the oracle. + pub convention_tags: usize, } /// Vanilla blocks by their sorted property names. @@ -42,6 +54,7 @@ const TEMPLATES: &[(&str, &str)] = &[ "minecraft:oak_trapdoor", ), ("east,north,south,waterlogged,west", "minecraft:oak_fence"), + ("east,north,south,waterlogged,west", "minecraft:glass_pane"), ( "east,north,south,up,waterlogged,west", "minecraft:cobblestone_wall", @@ -58,9 +71,24 @@ const TEMPLATES: &[(&str, &str)] = &[ ("stage", "minecraft:oak_sapling"), ]; -pub fn template(properties: &BTreeSet) -> Option<&'static str> { - let key = properties.iter().cloned().collect::>().join(","); - TEMPLATES.iter().find(|(k, _)| *k == key).map(|(_, t)| *t) +/// A guess without the oracle: the template whose properties include the +/// blockstate's with the fewest left over (a blockstate may leave out what +/// its models ignore, such as `powered` or `waterlogged`), the block's name +/// breaking ties (`_pane`, `_gate`, `_trapdoor`). +pub fn template(name: &str, properties: &BTreeSet) -> Option<&'static str> { + let fits = TEMPLATES.iter().filter_map(|(k, t)| { + let have: BTreeSet<&str> = k.split(',').filter(|p| !p.is_empty()).collect(); + properties + .iter() + .all(|p| have.contains(p.as_str())) + .then(|| (have.len() - properties.len(), *t)) + }); + let hint = |t: &str| { + let kind = t.rsplit('_').next().unwrap_or(t); + !name.ends_with(&format!("_{kind}")) + }; + fits.min_by_key(|&(extra, t)| (extra, hint(t))) + .map(|(_, t)| t) } /// The property names a blockstate file uses. @@ -165,7 +193,92 @@ pub fn upgrade_recipe(recipe: &mut Value) -> bool { true } -/// Where a jar entry goes: `Some(true)` inside the content mod, `Some(false)` +/// A 1.21.1 loot table in 26.3's shape, in place: `conditions` lists become +/// one `condition` (`all_of` for several), `functions` become `modifier`, +/// and conditions and functions name their kind in `type`. A tool match on +/// silk touch alone, or on shears alone, becomes 26.3's +/// `minecraft:tool/can_silk_touch` or `minecraft:tool/can_shear`. +pub fn upgrade_loot(v: &mut Value) { + match v { + Value::Array(a) => a.iter_mut().for_each(upgrade_loot), + Value::Object(o) => { + if let Some(Value::Array(mut list)) = o.remove("conditions") { + list.iter_mut().for_each(upgrade_condition); + let one = match <[Value; 1]>::try_from(list) { + Ok([c]) => c, + Err(list) => json!({"type": "minecraft:all_of", "terms": list}), + }; + o.insert("condition".to_owned(), one); + } + if let Some(Value::Array(mut list)) = o.remove("functions") { + for f in &mut list { + rename_kind(f, "function"); + upgrade_loot(f); + } + o.insert("modifier".to_owned(), Value::Array(list)); + } + for (k, x) in o.iter_mut() { + if k != "condition" && k != "modifier" { + upgrade_loot(x); + } + } + } + _ => {} + } +} + +/// `{"": kind, ...}` as `{"type": kind, ...}`. +fn rename_kind(v: &mut Value, key: &str) { + if let Some(o) = v.as_object_mut() + && !o.contains_key("type") + && let Some(kind) = o.remove(key) + { + o.insert("type".to_owned(), kind); + } +} + +/// One 1.21.1 loot condition in 26.3's shape. +fn upgrade_condition(c: &mut Value) { + rename_kind(c, "condition"); + if let Some(term) = c.get_mut("term") { + upgrade_condition(term); + } + if let Some(Value::Array(terms)) = c.get_mut("terms") { + terms.iter_mut().for_each(upgrade_condition); + } + if c["type"] == "minecraft:match_tool" + && let Some(named) = named_tool_condition(&c["predicate"]) + { + *c = json!(named); + } +} + +/// 26.3's named tool conditions for the 1.21.1 predicates they replace. +fn named_tool_condition(predicate: &Value) -> Option<&'static str> { + let keys: Vec<&str> = predicate.as_object()?.keys().map(String::as_str).collect(); + match keys.as_slice() { + ["predicates"] => { + let list = predicate["predicates"]["minecraft:enchantments"].as_array()?; + let [e] = list.as_slice() else { + return None; + }; + let silk = e["enchantments"] == "minecraft:silk_touch" + && e["levels"]["min"].as_u64().unwrap_or(1) <= 1 + && e["levels"].get("max").is_none() + && predicate["predicates"].as_object()?.len() == 1; + silk.then_some("minecraft:tool/can_silk_touch") + } + ["items"] => { + let items = &predicate["items"]; + let shears = items == "minecraft:shears" || *items == json!(["minecraft:shears"]); + shears.then_some("minecraft:tool/can_shear") + } + _ => None, + } +} + +/// Where a jar entry goes: `Some(true)` inside the content mod (its own +/// namespace, additions to vanilla and convention tags), `Some(false)` /// to `outside/`, `None` not carried (code, metadata). fn place(name: &str, id: &str) -> Option { let mut parts = name.splitn(3, '/'); @@ -173,10 +286,21 @@ fn place(name: &str, id: &str) -> Option { if !(root == "assets" || root == "data") || rest.is_empty() || name.ends_with('/') { return None; } - Some(ns == id || (root == "data" && ns == "minecraft" && rest.starts_with("tags/"))) + let shared_tags = + root == "data" && (ns == "minecraft" || ns == "c") && rest.starts_with("tags/"); + Some(ns == id || shared_tags) } -pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result { +/// Carries `jar` over into `out/carry/`. With the oracle's `facts`, blocks +/// and items are the ones the mod registers, with the templates and numbers +/// the facts give; `allowed` says which vanilla blocks the game has. +pub fn carry( + jar: &Path, + info: &JarInfo, + out: &Path, + facts: Option<&Facts>, + allowed: &dyn Fn(&str) -> bool, +) -> Result { let id = &info.mod_id; if id.is_empty() || id.len() > 64 @@ -196,6 +320,7 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result { let mut report = Report::default(); let mut blockstates: BTreeMap = BTreeMap::new(); let mut item_models = BTreeSet::new(); + let mut convention = BTreeSet::new(); for i in 0..zip.len() { let mut entry = zip.by_index(i).map_err(|e| e.to_string())?; let name = entry.name().to_owned(); @@ -218,11 +343,17 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result { }; if keep { let rel = name.split_once(&format!("/{id}/")).map_or("", |(_, r)| r); + if name.starts_with("data/") + && (rel.starts_with("worldgen/") || rel.starts_with("structure/")) + { + report.worldgen += 1; + } if let Some(file) = rel .strip_prefix("recipe/") .filter(|_| name.starts_with("data/")) { if let Ok(mut recipe) = serde_json::from_slice::(&bytes) { + tags_used(&recipe, &mut convention); if upgrade_recipe(&mut recipe) { report.recipes_upgraded += 1; bytes = serde_json::to_vec_pretty(&recipe).unwrap_or(bytes); @@ -230,6 +361,15 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result { report.recipes_kept.push(file.to_owned()); } } + } else if rel.starts_with("loot_table/") && name.starts_with("data/") { + if let Ok(mut table) = serde_json::from_slice::(&bytes) { + let before = table.clone(); + upgrade_loot(&mut table); + if table != before { + report.loot_tables_upgraded += 1; + bytes = serde_json::to_vec_pretty(&table).unwrap_or(bytes); + } + } } else if let Some(b) = rel .strip_prefix("blockstates/") .and_then(|b| b.strip_suffix(".json")) @@ -257,25 +397,116 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result { } } let decl = inside.join(format!("data/{id}/horizon")); - for (b, state) in &blockstates { - match template(&properties(state)) { - Some(t) => { - write( - &decl.join(format!("block/{b}.json")), - json!({"template": t}).to_string().as_bytes(), - )?; - report.blocks.insert(b.clone(), t.to_owned()); + let write_decl = |kind: &str, name: &str, v: &Value| { + let text = serde_json::to_vec_pretty(v).unwrap_or_default(); + write(&decl.join(format!("{kind}/{name}.json")), &text) + }; + if let Some(facts) = facts { + report.oracle = true; + let prefix = format!("{id}:"); + let mut declared = BTreeSet::new(); + for (full, block) in facts.blocks.range(prefix.clone()..) { + let Some(b) = full.strip_prefix(&prefix) else { + break; + }; + let Some(choice) = facts.template(full, allowed) else { + let props: Vec<&str> = block.properties.keys().map(String::as_str).collect(); + let why = format!( + "no vanilla {} with properties [{}]", + block.vanilla_class().rsplit('.').next().unwrap_or(""), + props.join(", ") + ); + report.blocks_unknown.insert(b.to_owned(), why); + continue; + }; + let mut v = json!({"template": choice.template, "properties": choice.properties}); + if block.item == "minecraft:air" { + v["item"] = json!(false); + } else if block.item != *full { + v["item"] = json!(false); + report + .differences + .entry(b.to_owned()) + .or_default() + .push(format!("its item is {}", block.item)); + } else { + declared.insert(full.clone()); + } + write_decl("block", b, &v)?; + report.blocks.insert(b.to_owned(), choice.template); + if !choice.differences.is_empty() { + report + .differences + .entry(b.to_owned()) + .or_default() + .extend(choice.differences); } - None => report.blocks_unknown.push(b.clone()), } - } - for m in item_models.iter().filter(|m| !blockstates.contains_key(*m)) { - let item = json!({"template": "minecraft:stick"}); - write( - &decl.join(format!("item/{m}.json")), - item.to_string().as_bytes(), - )?; - report.items += 1; + for (full, item) in facts.items.range(prefix.clone()..) { + let Some(name) = full.strip_prefix(&prefix) else { + break; + }; + if declared.contains(full) { + continue; + } + if item + .block + .as_ref() + .is_some_and(|b| facts.blocks.contains_key(b)) + && report.blocks_unknown.contains_key(name) + { + report + .items_unknown + .insert(name.to_owned(), "its block is left out".into()); + continue; + } + match facts.item(full) { + Ok((v, differences)) => { + write_decl("item", name, &v)?; + report.items += 1; + if !differences.is_empty() { + report.differences.insert(name.to_owned(), differences); + } + } + Err(e) => { + report.items_unknown.insert(name.to_owned(), e); + } + } + } + // Convention tags are NeoForge's and the pack's: the recipes get the + // members the oracle saw, those of vanilla and of this mod. + for tag in &convention { + let Some(path) = tag.strip_prefix("c:") else { + continue; + }; + let file = inside.join(format!("data/c/tags/item/{path}.json")); + if file.exists() { + continue; + } + if let Some(members) = facts.tag_members("item", tag, id) { + let v = json!({"values": members}); + write(&file, &serde_json::to_vec_pretty(&v).unwrap_or_default())?; + report.convention_tags += 1; + } + } + } else { + for (b, state) in &blockstates { + match template(b, &properties(state)) { + Some(t) => { + write_decl("block", b, &json!({"template": t}))?; + report.blocks.insert(b.clone(), t.to_owned()); + } + None => { + let props: Vec = properties(state).into_iter().collect(); + let why = format!("no template for properties [{}]", props.join(", ")); + report.blocks_unknown.insert(b.clone(), why); + } + } + } + for m in item_models.iter().filter(|m| !blockstates.contains_key(*m)) { + write_decl("item", m, &json!({"template": "minecraft:stick"}))?; + report.items += 1; + } } let q = |s: &str| toml::Value::String(s.to_owned()).to_string(); let name = if info.name.is_empty() { id } else { &info.name }; @@ -299,6 +530,30 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result { Ok(report) } +/// The tags a recipe's ingredients name (`#ns:path` or `{"tag": ...}`). +fn tags_used(v: &Value, out: &mut BTreeSet) { + match v { + Value::String(s) => { + if let Some(t) = s.strip_prefix('#') { + out.insert(t.to_owned()); + } + } + Value::Array(a) => a.iter().for_each(|x| tags_used(x, out)), + Value::Object(o) => { + for (k, x) in o { + match (k.as_str(), x) { + ("tag", Value::String(t)) => { + out.insert(t.clone()); + } + ("result", _) => {} + _ => tags_used(x, out), + } + } + } + _ => {} + } +} + fn write(path: &Path, bytes: &[u8]) -> Result<(), String> { if let Some(dir) = path.parent() { fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?; @@ -325,21 +580,86 @@ mod tests { assert!(!upgrade_recipe(&mut tag_list)); } + #[test] + fn upgrades_loot_tables() { + let mut slab = json!({"type": "minecraft:block", "pools": [{"rolls": 1.0, "entries": [{ + "type": "minecraft:item", "name": "m:slab", + "functions": [{"function": "minecraft:set_count", "count": 2.0, "add": false, + "conditions": [{"condition": "minecraft:block_state_property", "block": "m:slab", + "properties": {"type": "double"}}]}, + {"function": "minecraft:explosion_decay"}]}]}]}); + upgrade_loot(&mut slab); + assert_eq!( + slab["pools"][0]["entries"][0]["modifier"][0], + json!({"type": "minecraft:set_count", "count": 2.0, "add": false, + "condition": {"type": "minecraft:block_state_property", "block": "m:slab", + "properties": {"type": "double"}}}) + ); + let silk = json!({"condition": "minecraft:match_tool", "predicate": {"predicates": { + "minecraft:enchantments": [{"enchantments": "minecraft:silk_touch", "levels": {"min": 1}}]}}}); + let shears = json!({"condition": "minecraft:match_tool", "predicate": {"items": "minecraft:shears"}}); + let mut glass = json!({"pools": [{"conditions": [silk.clone()], "entries": []}, + {"conditions": [{"condition": "minecraft:any_of", "terms": [silk, shears]}, + {"condition": "minecraft:survives_explosion"}], "entries": []}]}); + upgrade_loot(&mut glass); + assert_eq!( + glass["pools"][0]["condition"], + "minecraft:tool/can_silk_touch" + ); + assert_eq!( + glass["pools"][1]["condition"], + json!({"type": "minecraft:all_of", "terms": [ + {"type": "minecraft:any_of", "terms": ["minecraft:tool/can_silk_touch", "minecraft:tool/can_shear"]}, + {"type": "minecraft:survives_explosion"}]}) + ); + // A loot table already in 26.3's shape stays as it is. + let mut new = glass.clone(); + upgrade_loot(&mut new); + assert_eq!(new, glass); + } + #[test] fn templates_from_blockstate_properties() { let door = json!({"variants": {"facing=east,half=lower,hinge=left,open=false,powered=false": {}}}); - assert_eq!(template(&properties(&door)), Some("minecraft:oak_door")); + assert_eq!( + template("gem_door", &properties(&door)), + Some("minecraft:oak_door") + ); + // Models that ignore `powered`: still a door. + let door = json!({"variants": {"facing=east,half=lower,hinge=left,open=false": {}}}); + assert_eq!( + template("gem_door", &properties(&door)), + Some("minecraft:oak_door") + ); + let trapdoor = json!({"variants": {"facing=east,half=top,open=false": {}}}); + assert_eq!( + template("gem_trapdoor", &properties(&trapdoor)), + Some("minecraft:oak_trapdoor") + ); + let sides = json!({"multipart": [{"when": {"north": "true"}}, {"when": {"east": "true"}}, + {"when": {"south": "true"}}, {"when": {"west": "true"}}]}); + assert_eq!( + template("gem_pane", &properties(&sides)), + Some("minecraft:glass_pane") + ); + assert_eq!( + template("gem_fence", &properties(&sides)), + Some("minecraft:oak_fence") + ); let fence = json!({"multipart": [{"apply": {}}, {"when": {"north": "true"}, "apply": {}}, {"when": {"east": "true"}}, {"when": {"south": "true"}}, {"when": {"west": "true"}}, {"when": {"OR": [{"waterlogged": "true"}]}}]}); - assert_eq!(template(&properties(&fence)), Some("minecraft:oak_fence")); assert_eq!( - template(&properties(&json!({"variants": {"": {}}}))), + template("gem_fence", &properties(&fence)), + Some("minecraft:oak_fence") + ); + assert_eq!( + template("gem_block", &properties(&json!({"variants": {"": {}}}))), Some("minecraft:stone") ); let odd = json!({"variants": {"charge=1,mode=fast": {}}}); - assert_eq!(template(&properties(&odd)), None); + assert_eq!(template("gem_core", &properties(&odd)), None); } /// A small NeoForge jar carried over is a content mod Horizon loads. @@ -411,14 +731,17 @@ mod tests { ); assert_eq!(info.census.classes, 1); let out = dir.join("work/mods/gem"); - let report = carry(&jar, &info, &out).unwrap(); - assert_eq!(report.copied, 11); - assert_eq!(report.outside, ["data/c/tags/item/gems.json"]); + let report = carry(&jar, &info, &out, None, &|_| true).unwrap(); + assert_eq!(report.copied, 12); + assert!(report.outside.is_empty()); assert_eq!((report.recipes_upgraded, report.recipes_kept.len()), (1, 1)); assert_eq!(report.item_definitions_added, 2); assert_eq!(report.blocks["gem_door"], "minecraft:oak_door"); assert_eq!(report.blocks["gem_block"], "minecraft:stone"); - assert_eq!(report.blocks_unknown, ["gem_core"]); + assert_eq!( + report.blocks_unknown.keys().collect::>(), + ["gem_core"] + ); assert_eq!(report.items, 1); let carried = out.join("carry"); assert!(!carried.join("com").exists()); diff --git a/crates/horizon-port-pack/src/jar.rs b/crates/horizon-port-pack/src/jar.rs index 67028755e..86e936e44 100644 --- a/crates/horizon-port-pack/src/jar.rs +++ b/crates/horizon-port-pack/src/jar.rs @@ -50,6 +50,12 @@ pub fn read(path: &Path) -> Result { } else { JarInfo::default() }; + // `version = "${file.jarVersion}"` is filled in from the manifest at load. + if info.version.starts_with("${") { + info.version = text(&mut zip, "META-INF/MANIFEST.MF") + .and_then(|m| manifest_value(&m, "Implementation-Version")) + .unwrap_or_default(); + } let names: Vec = zip.file_names().map(str::to_owned).collect(); info.census = census(&names); if info.mod_id.is_empty() { @@ -61,6 +67,16 @@ pub fn read(path: &Path) -> Result { Ok(info) } +/// A main-section attribute of `META-INF/MANIFEST.MF`. +fn manifest_value(manifest: &str, key: &str) -> Option { + manifest + .lines() + .take_while(|l| !l.trim().is_empty()) + .find_map(|l| l.strip_prefix(key)?.strip_prefix(':')) + .map(|v| v.trim().to_owned()) + .filter(|v| !v.is_empty()) +} + /// `[[mods]]` (the first one is the jar's mod), the top-level `license`, and /// `[[dependencies.]]` with `type = "required"` (or the older /// `mandatory = true`). diff --git a/crates/horizon-port-pack/src/main.rs b/crates/horizon-port-pack/src/main.rs index 4df3ef3ca..74178f503 100644 --- a/crates/horizon-port-pack/src/main.rs +++ b/crates/horizon-port-pack/src/main.rs @@ -6,8 +6,11 @@ //! `/modrinth.json`), the jars in the instance or `/jars/`, //! classes, tiers and dependency layers in `/inventory.json` and //! `inventory.csv`. -//! - `carry [...]`: the content mods' data and assets into -//! `/mods//carry/`, a folder mod for local use. +//! - `carry [--resources ] [...]`: the content +//! mods' data and assets into `/mods//carry/`, a folder mod for +//! local use. With the NeoForge oracle's `/oracle/facts.json` +//! (`tools/neoforge_oracle.py`), blocks and items come from its facts; +//! `--resources` limits templates to the blocks Horizon's tables have. //! //! The work folder belongs to the user: jars and carried-over files stay //! there and are never uploaded or committed. @@ -17,10 +20,11 @@ mod import; mod inventory; mod jar; mod modrinth; +mod oracle; use std::{fs, path::Path, process::ExitCode}; -const USAGE: &str = "usage: horizon-port-pack import | inventory [--offline] | carry [...]"; +const USAGE: &str = "usage: horizon-port-pack import | inventory [--offline] | carry [--resources ] [...]"; fn main() -> ExitCode { let args: Vec = std::env::args().skip(1).collect(); @@ -32,7 +36,19 @@ fn main() -> ExitCode { Some("inventory") => { path(1).and_then(|w| inventory(w, args.iter().any(|a| a == "--offline"))) } - Some("carry") => path(1).and_then(|w| carry(w, &args[2..])), + Some("carry") => path(1).and_then(|w| { + let mut rest = args[2..].to_vec(); + let resources = match rest.iter().position(|a| a == "--resources") { + Some(i) if i + 1 < rest.len() => { + let r = rest.remove(i + 1); + rest.remove(i); + Some(std::path::PathBuf::from(r)) + } + Some(_) => return Err(USAGE.to_owned()), + None => None, + }; + carry(w, resources.as_deref(), &rest) + }), _ => Err(USAGE.to_owned()), }; match result { @@ -107,8 +123,31 @@ fn inventory(work: &Path, offline: bool) -> Result<(), String> { Ok(()) } -fn carry(work: &Path, only: &[String]) -> Result<(), String> { +/// The vanilla blocks a prepared resource root has (`facts.json`'s defaults). +fn vanilla_blocks(resources: &Path) -> Result, String> { + let facts: serde_json::Value = read_json(&resources.join("facts.json"))?; + let defaults = facts["defaults"] + .as_object() + .ok_or("facts.json: no defaults")?; + Ok(defaults.keys().cloned().collect()) +} + +fn carry(work: &Path, resources: Option<&Path>, only: &[String]) -> Result<(), String> { let records: Vec = read_json(&work.join("inventory.json"))?; + let facts_path = work.join("oracle/facts.json"); + let facts = if facts_path.exists() { + let f = oracle::Facts::read(&facts_path)?; + println!( + "oracle facts: {} blocks, {} items", + f.blocks.len(), + f.items.len() + ); + Some(f) + } else { + None + }; + let vanilla = resources.map(vanilla_blocks).transpose()?; + let allowed = |b: &str| vanilla.as_ref().is_none_or(|v| v.contains(b)); let mut done = 0; for r in &records { let chosen = if only.is_empty() { @@ -125,19 +164,29 @@ fn carry(work: &Path, only: &[String]) -> Result<(), String> { if !chosen { continue; } - match carry::carry(jar, info, &work.join("mods").join(&r.key)) { + match carry::carry( + jar, + info, + &work.join("mods").join(&r.key), + facts.as_ref(), + &allowed, + ) { Ok(report) => { done += 1; println!( - "{}: {} files, {} recipes upgraded ({} kept), {} item definitions added, {} blocks ({} without a template), {} items, {} outside", + "{}: {} files, {} recipes upgraded ({} kept), {} loot tables upgraded, {} item definitions added, {} blocks ({} left out, {} with differences), {} items ({} left out), {} convention tags, {} outside", r.key, report.copied, report.recipes_upgraded, report.recipes_kept.len(), + report.loot_tables_upgraded, report.item_definitions_added, report.blocks.len(), report.blocks_unknown.len(), + report.differences.len(), report.items, + report.items_unknown.len(), + report.convention_tags, report.outside.len() ); } diff --git a/crates/horizon-port-pack/src/oracle.rs b/crates/horizon-port-pack/src/oracle.rs new file mode 100644 index 000000000..1fa9a717c --- /dev/null +++ b/crates/horizon-port-pack/src/oracle.rs @@ -0,0 +1,384 @@ +//! The NeoForge oracle's facts (`tools/neoforge_oracle.py export`, in +//! `/oracle/facts.json`): every block, item, recipe and tag the pack's +//! mods register, read from the running game, and the vanilla blocks beside +//! them. Carry-over uses them in place of guesses: a block's template is the +//! vanilla block of the same class and states whose shapes and sounds match +//! best, and the declared properties are the mod's own numbers. +use serde::Deserialize; +use serde_json::{Map, Value, json}; +use std::{ + collections::{BTreeMap, BTreeSet}, + path::Path, +}; + +#[derive(Debug, Deserialize)] +pub struct Facts { + pub blocks: BTreeMap, + pub items: BTreeMap, + #[serde(default)] + pub tags: Tags, +} + +#[derive(Debug, Default, Deserialize)] +pub struct Tags { + #[serde(default)] + pub block: BTreeMap>, + #[serde(default)] + pub item: BTreeMap>, +} + +#[derive(Debug, Deserialize)] +pub struct Block { + /// The class and its superclasses, most derived first. + pub class: Vec, + pub properties: BTreeMap>, + pub default: String, + pub item: String, + pub explosion_resistance: f32, + pub friction: f32, + pub speed_factor: f32, + pub jump_factor: f32, + #[serde(default)] + pub block_set_type: Option, + #[serde(default)] + pub wood_type: Option, + pub states: BTreeMap, +} + +#[derive(Debug, Deserialize)] +pub struct SetType { + pub name: String, + pub can_open_by_hand: bool, +} + +#[derive(Debug, Deserialize)] +pub struct State { + pub hardness: f32, + pub emission: u8, + pub requires_tool: bool, + pub map_color_id: u8, + pub sound: Value, + pub outline: Value, + pub collision: Value, +} + +#[derive(Debug, Deserialize)] +pub struct Item { + pub class: String, + pub max_stack_size: u8, + pub rarity: String, + #[serde(default)] + pub block: Option, + #[serde(default)] + pub food: Option, +} + +const VANILLA_PACKAGE: &str = "net.minecraft."; + +/// A state key with its properties sorted, so keys compare across blocks. +pub fn state_key(key: &str) -> String { + let mut parts: Vec<&str> = key.split(',').filter(|p| !p.is_empty()).collect(); + parts.sort_unstable(); + parts.join(",") +} + +impl Block { + /// The first vanilla class in the chain. + pub fn vanilla_class(&self) -> &str { + self.class + .iter() + .find(|c| c.starts_with(VANILLA_PACKAGE)) + .map_or("", String::as_str) + } + /// Its own class is a mod class: behaviour code the template may not have. + pub fn custom_class(&self) -> bool { + self.class + .first() + .is_some_and(|c| !c.starts_with(VANILLA_PACKAGE)) + } + fn default_state(&self) -> Option<&State> { + self.states + .get(&self.default) + .or_else(|| self.states.values().next()) + } + fn same_states(&self, other: &Block) -> bool { + self.properties.len() == other.properties.len() + && self.properties.iter().all(|(k, v)| { + other.properties.get(k).is_some_and(|w| { + v.iter().collect::>() == w.iter().collect::>() + }) + }) + } + fn by_key(&self) -> BTreeMap { + self.states.iter().map(|(k, s)| (state_key(k), s)).collect() + } +} + +/// The template carry-over gives a mod block. +#[derive(Debug, Clone, PartialEq)] +pub struct Choice { + pub template: String, + /// `data//horizon/block/.json`'s `properties`. + pub properties: Map, + /// What the template does not reproduce, for the report. + pub differences: Vec, +} + +impl Facts { + pub fn read(path: &Path) -> Result { + let bytes = std::fs::read(path).map_err(|e| format!("{}: {e}", path.display()))?; + serde_json::from_slice(&bytes).map_err(|e| format!("{}: {e}", path.display())) + } + + /// The vanilla block that best stands in for `id`: the same vanilla + /// class and states, then the most states with the same outline and + /// collision, then the same sounds, set type, wood type and hardness. + /// `None` when no vanilla block has its class and states. + pub fn template(&self, id: &str, allowed: &dyn Fn(&str) -> bool) -> Option { + let block = self.blocks.get(id)?; + let class = block.vanilla_class(); + let own = block.by_key(); + let ours = block.default_state()?; + let mut best: Option<(i64, &str, &Block)> = None; + for (name, v) in &self.blocks { + if !name.starts_with("minecraft:") + || v.vanilla_class() != class + || v.custom_class() + || !block.same_states(v) + || !allowed(name) + { + continue; + } + let theirs = v.by_key(); + let shapes = own + .iter() + .filter(|(k, s)| { + theirs + .get(*k) + .is_some_and(|t| t.outline == s.outline && t.collision == s.collision) + }) + .count() as i64; + let Some(td) = v.default_state() else { + continue; + }; + let same_set = match (&block.block_set_type, &v.block_set_type) { + (Some(a), Some(b)) => { + (a.name == b.name) as i64 * 2 + + (a.can_open_by_hand == b.can_open_by_hand) as i64 * 8 + } + _ => 0, + }; + let score = shapes * 1000 + + (td.sound == ours.sound) as i64 * 100 + + same_set * 10 + + (block.wood_type.is_some() && block.wood_type == v.wood_type) as i64 * 20 + + (td.hardness == ours.hardness) as i64 * 5 + + (td.map_color_id == ours.map_color_id) as i64; + if best.is_none_or(|(s, n, _)| score > s || (score == s && name.as_str() < n)) { + best = Some((score, name, v)); + } + } + let (_, template, t) = best?; + Some(self.choice(block, template, t, allowed)) + } + + fn choice( + &self, + block: &Block, + template: &str, + t: &Block, + allowed: &dyn Fn(&str) -> bool, + ) -> Choice { + let (ours, theirs) = (block.default_state(), t.default_state()); + let mut properties = Map::new(); + let mut differences = Vec::new(); + if let Some(s) = ours { + properties.insert("hardness".into(), json!(s.hardness)); + properties.insert( + "explosion_resistance".into(), + json!(block.explosion_resistance), + ); + properties.insert("light".into(), json!(s.emission)); + properties.insert("requires_tool".into(), json!(s.requires_tool)); + properties.insert("friction".into(), json!(block.friction)); + properties.insert("map_color".into(), json!(s.map_color_id)); + if theirs.is_none_or(|t| t.sound != s.sound) { + match self.sound_block(&s.sound, allowed) { + Some(b) => { + properties.insert("sounds".into(), json!(b)); + } + None => differences.push("sounds: no vanilla block has them".into()), + } + } + } + if (block.speed_factor, block.jump_factor) != (t.speed_factor, t.jump_factor) { + differences.push(format!( + "speed and jump factors {} {} (template {} {})", + block.speed_factor, block.jump_factor, t.speed_factor, t.jump_factor + )); + } + let theirs = t.by_key(); + let mut shapes = 0; + let mut varying = BTreeSet::new(); + let first = ours.map(|s| (s.hardness, s.emission, s.requires_tool, s.map_color_id)); + for (k, s) in block.by_key() { + let Some(v) = theirs.get(&k) else { + continue; + }; + if v.outline != s.outline || v.collision != s.collision { + shapes += 1; + } + if Some((s.hardness, s.emission, s.requires_tool, s.map_color_id)) != first { + varying.insert("per-state hardness, light or map colour"); + } + } + if shapes > 0 { + differences.push(format!( + "shapes differ from {template} in {shapes} of {} states", + block.states.len() + )); + } + differences.extend(varying.into_iter().map(str::to_owned)); + if block.custom_class() { + differences.push(format!( + "class {} (behaviour beyond {})", + block.class[0], + block.vanilla_class() + )); + } + Choice { + template: template.to_owned(), + properties, + differences, + } + } + + /// A vanilla block whose default state has these sounds. + fn sound_block(&self, sound: &Value, allowed: &dyn Fn(&str) -> bool) -> Option<&str> { + self.blocks + .iter() + .filter(|(n, _)| n.starts_with("minecraft:") && allowed(n)) + .find(|(_, b)| b.default_state().is_some_and(|s| &s.sound == sound)) + .map(|(n, _)| n.as_str()) + } + + /// An item declaration for a mod item that is not a declared block's: + /// a vanilla template item with its stack size and rarity, and what it + /// does not reproduce. + pub fn item(&self, id: &str) -> Result<(Value, Vec), String> { + let item = self.items.get(id).ok_or("not in the oracle")?; + if item.block.is_some() { + return Err("a block item without a block".into()); + } + let mut differences = Vec::new(); + if !item.class.starts_with(VANILLA_PACKAGE) { + differences.push(format!("class {} (behaviour beyond Item)", item.class)); + } + if item.food.is_some() { + return Err("food (no food template yet)".into()); + } + let mut decl = json!({"template": "minecraft:stick"}); + if item.max_stack_size != 64 { + decl["max_stack_size"] = json!(item.max_stack_size); + } + if item.rarity != "common" { + decl["rarity"] = json!(item.rarity); + } + Ok((decl, differences)) + } + + /// A tag's members the content mod may name: vanilla's and its own. + pub fn tag_members(&self, kind: &str, tag: &str, own: &str) -> Option> { + let map = if kind == "block" { + &self.tags.block + } else { + &self.tags.item + }; + let members = map.get(tag)?; + Some( + members + .iter() + .filter(|m| { + m.split_once(':') + .is_some_and(|(ns, _)| ns == "minecraft" || ns == own) + }) + .cloned() + .collect(), + ) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn state(hardness: f32, sound: &str, outline: Value) -> Value { + json!({"hardness": hardness, "emission": 0, "requires_tool": false, "map_color_id": 13, + "sound": {"break": sound}, "outline": outline, "collision": outline}) + } + fn block(class: &[&str], props: Value, states: Value) -> Value { + let default = states + .as_object() + .unwrap() + .keys() + .next() + .unwrap() + .to_owned(); + json!({"class": class, "properties": props, "default": default, "item": "x", + "explosion_resistance": 3.0, "friction": 0.6, "speed_factor": 1.0, + "jump_factor": 1.0, "states": states}) + } + + #[test] + fn templates_follow_class_shapes_and_sounds() { + let cube = json!([[0, 0, 0, 1, 1, 1]]); + let low = json!([[0, 0, 0, 1, 0.9375, 1]]); + let block_class = ["net.minecraft.world.level.block.Block"]; + let path = ["net.minecraft.world.level.block.DirtPathBlock"]; + let facts: Facts = serde_json::from_value(json!({ + "blocks": { + "minecraft:stone": block(&block_class, json!({}), json!({"": state(1.5, "stone", cube.clone())})), + "minecraft:oak_planks": block(&block_class, json!({}), json!({"": state(2.0, "wood", cube.clone())})), + "minecraft:dirt_path": block(&path, json!({}), json!({"": state(0.65, "grass", low.clone())})), + "m:wood_tile": block(&["m.Tile", block_class[0]], json!({}), json!({"": state(2.5, "wood", cube.clone())})), + "m:path": block(&["m.Path", block_class[0]], json!({}), json!({"": state(1.0, "stone", low.clone())})), + "m:gadget": block(&["m.Gadget", block_class[0]], json!({"mode": ["a", "b"]}), + json!({"mode=a": state(1.0, "stone", cube.clone()), "mode=b": state(1.0, "stone", cube)})), + }, + "items": {} + })) + .unwrap(); + let any = |_: &str| true; + let tile = facts.template("m:wood_tile", &any).unwrap(); + assert_eq!(tile.template, "minecraft:oak_planks"); + assert_eq!(tile.properties["hardness"], json!(2.5)); + assert!(!tile.properties.contains_key("sounds")); + assert_eq!( + tile.differences, + ["class m.Tile (behaviour beyond net.minecraft.world.level.block.Block)"] + ); + // A plain Block is never templated on a DirtPathBlock: shapes differ, and say so. + let path = facts.template("m:path", &any).unwrap(); + assert_eq!(path.template, "minecraft:stone"); + assert!( + path.differences[0].starts_with("shapes differ"), + "{:?}", + path.differences + ); + assert_eq!(facts.template("m:gadget", &any), None); + let tile = facts + .template("m:wood_tile", &|n: &str| n != "minecraft:oak_planks") + .unwrap(); + assert_eq!(tile.template, "minecraft:stone"); + assert_eq!(tile.differences[0], "sounds: no vanilla block has them"); + } + + #[test] + fn state_keys_sort() { + assert_eq!( + state_key("half=lower,facing=north"), + "facing=north,half=lower" + ); + assert_eq!(state_key(""), ""); + } +} diff --git a/docs/modpacks.md b/docs/modpacks.md index 7951ad4d4..ed77ca411 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -268,6 +268,7 @@ inspected: cargo run -p horizon-port-pack -- import ~/Downloads/pack.mrpack ~/.horizon/ports/pack cargo run -p horizon-port-pack -- inventory ~/.horizon/ports/pack # --offline reuses modrinth.json cargo run -p horizon-port-pack -- carry ~/.horizon/ports/pack # content mods with a jar, or name them +# --resources : only templates Horizon's tables have ``` `inventory` reads metadata only: Modrinth answers by file hash, and the jars only if the user's @@ -277,14 +278,26 @@ classes come from the reviewed table, Modrinth categories and sides; with jars, only): content 54, library 33, client-ui 26, performance 25, other 14, unknown 2, server-only 1; 40 rows matched the reviewed ATM10 table; three dependency layers (93 / 57 / 5). -`carry` copies a jar's `assets//`, `data//` and `data/minecraft/tags/` into -`mods//carry/`, a folder content mod (API 0.2) the game loads with `--dev-mod`, and keeps -what a content mod may not hold (other namespaces such as `c` tags, vanilla data) in `outside/`. -No class file is copied. It upgrades vanilla-type recipes from 1.21.1 ingredients to 26.3's, -adds the `items/` definitions 1.21.4 introduced, and declares each block from a vanilla template -guessed from its blockstate properties (stone for none, a door for `facing, half, hinge, open, -powered`, ...); blocks with an unknown property set, custom recipe types and NeoForge -conditions are listed in `carry-report.json` for the oracle step. +`carry` copies a jar's `assets//`, `data//`, `data/minecraft/tags/` and `data/c/tags/` +into `mods//carry/`, a folder content mod (API 0.2) the game loads with `--dev-mod`, and +keeps what a content mod may not hold (other namespaces, vanilla data) in `outside/`. No class +file is copied. It upgrades from 1.21.1 to 26.3: vanilla-type recipes (ingredients), loot tables +(`conditions` lists become one `condition`, `functions` become `modifier`, kinds move to `type`, +tool matches on silk touch or shears become `minecraft:tool/can_silk_touch` and +`minecraft:tool/can_shear`), and the `items/` definitions 1.21.4 introduced. + +Blocks and items come from the NeoForge oracle when `/oracle/facts.json` exists (step 6): +every block the mod registers gets the vanilla template of the same vanilla class and states +whose shapes, sounds, set type and wood type match best, with the mod's own hardness, blast +resistance, light, tool need, friction, map colour and sounds as overrides. `--resources +` limits templates to blocks Horizon's tables have. `carry-report.json` lists, per +block, what the template does not reproduce (other shapes, sounds no vanilla block has, a class +of its own), and the blocks left out: those whose vanilla class has no vanilla block with the +same states (Macaw's garage doors, multi-part gates). Recipes get the convention tags they use +(`c:dyes/red`), filled from the oracle with vanilla's and the mod's own members. Without the +oracle, templates are guessed from the blockstate's properties: the template whose properties +include them with the fewest left over (models often ignore `powered` or `waterlogged`), the +block's name breaking ties (`_pane`, `_gate`, `_trapdoor`). ### 1. Import From 32f5f01e22fb4fcbb0017d4951560d27459f8525 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 23:27:20 +0200 Subject: [PATCH 08/28] Per-mod parity harness against a dev-only NeoForge oracle The harness the modpack design calls for, for data-tier mods: - tools/neoforge_oracle.py installs a NeoForge 21.1.259 server (ATM10's) under .local/neoforge-oracle, builds the exporter in mods/horizon/src/neoforge-oracle (our code, never shipped), runs it headless with the user's jars and writes every block (class chain, states, per-state hardness, light, tool need, map colour, sounds, outline and collision; drops for hand, diamond tools, shears and silk touch; placement; BlockSetType and WoodType), item, recipe and tag of the mods' namespaces, plus the vanilla blocks for templates. About 30 s. - examples/mod_port_probe.rs builds the content root from the carried mods and dumps what Horizon's loaders make of the same things. - tools/mod_port_harness.py compares them per mod and writes /mods//harness/result.json. 1.21.1 sound events map to 26.3's through vanilla blocks both have, and vanilla items newer than 1.21.1 are not counted against a recipe. On ATM10's own jars (MIT): Macaw's Trapdoors passes everything; Doors, Fences, Paths, Glassential, Factory Blocks and Cloud Glass pass every drop, recipe, tag and placement and fail only on what API 0.2 cannot say (shapes and sound events of their own, blocks of classes no vanilla block shares). Jars, facts and results stay in the work folder. Co-Authored-By: Claude Opus 5.5 --- .../horizon-client/examples/mod_port_probe.rs | 271 +++++++++++ docs/modpacks.md | 47 +- .../horizonlab/neoforge/FactsExporter.java | 426 ++++++++++++++++++ .../resources/META-INF/neoforge.mods.toml | 11 + tools/mod_port_harness.py | 211 +++++++++ tools/neoforge_oracle.py | 164 +++++++ 6 files changed, 1128 insertions(+), 2 deletions(-) create mode 100644 crates/horizon-client/examples/mod_port_probe.rs create mode 100644 mods/horizon/src/neoforge-oracle/java/dev/horizonlab/neoforge/FactsExporter.java create mode 100644 mods/horizon/src/neoforge-oracle/resources/META-INF/neoforge.mods.toml create mode 100644 tools/mod_port_harness.py create mode 100644 tools/neoforge_oracle.py diff --git a/crates/horizon-client/examples/mod_port_probe.rs b/crates/horizon-client/examples/mod_port_probe.rs new file mode 100644 index 000000000..c78285bbb --- /dev/null +++ b/crates/horizon-client/examples/mod_port_probe.rs @@ -0,0 +1,271 @@ +//! The Horizon side of a mod port's harness (tools/mod_port_harness.py, +//! docs/modpacks.md): builds the content root for carried-over mods and +//! writes what Horizon makes of every block state, drop, recipe and tag the +//! NeoForge oracle exported. +//! +//! cargo run -p horizon-client --example mod_port_probe -- PREPARED WORK OUT.json [MOD...] +//! +//! WORK is a `horizon-port-pack` work folder: `oracle/facts.json` and +//! `mods//carry/`. The root is built in `WORK/horizon-root`. +use horizon_client::{ + Result, + assets::Assets, + blocks::BlockFacts, + crafting::{Recipe, Recipes}, + items::{ItemStack, Items}, + mod_content::{self, ContentMod}, + stations::StationRecipes, +}; +use horizon_core::{geometry::Axis, random::LegacyRandom}; +use horizon_world::chunk::BlockState; +use serde_json::{Map, Value, json}; +use std::{collections::BTreeMap, fs, path::Path}; + +fn boxes(list: impl IntoIterator) -> Value { + let mut v: Vec<[f64; 6]> = list.into_iter().collect(); + v.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)); + json!(v) +} + +fn sound(s: &horizon_client::blocks::Sounds) -> Value { + json!({"volume": s.volume, "pitch": s.pitch, "break": &*s.break_sound, "step": &*s.step, + "place": &*s.place, "hit": &*s.hit, "fall": &*s.fall}) +} + +fn tool(name: &str) -> Option { + match name { + "hand" => None, + "silk_touch_pickaxe" => { + let mut pick = ItemStack::new("minecraft:diamond_pickaxe", 1); + pick.enchant("minecraft:silk_touch", 1); + Some(pick) + } + other => Some(ItemStack::new(&format!("minecraft:{other}"), 1)), + } +} + +fn main() -> Result<()> { + let args: Vec = std::env::args().skip(1).collect(); + let [base, work, out, wanted @ ..] = args.as_slice() else { + return Err("usage: mod_port_probe PREPARED WORK OUT.json [MOD...]".into()); + }; + let (base, work) = (Path::new(base), Path::new(work)); + let oracle: Value = serde_json::from_slice(&fs::read(work.join("oracle/facts.json"))?)?; + let mut mods = Vec::new(); + for entry in fs::read_dir(work.join("mods"))?.flatten() { + let id = entry.file_name().to_string_lossy().into_owned(); + let dir = entry.path().join("carry"); + if !(wanted.is_empty() || wanted.contains(&id)) || !dir.is_dir() { + continue; + } + let package = horizon_mods::Package::read(&dir)?; + let content = horizon_mods::Content::read(&dir, &package.manifest)?; + mods.push(ContentMod { + id: package.manifest.id.clone(), + content, + }); + } + mods.sort_by(|a, b| a.id.cmp(&b.id)); + let root = work.join("horizon-root"); + let began = std::time::Instant::now(); + let step = |what: &str| { + let what = what.to_owned(); + move |e: Box| format!("{what}: {e}") + }; + mod_content::build(base, &mods, &root).map_err(step("content root"))?; + let built = began.elapsed().as_secs_f64(); + let assets = Assets::load(&root).map_err(step("assets"))?; + let registry = assets.registry; + let facts = BlockFacts::load(&root, registry).map_err(step("block facts"))?; + let items = Items::load(&root, registry, &facts).map_err(step("items"))?; + let recipes = Recipes::load(&root, &items).map_err(step("recipes"))?; + let stations = StationRecipes::load(&root, &items); + let collisions = + horizon_client::collisions::load(&root, registry).map_err(step("collisions"))?; + let loaded = began.elapsed().as_secs_f64() - built; + let ours = |id: &str| { + id.split_once(':') + .is_some_and(|(ns, _)| mods.iter().any(|m| m.id == ns)) + }; + let tools: Vec = serde_json::from_value(oracle["tools"].clone())?; + + let mut blocks = Map::new(); + for (name, block) in oracle["blocks"].as_object().ok_or("oracle: no blocks")? { + if !ours(name) { + continue; + } + let Some(default) = registry.default_state(name) else { + blocks.insert(name.clone(), Value::Null); + continue; + }; + let mut states = Map::new(); + for (key, o) in block["states"].as_object().into_iter().flatten() { + let properties: BTreeMap = key + .split(',') + .filter(|p| !p.is_empty()) + .filter_map(|p| p.split_once('=')) + .map(|(k, v)| (k.to_owned(), v.to_owned())) + .collect(); + let descriptor = BlockState { + name: name.clone(), + properties, + }; + let Some(id) = registry.id(&descriptor) else { + states.insert(key.clone(), Value::Null); + continue; + }; + let f = facts.get(id); + let collision = collisions + .cached_shapes() + .cached_shape(id) + .ok() + .flatten() + .map(|s| { + boxes(s.boxes().iter().map(|b| { + [ + b.min(Axis::X), + b.min(Axis::Y), + b.min(Axis::Z), + b.max(Axis::X), + b.max(Axis::Y), + b.max(Axis::Z), + ] + })) + }); + let mut row = json!({ + "hardness": f.hardness, + "explosion_resistance": f.explosion_resistance, + "emission": f.emission, + "requires_tool": f.requires_tool, + "friction": f.friction, + "map_color_id": f.map_color, + "can_occlude": f.can_occlude, + "sound": sound(&f.sounds), + "outline": boxes(f.outline.iter().copied()), + "collision": collision, + "classes": f.classes.iter().map(|c| &**c).collect::>(), + }); + if o.get("drops").is_some() { + let mut drops = Map::new(); + for t in &tools { + let mut random = LegacyRandom::new(0); + let held = tool(t); + let mut counts: BTreeMap = BTreeMap::new(); + for s in items.block_drops(registry, id, held.as_ref(), &mut random) { + *counts.entry(s.item.to_string()).or_default() += s.count; + } + drops.insert(t.clone(), json!(counts)); + } + row["drops"] = Value::Object(drops); + } + states.insert(key.clone(), row); + } + let item = facts.get(default).item.to_string(); + blocks.insert( + name.clone(), + json!({"states": states, "item": item, "item_known": items.items.contains_key(&*item)}), + ); + } + + // Vanilla's sounds, by block: the harness maps the oracle's version's + // sound events to this one's through them. + let mut vanilla_sounds = Map::new(); + for name in oracle["blocks"] + .as_object() + .into_iter() + .flatten() + .map(|(k, _)| k) + { + if let Some(id) = name + .starts_with("minecraft:") + .then(|| registry.default_state(name)) + .flatten() + { + vanilla_sounds.insert(name.clone(), sound(&facts.get(id).sounds)); + } + } + + let mut item_rows = Map::new(); + for name in oracle["items"] + .as_object() + .into_iter() + .flatten() + .map(|(k, _)| k) + { + item_rows.insert( + name.clone(), + match items.items.get(name.as_str()) { + Some(i) => json!({"max_stack_size": i.max_stack, "block": i.block.map(|b| b.0)}), + None => Value::Null, + }, + ); + } + + let sorted = |list: &[String]| { + let mut v = list.to_vec(); + v.sort(); + v.dedup(); + v + }; + let mut recipe_rows = Map::new(); + for (name, recipe) in &recipes.crafting { + if !ours(name) { + continue; + } + let row = match recipe { + Recipe::Shaped { cells, result, .. } => json!({ + "result": result.item.as_deref(), "count": result.count, + "ingredients": cells.iter().flatten().map(|i| sorted(&i.1)).collect::>()}), + Recipe::Shapeless { + ingredients, + result, + } => json!({ + "result": result.item.as_deref(), "count": result.count, + "ingredients": ingredients.iter().map(|i| sorted(&i.1)).collect::>()}), + Recipe::Special(_) => json!({"special": true}), + }; + recipe_rows.insert(name.clone(), row); + } + for c in recipes.cooking.iter().filter(|c| ours(&c.id)) { + recipe_rows.insert( + c.id.clone(), + json!({"result": &*c.result.item, "count": c.result.count, + "ingredients": [sorted(&c.ingredient.1)]}), + ); + } + for s in stations.stonecutting.iter().filter(|s| ours(&s.id)) { + recipe_rows.insert( + s.id.clone(), + json!({"result": &*s.result.item, "count": s.result.count, + "ingredients": [sorted(&s.input.1)]}), + ); + } + + let mut block_tags = Map::new(); + for (tag, members) in &items.block_tags { + let mut ids: Vec<&String> = members.iter().filter(|m| ours(m)).collect(); + if !ids.is_empty() { + ids.sort(); + block_tags.insert(tag.clone(), json!(ids)); + } + } + + let report = json!({ + "states": registry.len(), + "build_seconds": built, + "load_seconds": loaded, + "blocks": blocks, + "items": item_rows, + "recipes": recipe_rows, + "block_tags": block_tags, + "vanilla_sounds": vanilla_sounds, + }); + fs::write(out, serde_json::to_vec(&report)?)?; + println!( + "{out}: {} blocks, {} items, {} recipes; root built in {built:.2} s, loaded in {loaded:.2} s", + blocks.len(), + item_rows.len(), + recipe_rows.len() + ); + Ok(()) +} diff --git a/docs/modpacks.md b/docs/modpacks.md index ed77ca411..9cdd14774 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -399,8 +399,51 @@ A **harness per mod**, generated from the tier: | deep | entity scenarios (spawn, tick N, positions and states, drops), and render captures where the look is the point, compared as images with a tolerance | The comparison skips vanilla 1.21.1-versus-26.3 differences: it normalises ids and components -through the step-4 upgrader and compares only the mod's own ids and effects. The harness format -is `tools/parity.py`'s, so the same runner, local or CI, runs vanilla and mod harnesses. +through the step-4 upgrader and compares only the mod's own ids and effects. + +**Status: the data-tier harness runs.** + +``` +python3 tools/neoforge_oracle.py export --jars --deps --out /oracle/facts.json +cargo run -p horizon-port-pack -- carry --resources .local/horizon-client/26.3 +python3 tools/mod_port_harness.py --work # or --jars/--deps to export first +``` + +- `tools/neoforge_oracle.py` installs a NeoForge server (21.1.259, ATM10's) under + `.local/neoforge-oracle/`, builds the exporter mod in `mods/horizon/src/neoforge-oracle/` (our code, dev + only), starts the server headless with the jars and writes, for every block of the mods' + namespaces and every vanilla block: the class chain, states, per-state hardness, light, tool + need, map colour, sounds, outline and collision shapes; drops for hand, diamond tools, shears + and silk touch; placement on a floor and a wall; BlockSetType and WoodType. Then items (class, + stack size, rarity, food), recipes (type, result, count, resolved ingredients) and tags. One run + with the seven mods below takes about 30 s. +- `crates/horizon-client/examples/mod_port_probe.rs` builds the content root from the carried + mods and dumps what Horizon's loaders make of the same blocks, drops, recipes and tags. +- `tools/mod_port_harness.py` compares them per mod (blocks, properties, sounds, shapes, drops, + placement against the template's in the oracle, vanilla tags, recipes, items) and writes + `/mods//harness/result.json`. It maps 1.21.1 sound events to 26.3's through the + vanilla blocks both versions have (`block.metal.*` became `block.iron.*`) and ignores vanilla + items 1.21.1 did not have (pale oak in `#minecraft:logs`). + +The oracle needs the mods' jars, so it is not a `tools/parity.py` harness: it runs where the +user's jars are, and its facts and results stay in the work folder. The first real mods +(ATM10's own jars from Modrinth, all MIT; checks passed / compared): + +| mod | blocks | properties | sounds | shapes | drops | placement | tags | recipes | items | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| Macaw's Trapdoors 1.1.5 | 179/179 | 11456/11456 | 11456/11456 | 11456/11456 | 10024/10024 | 358/358 | 534/534 | 191/191 | 191/191 | +| Macaw's Doors 1.1.5 | 239/245 | 15296/15296 | 15296/15296 | 12352/15296 | 13384/13384 | 478/478 | 941/941 | 257/257 | 251/257 | +| Macaw's Fences and Walls 1.2.1 | 150/180 | 4800/4800 | 4800/4800 | 4032/4800 | 33600/33600 | 300/300 | 432/432 | 222/222 | 150/180 | +| Macaw's Paths and Pavings 1.1.1 | 234/315 | 4602/4602 | 4602/4602 | 4472/4602 | 6734/6734 | 468/468 | 416/416 | 315/315 | 234/315 | +| Glassential-renewed 3.4.7 | 105/114 | 5177/5177 | 5177/5177 | 4727/5177 | 6447/6447 | 210/210 | 105/105 | 143/143 | 106/115 | +| Factory Blocks 1.4.0 | 42/49 | 42/42 | 0/42 | 42/42 | 294/294 | 84/84 | 42/42 | 1/1 | 42/49 | +| Cloud Glass 1.1.0 | 16/16 | 16/16 | 16/16 | 0/16 | 112/112 | 32/32 | – | 31/31 | 16/16 | + +What fails is what API 0.2 cannot express yet: shapes of their own (Japanese doors, hedges, +paths a sixteenth high, glass without collision), sound events of the mod's own +(`factory_blocks:metal_sound`), and blocks whose vanilla class has no vanilla block with the +same states (garage doors, double gates, engraved and facing paths, fans). Every drop, recipe +and tag of the declared blocks matches. ### 7. Coverage report diff --git a/mods/horizon/src/neoforge-oracle/java/dev/horizonlab/neoforge/FactsExporter.java b/mods/horizon/src/neoforge-oracle/java/dev/horizonlab/neoforge/FactsExporter.java new file mode 100644 index 000000000..c452e6488 --- /dev/null +++ b/mods/horizon/src/neoforge-oracle/java/dev/horizonlab/neoforge/FactsExporter.java @@ -0,0 +1,426 @@ +package dev.horizonlab.neoforge; + +import com.google.gson.stream.JsonWriter; +import java.io.IOException; +import java.io.Writer; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeMap; +import java.util.TreeSet; +import net.minecraft.core.BlockPos; +import net.minecraft.core.Direction; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerLevel; +import net.minecraft.sounds.SoundEvent; +import net.minecraft.world.InteractionHand; +import net.minecraft.world.item.BlockItem; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.Items; +import net.minecraft.world.item.context.BlockPlaceContext; +import net.minecraft.world.item.crafting.Ingredient; +import net.minecraft.world.item.crafting.RecipeHolder; +import net.minecraft.world.item.enchantment.Enchantments; +import net.minecraft.world.level.EmptyBlockGetter; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.Blocks; +import net.minecraft.world.level.block.SoundType; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.block.state.properties.Property; +import net.minecraft.world.level.storage.loot.LootParams; +import net.minecraft.world.level.storage.loot.parameters.LootContextParams; +import net.minecraft.world.phys.AABB; +import net.minecraft.world.phys.BlockHitResult; +import net.minecraft.world.phys.Vec3; +import net.minecraft.world.phys.shapes.VoxelShape; +import net.neoforged.bus.api.IEventBus; +import net.neoforged.fml.common.Mod; +import net.neoforged.neoforge.common.NeoForge; +import net.neoforged.neoforge.event.server.ServerStartedEvent; + +/** + * Dev-only oracle for Horizon's mod ports (docs/modpacks.md): once the server has started, + * writes every block, item, recipe and tag of the namespaces named in {@code + * horizon.oracle.namespaces} (plus the vanilla blocks, so templates can be compared) to {@code + * horizon.oracle.out}, then stops the server. Never shipped to players. + */ +@Mod("horizon_oracle") +public final class FactsExporter { + private static final BlockPos FLOOR = new BlockPos(0, 99, 0); + + public FactsExporter(IEventBus modBus) { + NeoForge.EVENT_BUS.addListener(this::started); + } + + private void started(ServerStartedEvent event) { + MinecraftServer server = event.getServer(); + Path out = Path.of(System.getProperty("horizon.oracle.out", "horizon-oracle.json")); + Set namespaces = + new TreeSet<>(Arrays.asList(System.getProperty("horizon.oracle.namespaces", "").split(","))); + namespaces.remove(""); + try (Writer w = Files.newBufferedWriter(out, StandardCharsets.UTF_8); + JsonWriter json = new JsonWriter(w)) { + new Export(server, namespaces, json).run(); + } catch (Throwable e) { + e.printStackTrace(); + System.exit(3); + } + System.out.println("horizon-oracle: wrote " + out); + server.halt(false); + } + + private static final class Export { + final MinecraftServer server; + final ServerLevel level; + final Set namespaces; + final JsonWriter json; + final List tools = new ArrayList<>(); + final List toolNames = new ArrayList<>(); + + Export(MinecraftServer server, Set namespaces, JsonWriter json) { + this.server = server; + this.level = server.overworld(); + this.namespaces = namespaces; + this.json = json; + tool("hand", ItemStack.EMPTY); + tool("diamond_pickaxe", new ItemStack(Items.DIAMOND_PICKAXE)); + tool("diamond_axe", new ItemStack(Items.DIAMOND_AXE)); + tool("diamond_shovel", new ItemStack(Items.DIAMOND_SHOVEL)); + tool("diamond_hoe", new ItemStack(Items.DIAMOND_HOE)); + tool("shears", new ItemStack(Items.SHEARS)); + ItemStack silk = new ItemStack(Items.DIAMOND_PICKAXE); + silk.enchant( + server.registryAccess() + .registryOrThrow(Registries.ENCHANTMENT) + .getHolderOrThrow(Enchantments.SILK_TOUCH), + 1); + tool("silk_touch_pickaxe", silk); + } + + void tool(String name, ItemStack stack) { + toolNames.add(name); + tools.add(stack); + } + + boolean ours(ResourceLocation id) { + return namespaces.contains(id.getNamespace()); + } + + void run() throws IOException { + json.beginObject(); + json.name("schema").value(1); + json.name("minecraft").value(net.minecraft.SharedConstants.getCurrentVersion().getName()); + json.name("namespaces"); + json.beginArray(); + for (String n : namespaces) json.value(n); + json.endArray(); + json.name("tools"); + json.beginArray(); + for (String n : toolNames) json.value(n); + json.endArray(); + blocks(); + // Vanilla's items, so harnesses can tell later versions' additions apart. + json.name("vanilla_items"); + json.beginArray(); + for (Item item : BuiltInRegistries.ITEM) { + ResourceLocation id = BuiltInRegistries.ITEM.getKey(item); + if (id.getNamespace().equals("minecraft")) json.value(id.toString()); + } + json.endArray(); + items(); + recipes(); + tags(); + json.endObject(); + } + + void blocks() throws IOException { + level.setBlock(FLOOR, Blocks.STONE.defaultBlockState(), 3); + json.name("blocks"); + json.beginObject(); + for (Block block : BuiltInRegistries.BLOCK) { + ResourceLocation id = BuiltInRegistries.BLOCK.getKey(block); + boolean mod = ours(id); + if (!mod && !id.getNamespace().equals("minecraft")) continue; + json.name(id.toString()); + json.beginObject(); + json.name("class"); + json.beginArray(); + for (Class c = block.getClass(); c != null && c != Object.class; c = c.getSuperclass()) { + json.value(c.getName()); + } + json.endArray(); + BlockState def = block.defaultBlockState(); + json.name("properties"); + json.beginObject(); + for (Property p : block.getStateDefinition().getProperties()) { + json.name(p.getName()); + json.beginArray(); + for (Object v : p.getPossibleValues()) json.value(name(p, v)); + json.endArray(); + } + json.endObject(); + json.name("default").value(stateKey(def)); + json.name("item").value(BuiltInRegistries.ITEM.getKey(block.asItem()).toString()); + json.name("explosion_resistance").value(block.getExplosionResistance()); + json.name("friction").value(block.getFriction()); + json.name("speed_factor").value(block.getSpeedFactor()); + json.name("jump_factor").value(block.getJumpFactor()); + blockSetType(block); + json.name("states"); + json.beginObject(); + for (BlockState state : block.getStateDefinition().getPossibleStates()) { + json.name(stateKey(state)); + json.beginObject(); + json.name("hardness").value(state.getDestroySpeed(EmptyBlockGetter.INSTANCE, BlockPos.ZERO)); + json.name("emission").value(state.getLightEmission()); + json.name("requires_tool").value(state.requiresCorrectToolForDrops()); + json.name("can_occlude").value(state.canOcclude()); + json.name("replaceable").value(state.canBeReplaced()); + json.name("random_ticks").value(state.isRandomlyTicking()); + var color = state.getMapColor(EmptyBlockGetter.INSTANCE, BlockPos.ZERO); + json.name("map_color").value(color.col); + json.name("map_color_id").value(color.id); + sound(state.getSoundType(level, FLOOR.above(), null)); + json.name("outline"); + boxes(state.getShape(EmptyBlockGetter.INSTANCE, BlockPos.ZERO)); + json.name("collision"); + boxes(state.getCollisionShape(EmptyBlockGetter.INSTANCE, BlockPos.ZERO)); + if (mod && lootSample(block, state)) drops(state); + json.endObject(); + } + json.endObject(); + if (block.asItem() instanceof BlockItem bi) placement(bi); + json.endObject(); + } + json.endObject(); + } + + /** Every state of a small block; else the default and each one-property change from it. */ + boolean lootSample(Block block, BlockState state) { + if (block.getStateDefinition().getPossibleStates().size() <= 32) return true; + BlockState def = block.defaultBlockState(); + int differ = 0; + for (Property p : block.getStateDefinition().getProperties()) { + if (!state.getValue(p).equals(def.getValue(p))) differ++; + } + return differ <= 1; + } + + void drops(BlockState state) throws IOException { + json.name("drops"); + json.beginObject(); + for (int i = 0; i < tools.size(); i++) { + LootParams.Builder params = + new LootParams.Builder(level) + .withParameter(LootContextParams.ORIGIN, Vec3.atCenterOf(FLOOR.above())) + .withParameter(LootContextParams.TOOL, tools.get(i).copy()); + Map counts = new TreeMap<>(); + for (ItemStack s : state.getDrops(params)) { + counts.merge(BuiltInRegistries.ITEM.getKey(s.getItem()).toString(), s.getCount(), Integer::sum); + } + json.name(toolNames.get(i)); + json.beginObject(); + for (Map.Entry e : counts.entrySet()) json.name(e.getKey()).value(e.getValue()); + json.endObject(); + } + json.endObject(); + } + + void placement(BlockItem item) throws IOException { + BlockPos at = FLOOR.above(); + level.setBlock(at, Blocks.AIR.defaultBlockState(), 3); + json.name("placement"); + json.beginObject(); + for (Direction face : new Direction[] {Direction.UP, Direction.NORTH}) { + BlockPos clicked = face == Direction.UP ? FLOOR : at.relative(face.getOpposite()); + level.setBlock(clicked, Blocks.STONE.defaultBlockState(), 3); + Vec3 hit = Vec3.atCenterOf(clicked).add(Vec3.atLowerCornerOf(face.getNormal()).scale(0.5)); + // A player-less context (the constructor is protected, hence the subclass). + BlockPlaceContext ctx = + new BlockPlaceContext( + level, null, InteractionHand.MAIN_HAND, new ItemStack(item), + new BlockHitResult(hit, face, clicked, false)) {}; + BlockState placed = null; + try { + placed = item.getBlock().getStateForPlacement(ctx); + } catch (RuntimeException e) { + // Needs a player: recorded as no placement. + } + json.name(face.getName()).value(placed == null ? null : stateKey(placed)); + if (face != Direction.UP) level.setBlock(clicked, Blocks.AIR.defaultBlockState(), 3); + } + json.endObject(); + } + + /** The BlockSetType (doors, trapdoors, buttons, plates) and WoodType (fence gates) a block keeps. */ + void blockSetType(Block block) throws IOException { + String setType = null, woodType = null; + Boolean byHand = null; + for (Class c = block.getClass(); c != null && c != Object.class; c = c.getSuperclass()) { + for (var f : c.getDeclaredFields()) { + try { + if (f.getType() == net.minecraft.world.level.block.state.properties.BlockSetType.class && setType == null) { + f.setAccessible(true); + var t = (net.minecraft.world.level.block.state.properties.BlockSetType) f.get(block); + if (t != null) { + setType = t.name(); + byHand = t.canOpenByHand(); + } + } else if (f.getType() == net.minecraft.world.level.block.state.properties.WoodType.class && woodType == null) { + f.setAccessible(true); + var t = (net.minecraft.world.level.block.state.properties.WoodType) f.get(block); + if (t != null) woodType = t.name(); + } + } catch (ReflectiveOperationException | RuntimeException e) { + // Not readable: left out. + } + } + } + if (setType != null) { + json.name("block_set_type"); + json.beginObject(); + json.name("name").value(setType); + json.name("can_open_by_hand").value(byHand); + json.endObject(); + } + if (woodType != null) json.name("wood_type").value(woodType); + } + + void sound(SoundType s) throws IOException { + json.name("sound"); + json.beginObject(); + json.name("volume").value(s.getVolume()); + json.name("pitch").value(s.getPitch()); + event("break", s.getBreakSound()); + event("step", s.getStepSound()); + event("place", s.getPlaceSound()); + event("hit", s.getHitSound()); + event("fall", s.getFallSound()); + json.endObject(); + } + + void event(String name, SoundEvent e) throws IOException { + json.name(name).value(e.getLocation().toString()); + } + + void boxes(VoxelShape shape) throws IOException { + json.beginArray(); + for (AABB b : shape.toAabbs()) { + json.beginArray(); + json.value(b.minX).value(b.minY).value(b.minZ).value(b.maxX).value(b.maxY).value(b.maxZ); + json.endArray(); + } + json.endArray(); + } + + void items() throws IOException { + json.name("items"); + json.beginObject(); + for (Item item : BuiltInRegistries.ITEM) { + ResourceLocation id = BuiltInRegistries.ITEM.getKey(item); + if (!ours(id)) continue; + ItemStack stack = new ItemStack(item); + json.name(id.toString()); + json.beginObject(); + json.name("class").value(item.getClass().getName()); + json.name("max_stack_size").value(stack.getMaxStackSize()); + json.name("rarity").value(stack.getRarity().getSerializedName()); + if (item instanceof BlockItem bi) { + json.name("block").value(BuiltInRegistries.BLOCK.getKey(bi.getBlock()).toString()); + } + var food = stack.get(net.minecraft.core.component.DataComponents.FOOD); + if (food != null) { + json.name("food"); + json.beginObject(); + json.name("nutrition").value(food.nutrition()); + json.name("saturation").value(food.saturation()); + json.endObject(); + } + json.endObject(); + } + json.endObject(); + } + + void recipes() throws IOException { + json.name("recipes"); + json.beginObject(); + for (RecipeHolder holder : server.getRecipeManager().getRecipes()) { + if (!ours(holder.id())) continue; + var recipe = holder.value(); + json.name(holder.id().toString()); + json.beginObject(); + json.name("type").value(BuiltInRegistries.RECIPE_TYPE.getKey(recipe.getType()).toString()); + json.name("serializer").value(BuiltInRegistries.RECIPE_SERIALIZER.getKey(recipe.getSerializer()).toString()); + ItemStack result = recipe.getResultItem(server.registryAccess()); + json.name("result").value(BuiltInRegistries.ITEM.getKey(result.getItem()).toString()); + json.name("count").value(result.getCount()); + json.name("ingredients"); + json.beginArray(); + for (Ingredient ing : recipe.getIngredients()) { + Set ids = new TreeSet<>(); + for (ItemStack s : ing.getItems()) ids.add(BuiltInRegistries.ITEM.getKey(s.getItem()).toString()); + json.beginArray(); + for (String i : ids) json.value(i); + json.endArray(); + } + json.endArray(); + json.endObject(); + } + json.endObject(); + } + + /** Tags that hold one of our ids, with only those members; and every `c` tag, whole. */ + void tags() throws IOException { + json.name("tags"); + json.beginObject(); + for (String kind : new String[] {"block", "item"}) { + json.name(kind); + json.beginObject(); + Map> out = new TreeMap<>(); + var registry = kind.equals("block") ? BuiltInRegistries.BLOCK : BuiltInRegistries.ITEM; + registry.getTags().forEach(pair -> { + String tag = pair.getFirst().location().toString(); + boolean convention = pair.getFirst().location().getNamespace().equals("c"); + Set members = new LinkedHashSet<>(); + for (var holder : pair.getSecond()) { + ResourceLocation id = holder.unwrapKey().orElseThrow().location(); + if (convention || ours(id) || ours(pair.getFirst().location())) members.add(id.toString()); + } + if (!members.isEmpty()) out.put(tag, new TreeSet<>(members)); + }); + for (var e : out.entrySet()) { + json.name(e.getKey()); + json.beginArray(); + for (String m : e.getValue()) json.value(m); + json.endArray(); + } + json.endObject(); + } + json.endObject(); + } + + static String stateKey(BlockState state) { + StringBuilder b = new StringBuilder(); + for (Property p : state.getProperties()) { + if (b.length() > 0) b.append(','); + b.append(p.getName()).append('=').append(name(p, state.getValue(p))); + } + return b.toString(); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + static String name(Property p, Object v) { + return p.getName((Comparable) v); + } + } +} diff --git a/mods/horizon/src/neoforge-oracle/resources/META-INF/neoforge.mods.toml b/mods/horizon/src/neoforge-oracle/resources/META-INF/neoforge.mods.toml new file mode 100644 index 000000000..006875e95 --- /dev/null +++ b/mods/horizon/src/neoforge-oracle/resources/META-INF/neoforge.mods.toml @@ -0,0 +1,11 @@ +# Dev-only: the NeoForge oracle for Horizon's mod-port harnesses (docs/modpacks.md). +# Built and run by tools/neoforge_oracle.py; never shipped. +modLoader = "javafml" +loaderVersion = "[4,)" +license = "Apache-2.0" + +[[mods]] +modId = "horizon_oracle" +version = "1" +displayName = "Horizon oracle (dev only)" +description = "Exports block, item, recipe and tag facts for Horizon's parity harnesses." diff --git a/tools/mod_port_harness.py b/tools/mod_port_harness.py new file mode 100644 index 000000000..23f7e82b9 --- /dev/null +++ b/tools/mod_port_harness.py @@ -0,0 +1,211 @@ +#!/usr/bin/env python3 +"""Per-mod parity harness for ported mods (docs/modpacks.md, "The Java oracle and per-mod harnesses"). + + mod_port_harness.py --work WORK [--resources PREPARED] [--jars DIR --deps DIR] [MOD ...] + +WORK is a `horizon-port-pack` work folder whose mods were carried over. With --jars the NeoForge +oracle (tools/neoforge_oracle.py, dev-only) first exports WORK/oracle/facts.json. The Horizon side +is crates/horizon-client/examples/mod_port_probe.rs: the content root built from WORK/mods/*/carry +and what the game's loaders make of it. For every block and item the mod registers, compared: + +- blocks: declared in Horizon at all; per state hardness, explosion resistance, light, tool need, + friction, map colour, sounds, outline and collision shapes; +- drops: the loot of each sampled state for hand, diamond tools, shears and silk touch; +- placement: the state the block takes when placed, against its template's in the same oracle + (Horizon places the template as vanilla does, which the vanilla harnesses check); +- tags: the vanilla block tags (tool and mining tags) holding the mod's blocks; +- recipes: each recipe's result, count and ingredients; +- items: present, and their stack size. + +Writes WORK/mods//harness/result.json per mod and prints a table. Jars, facts and results stay +in WORK, outside the repository. +""" +import argparse +import json +import math +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +CHECKS = ['blocks', 'properties', 'sounds', 'shapes', 'drops', 'placement', 'tags', 'recipes', 'items'] +EXAMPLES = 8 + + +def key(k): + return ','.join(sorted(p for p in k.split(',') if p)) + + +def cells(boxes, grid=32): + out = set() + for b in boxes: + lo = [math.floor(round(v * grid, 6)) for v in b[:3]] + hi = [math.ceil(round(v * grid, 6)) for v in b[3:]] + for x in range(lo[0], hi[0]): + for y in range(lo[1], hi[1]): + for z in range(lo[2], hi[2]): + out.add((x, y, z)) + return out + + +def same_shape(a, b): + if a is None or b is None: + return a == b + sa, sb = sorted(map(tuple, a)), sorted(map(tuple, b)) + if sa == sb: + return True + return cells(a) == cells(b) + + +class Check: + def __init__(self): + self.passed = 0 + self.failed = 0 + self.examples = [] + + def record(self, ok, what): + if ok: + self.passed += 1 + else: + self.failed += 1 + if len(self.examples) < EXAMPLES: + self.examples.append(what) + + def json(self): + return {'passed': self.passed, 'failed': self.failed, 'examples': self.examples} + + +def sound_upgrades(oracle, horizon): + """The oracle version's vanilla sound sets → this version's, through the vanilla blocks both have.""" + out = {} + for name, hs in horizon.get('vanilla_sounds', {}).items(): + ob = oracle['blocks'].get(name) + if ob: + os_ = ob['states'].get(ob['default']) or next(iter(ob['states'].values())) + out.setdefault(json.dumps(os_['sound'], sort_keys=True), []).append(hs) + return out + + +def compare_mod(mod, oracle, horizon, carry, upgrades, old_items): + checks = {c: Check() for c in CHECKS} + prefix = mod + ':' + templates = {prefix + b: t for b, t in carry.get('blocks', {}).items()} + vanilla_tags = {t: set(m) for t, m in oracle['tags']['block'].items() if t.startswith('minecraft:')} + for name, ob in oracle['blocks'].items(): + if not name.startswith(prefix): + continue + hb = horizon['blocks'].get(name) + checks['blocks'].record(hb is not None, f'{name}: not in Horizon ({carry.get("blocks_unknown", {}).get(name[len(prefix):], "left out")})') + if hb is None: + continue + for k, os_ in ob['states'].items(): + hs = hb['states'].get(k) + if hs is None: + checks['properties'].record(False, f'{name}[{k}]: no such state in Horizon') + continue + props = [('hardness', os_['hardness'], hs['hardness']), + ('explosion_resistance', ob['explosion_resistance'], hs['explosion_resistance']), + ('emission', os_['emission'], hs['emission']), + ('requires_tool', os_['requires_tool'], hs['requires_tool']), + ('friction', ob['friction'], hs['friction']), + ('map_color', os_['map_color_id'], hs['map_color_id'])] + bad = [f'{p} {o} vs {h}' for p, o, h in props + if (abs(o - h) > 1e-6 if isinstance(o, float) else o != h)] + checks['properties'].record(not bad, f'{name}[{k}]: ' + '; '.join(bad)) + upgraded = upgrades.get(json.dumps(os_['sound'], sort_keys=True), []) + checks['sounds'].record(os_['sound'] == hs['sound'] or hs['sound'] in upgraded, + f'{name}[{k}]: {os_["sound"]["break"]} vs {hs["sound"]["break"]}') + shapes_ok = same_shape(os_['outline'], hs['outline']) and same_shape(os_['collision'], hs['collision']) + checks['shapes'].record(shapes_ok, f'{name}[{k}]: outline {os_["outline"]} vs {hs["outline"]}') + for tool, odrops in os_.get('drops', {}).items(): + hdrops = (hs.get('drops') or {}).get(tool) + checks['drops'].record(odrops == hdrops, f'{name}[{k}] {tool}: {odrops} vs {hdrops}') + # Placement: the mod block against its template, both in the oracle. + template = templates.get(name) + ot = oracle['blocks'].get(template) if template else None + if ot and 'placement' in ob: + for face, placed in ob['placement'].items(): + theirs = ot.get('placement', {}).get(face) + checks['placement'].record( + placed is not None and theirs is not None and key(placed) == key(theirs), + f'{name} on {face}: {placed} vs {template} {theirs}') + for tag, members in vanilla_tags.items(): + if name in members: + checks['tags'].record(name in horizon['block_tags'].get(tag, []), f'{name}: not in #{tag}') + for rid, orec in oracle['recipes'].items(): + if not rid.startswith(prefix): + continue + hrec = horizon['recipes'].get(rid) + if hrec is None: + checks['recipes'].record(False, f'{rid} ({orec["type"]}): not loaded') + continue + # Vanilla items added after the oracle's version (pale oak in a log tag) are not the mod's. + newer = lambda i: i.startswith('minecraft:') and old_items and i not in old_items + oing = sorted(sorted(i) for i in orec['ingredients'] if i) + hing = sorted(sorted(x for x in i if not newer(x)) for i in hrec.get('ingredients', []) if i) + ok = (orec['result'], orec['count']) == (hrec.get('result'), hrec.get('count')) and oing == hing + why = f'{rid}: {orec["result"]} x{orec["count"]} vs {hrec.get("result")} x{hrec.get("count")}' + if oing != hing: + missing = [i for i in oing if i not in hing][:2] + why += f'; ingredients differ, e.g. oracle {missing}' + checks['recipes'].record(ok, why) + for iid, oi in oracle['items'].items(): + if not iid.startswith(prefix): + continue + hi = horizon['items'].get(iid) + checks['items'].record(hi is not None and hi['max_stack_size'] == oi['max_stack_size'], + f'{iid}: {"missing" if hi is None else "stack " + str(hi["max_stack_size"])}') + result = {c: v.json() for c, v in checks.items()} + failed = sum(v.failed for v in checks.values()) + total = sum(v.passed + v.failed for v in checks.values()) + return {'mod': mod, 'passed': failed == 0 and total > 0, 'checks': result, + 'blocks_with_differences': len(carry.get('differences', {}))} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--work', required=True) + parser.add_argument('--resources', default=str(ROOT / '.local/horizon-client/26.3')) + parser.add_argument('--jars', help='export the oracle facts from these jars first') + parser.add_argument('--deps') + parser.add_argument('mods', nargs='*') + args = parser.parse_args() + work = Path(args.work).resolve() + facts = work / 'oracle' / 'facts.json' + if args.jars: + facts.parent.mkdir(parents=True, exist_ok=True) + command = [sys.executable, str(ROOT / 'tools/neoforge_oracle.py'), 'export', '--jars', args.jars, '--out', str(facts)] + if args.deps: + command += ['--deps', args.deps] + subprocess.run(command, check=True) + if not facts.exists(): + sys.exit(f'{facts}: no oracle facts (run with --jars, or tools/neoforge_oracle.py export)') + subprocess.run(['cargo', 'build', '--release', '-q', '-p', 'horizon-client', '--example', 'mod_port_probe'], + cwd=ROOT, check=True) + metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], + cwd=ROOT, text=True)) + probe = Path(metadata['target_directory']) / 'release/examples/mod_port_probe' + out = work / 'horizon.json' + subprocess.run([str(probe), args.resources, str(work), str(out), *args.mods], check=True) + oracle = json.loads(facts.read_text()) + horizon = json.loads(out.read_text()) + upgrades = sound_upgrades(oracle, horizon) + old_items = set(oracle.get('vanilla_items', [])) + mods = args.mods or sorted(p.name for p in (work / 'mods').iterdir() if (p / 'carry').is_dir()) + print(f'{"mod":<16} {"result":<7} ' + ' '.join(f'{c:>12}' for c in CHECKS)) + for mod in mods: + carry_report = work / 'mods' / mod / 'carry-report.json' + carry = json.loads(carry_report.read_text()) if carry_report.exists() else {} + result = compare_mod(mod, oracle, horizon, carry, upgrades, old_items) + (work / 'mods' / mod / 'harness').mkdir(parents=True, exist_ok=True) + (work / 'mods' / mod / 'harness' / 'result.json').write_text(json.dumps(result, indent=1)) + cols = [] + for c in CHECKS: + r = result['checks'][c] + n = r['passed'] + r['failed'] + cols.append(f'{r["passed"]}/{n}' if n else '-') + print(f'{mod:<16} {"pass" if result["passed"] else "FAIL":<7} ' + ' '.join(f'{c:>12}' for c in cols)) + + +if __name__ == '__main__': + main() diff --git a/tools/neoforge_oracle.py b/tools/neoforge_oracle.py new file mode 100644 index 000000000..f72bbec3e --- /dev/null +++ b/tools/neoforge_oracle.py @@ -0,0 +1,164 @@ +#!/usr/bin/env python3 +"""Dev-only NeoForge oracle for Horizon's mod-port harnesses (docs/modpacks.md). + + neoforge_oracle.py export --jars DIR [--deps DIR] [--namespaces a,b] --out FACTS.json + +installs a NeoForge server under .local/neoforge-oracle (once), builds the exporter mod in +mods/horizon/src/neoforge-oracle, starts the server headless with the given mod jars, and writes every +block, item, recipe and tag of the mods' namespaces (and the vanilla blocks, for templates) to +FACTS.json. The jars are the user's own; nothing here is shipped or committed. +""" +import argparse +import json +import os +import shutil +import subprocess +import sys +import time +import urllib.request +import zipfile +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +LOCAL = ROOT / '.local' / 'neoforge-oracle' +SOURCE = ROOT / 'mods' / 'horizon' / 'src' / 'neoforge-oracle' +# ATM10 8.x: Minecraft 1.21.1 on NeoForge 21.1.259 (docs/modpacks.md). +NEOFORGE = os.environ.get('HORIZON_NEOFORGE', '21.1.259') +MAVEN = 'https://maven.neoforged.net/releases/net/neoforged/neoforge' + + +def install(): + """The NeoForge server, installed once per version.""" + home = LOCAL / NEOFORGE + args = home / f'libraries/net/neoforged/neoforge/{NEOFORGE}/unix_args.txt' + if args.exists(): + return home + home.mkdir(parents=True, exist_ok=True) + installer = LOCAL / f'neoforge-{NEOFORGE}-installer.jar' + if not installer.exists(): + url = f'{MAVEN}/{NEOFORGE}/neoforge-{NEOFORGE}-installer.jar' + with urllib.request.urlopen(url, timeout=120) as r: + installer.write_bytes(r.read()) + with (LOCAL / f'install-{NEOFORGE}.log').open('w') as log: + subprocess.run(['java', '-jar', str(installer), '--installServer', str(home)], + cwd=LOCAL, stdout=log, stderr=subprocess.STDOUT, check=True) + return home + + +def classpath(home): + libs = home / 'libraries' + first = [libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-server.jar', + libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-universal.jar'] + rest = sorted(p for p in libs.rglob('*.jar') if p not in first and 'slim' not in p.name + and 'extra' not in p.name and not p.name.endswith('-unpacked.jar')) + return os.pathsep.join(map(str, first + rest)) + + +def build(home): + """The exporter mod jar, rebuilt when its sources change.""" + out = LOCAL / 'build' + jar = out / 'horizon-oracle.jar' + sources = sorted((SOURCE / 'java').rglob('*.java')) + resources = sorted(p for p in (SOURCE / 'resources').rglob('*') if p.is_file()) + newest = max(p.stat().st_mtime for p in sources + resources) + if jar.exists() and jar.stat().st_mtime > newest: + return jar + classes = out / 'classes' + shutil.rmtree(classes, ignore_errors=True) + classes.mkdir(parents=True) + javac = subprocess.run(['javac', '--release', '21', '-proc:none', '-nowarn', '-cp', classpath(home), + '-d', str(classes), *map(str, sources)], capture_output=True, text=True) + if javac.returncode: + sys.exit(f'the exporter does not compile:\n{javac.stdout}{javac.stderr}') + with zipfile.ZipFile(jar, 'w', zipfile.ZIP_DEFLATED) as z: + for p in sorted(classes.rglob('*.class')): + z.write(p, p.relative_to(classes).as_posix()) + for p in resources: + z.write(p, p.relative_to(SOURCE / 'resources').as_posix()) + return jar + + +SERVER_PROPERTIES = """level-type=minecraft\\:flat +online-mode=false +server-port=0 +spawn-protection=0 +view-distance=2 +simulation-distance=2 +generate-structures=false +spawn-monsters=false +spawn-animals=false +""" + + +def instance(name, jars, extra=()): + """A server folder with `jars` (and the exporter) in mods/.""" + home = install() + run = LOCAL / 'runs' / name + shutil.rmtree(run, ignore_errors=True) + (run / 'mods').mkdir(parents=True) + (run / 'libraries').symlink_to(home / 'libraries') + (run / 'eula.txt').write_text('eula=true\n') + (run / 'server.properties').write_text(SERVER_PROPERTIES) + for jar in [*jars, *extra]: + (run / 'mods' / Path(jar).name).symlink_to(Path(jar).resolve()) + return home, run + + +def start(home, run, props, log_name='server.log', timeout=900): + """Runs the server to its end; returns (seconds, the log).""" + args = home / f'libraries/net/neoforged/neoforge/{NEOFORGE}/unix_args.txt' + command = ['java', '-Xmx4G', *[f'-D{k}={v}' for k, v in props.items()], f'@{args}', 'nogui'] + began = time.monotonic() + with (run / log_name).open('w') as log: + subprocess.run(command, cwd=run, stdin=subprocess.DEVNULL, stdout=log, + stderr=subprocess.STDOUT, timeout=timeout) + return time.monotonic() - began, (run / log_name).read_text(errors='replace') + + +def mod_ids(jar): + """The mod ids a jar declares (its neoforge.mods.toml).""" + import tomllib + with zipfile.ZipFile(jar) as z: + for name in ('META-INF/neoforge.mods.toml', 'META-INF/mods.toml'): + if name in z.namelist(): + try: + toml = tomllib.loads(z.read(name).decode('utf-8', 'replace')) + except tomllib.TOMLDecodeError: + return [] + return [m.get('modId', '') for m in toml.get('mods', [])] + return [] + + +def export(args): + jars = sorted(Path(args.jars).glob('*.jar')) + deps = sorted(Path(args.deps).glob('*.jar')) if args.deps else [] + namespaces = args.namespaces or ','.join(i for j in jars for i in mod_ids(j)) + home = install() + exporter = build(home) + home, run = instance('export', jars, [*deps, exporter]) + out = Path(args.out).resolve() + out.unlink(missing_ok=True) + seconds, log = start(home, run, {'horizon.oracle.out': out, 'horizon.oracle.namespaces': namespaces}) + if not out.exists(): + tail = '\n'.join(log.splitlines()[-40:]) + sys.exit(f'the oracle wrote nothing; the end of {run / "server.log"}:\n{tail}') + facts = json.loads(out.read_text()) + mods = sum(1 for b in facts['blocks'] if not b.startswith('minecraft:')) + print(f'{out}: {mods} mod blocks, {len(facts["items"])} items, {len(facts["recipes"])} recipes ' + f'({namespaces}); server ran {seconds:.1f} s') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + sub = parser.add_subparsers(dest='command', required=True) + e = sub.add_parser('export', help='write the facts of the mods in --jars') + e.add_argument('--jars', required=True, help='the mods to export') + e.add_argument('--deps', help='their required libraries (loaded, not exported)') + e.add_argument('--namespaces', help='comma-separated; default: the jars\' mod ids') + e.add_argument('--out', required=True) + args = parser.parse_args() + {'export': export}[args.command](args) + + +if __name__ == '__main__': + main() From 0560bbf87607c435bab58b7005b0fe0707891fec Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 23:28:43 +0200 Subject: [PATCH 09/28] horizon-port-pack report: coverage per mod, and ATM10 measured `report ` writes coverage.json and coverage.md: per mod ported, partial, not yet or not needed with the reason, and the totals by class, tier and licence family. It reads the inventory, each mod's carry report and its harness result: ported is a green harness with nothing left out (blocks with a class of their own are counted and named); partial lists the failing checks, the blocks left out and what the templates miss; not yet names the API tier or the dependency it waits for; not needed covers libraries, performance mods and pack tooling. Unclassified mods are not yet, never not needed. `import` also reads Crash Assistant's modlist.json, the list ATM10 publishes in its repository (mod ids, names, versions, Modrinth hashes, the loader entry), and the inventory uses its mod ids and names when there is no jar. ATM10 (496 files, the eight mods we downloaded carried and checked): ported 1, partial 7, not yet 367, not needed 121. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-port-pack/src/import.rs | 90 ++++- crates/horizon-port-pack/src/inventory.rs | 10 +- crates/horizon-port-pack/src/main.rs | 24 +- crates/horizon-port-pack/src/report.rs | 428 ++++++++++++++++++++++ docs/modpacks.md | 36 +- 5 files changed, 579 insertions(+), 9 deletions(-) create mode 100644 crates/horizon-port-pack/src/report.rs diff --git a/crates/horizon-port-pack/src/import.rs b/crates/horizon-port-pack/src/import.rs index b0f5d04c2..dd712acf1 100644 --- a/crates/horizon-port-pack/src/import.rs +++ b/crates/horizon-port-pack/src/import.rs @@ -1,5 +1,6 @@ -//! Step 1, import: a Modrinth `.mrpack`, a CurseForge zip, or an instance -//! folder (Prism / MultiMC, or a plain `mods/` folder) to `pack.json`. +//! Step 1, import: a Modrinth `.mrpack`, a CurseForge zip, an instance +//! folder (Prism / MultiMC, or a plain `mods/` folder), or a Crash Assistant +//! `modlist.json` (the list packs such as ATM10 publish) to `pack.json`. use serde::{Deserialize, Serialize}; use serde_json::Value; use std::{ @@ -37,6 +38,13 @@ pub struct PackFile { /// CurseForge project and file ids. #[serde(default, skip_serializing_if = "Option::is_none")] pub curseforge: Option<(u64, u64)>, + /// The mod id, name and version a mod list states (`modlist.json`). + #[serde(default, skip_serializing_if = "Option::is_none")] + pub mod_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub version: Option, /// The jar on disk (instances only). #[serde(default, skip_serializing_if = "Option::is_none")] pub jar: Option, @@ -63,6 +71,12 @@ pub fn import(path: &Path) -> Result { if path.is_dir() { return instance(path); } + if path.extension().is_some_and(|e| e == "json") { + let text = fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?; + let list: Value = serde_json::from_str(text.trim_start_matches('\u{feff}')) + .map_err(|e| format!("{}: {e}", path.display()))?; + return modlist(&list); + } let file = fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?; let mut zip = zip::ZipArchive::new(file).map_err(|e| format!("{}: {e}", path.display()))?; if let Some(index) = read_json(&mut zip, "modrinth.index.json")? { @@ -186,6 +200,54 @@ pub fn curseforge(manifest: &Value, names: &[String]) -> Pack { } } +/// Crash Assistant's `config/crash_assistant/modlist.json`: jar name → mod +/// id, name, version and Modrinth SHA-1, with the loader as an entry of its +/// own. NeoForge `21.1.x` runs Minecraft 1.21.1. +pub fn modlist(list: &Value) -> Result { + let entries = list.as_object().ok_or("modlist.json: not an object")?; + let mut pack = Pack { + name: "modlist".into(), + format: "modlist".into(), + ..Pack::default() + }; + for (key, e) in entries { + let jar = e["jarName"].as_str().unwrap_or(key); + if jar.ends_with("(modloader)") { + let version = str_of(e, "version"); + let (loader, v) = version.split_once('-').unwrap_or(("", &version)); + pack.loader = loader.to_owned(); + pack.loader_version = v.to_owned(); + if loader == "neoforge" { + let mut parts = v.split('.'); + if let (Some(a), Some(b)) = (parts.next(), parts.next()) { + pack.minecraft = if b == "0" { + format!("1.{a}") + } else { + format!("1.{a}.{b}") + }; + } + } + continue; + } + let folder = if jar.ends_with(".zip") { + "datapacks" + } else { + "mods" + }; + let text = |k: &str| e[k].as_str().filter(|v| !v.is_empty()).map(str::to_owned); + pack.files.push(PackFile { + path: format!("{folder}/{jar}"), + sha1: text("modrinthHash"), + mod_id: text("modId"), + name: text("name"), + version: text("version"), + ..PackFile::default() + }); + } + pack.files.sort_by(|a, b| a.path.cmp(&b.path)); + Ok(pack) +} + /// A Prism / MultiMC instance (`mmc-pack.json`), a game folder, or a /// folder of jars: the jars on disk, hashed. fn instance(dir: &Path) -> Result { @@ -319,6 +381,30 @@ mod tests { ); } + #[test] + fn reads_a_crash_assistant_mod_list() { + let list = serde_json::json!({ + "neoforge-21.1.259 (modloader)": {"jarName": "neoforge-21.1.259 (modloader)", + "modId": "neoforge", "version": "neoforge-21.1.259"}, + "mcw-doors-1.1.2.jar": {"jarName": "mcw-doors-1.1.2.jar", "modId": "mcwdoors", + "modrinthHash": "0123456789abcdef0123456789abcdef01234567"}, + "sawmill.zip": {"jarName": "sawmill.zip"} + }); + let pack = modlist(&list).unwrap(); + assert_eq!( + ( + pack.minecraft.as_str(), + pack.loader.as_str(), + pack.loader_version.as_str() + ), + ("1.21.1", "neoforge", "21.1.259") + ); + let paths: Vec<&str> = pack.files.iter().map(|f| f.path.as_str()).collect(); + assert_eq!(paths, ["datapacks/sawmill.zip", "mods/mcw-doors-1.1.2.jar"]); + assert!(pack.files[1].sha1.is_some()); + assert_eq!(pack.files[1].mod_id.as_deref(), Some("mcwdoors")); + } + #[test] fn reads_a_curseforge_manifest() { let manifest = json!({"name": "CF", "overrides": "overrides", diff --git a/crates/horizon-port-pack/src/inventory.rs b/crates/horizon-port-pack/src/inventory.rs index 49661f1ae..57c043ae3 100644 --- a/crates/horizon-port-pack/src/inventory.rs +++ b/crates/horizon-port-pack/src/inventory.rs @@ -78,6 +78,7 @@ pub fn build(pack: &Pack, cache: &Cache, work: &Path) -> Vec { .as_ref() .map(|i| i.mod_id.clone()) .filter(|k| !k.is_empty()) + .or_else(|| f.mod_id.clone()) .or_else(|| Some(p("slug")).filter(|s| !s.is_empty())) .unwrap_or(stem); let (client, server) = match project { @@ -97,7 +98,9 @@ pub fn build(pack: &Pack, cache: &Cache, work: &Path) -> Vec { .as_ref() .map(|i| i.name.clone()) .filter(|n| !n.is_empty()) - .unwrap_or_else(|| p("title")); + .or_else(|| Some(p("title")).filter(|t| !t.is_empty())) + .or_else(|| f.name.clone()) + .unwrap_or_default(); let (class, tier, confidence) = match known.get(&[key.as_str(), p("slug").as_str(), name.as_str()]) { Some((c, t)) => (c.clone(), t.clone(), "known".to_owned()), @@ -123,8 +126,9 @@ pub fn build(pack: &Pack, cache: &Cache, work: &Path) -> Vec { .versions .get(sha1) .and_then(|v| v["version_number"].as_str()) - .unwrap_or("") - .to_owned() + .map(str::to_owned) + .or_else(|| f.version.clone()) + .unwrap_or_default() }), path: f.path.clone(), class, diff --git a/crates/horizon-port-pack/src/main.rs b/crates/horizon-port-pack/src/main.rs index 74178f503..3e6cdf4d7 100644 --- a/crates/horizon-port-pack/src/main.rs +++ b/crates/horizon-port-pack/src/main.rs @@ -12,6 +12,10 @@ //! (`tools/neoforge_oracle.py`), blocks and items come from its facts; //! `--resources` limits templates to the blocks Horizon's tables have. //! +//! - `report `: the coverage report, per mod ported, partial, not yet +//! or not needed with the reason, in `/coverage.json` and +//! `coverage.md`. +//! //! The work folder belongs to the user: jars and carried-over files stay //! there and are never uploaded or committed. mod carry; @@ -21,10 +25,11 @@ mod inventory; mod jar; mod modrinth; mod oracle; +mod report; use std::{fs, path::Path, process::ExitCode}; -const USAGE: &str = "usage: horizon-port-pack import | inventory [--offline] | carry [--resources ] [...]"; +const USAGE: &str = "usage: horizon-port-pack import | inventory [--offline] | carry [--resources ] [...] | report "; fn main() -> ExitCode { let args: Vec = std::env::args().skip(1).collect(); @@ -49,6 +54,7 @@ fn main() -> ExitCode { }; carry(w, resources.as_deref(), &rest) }), + Some("report") => path(1).and_then(report), _ => Err(USAGE.to_owned()), }; match result { @@ -70,6 +76,22 @@ fn read_json(path: &Path) -> Result { serde_json::from_str(&text).map_err(|e| format!("{}: {e}", path.display())) } +fn report(work: &Path) -> Result<(), String> { + let pack: import::Pack = read_json(&work.join("pack.json"))?; + let records: Vec = read_json(&work.join("inventory.json"))?; + let rows = report::build(&records, work); + write_json(&work.join("coverage.json"), &rows)?; + let title = format!( + "{} ({} {}, Minecraft {})", + pack.name, pack.loader, pack.loader_version, pack.minecraft + ); + fs::write(work.join("coverage.md"), report::markdown(&title, &rows)) + .map_err(|e| format!("coverage.md: {e}"))?; + println!("{title}: {} files: {:?}", rows.len(), report::counts(&rows)); + println!("{}", work.join("coverage.md").display()); + Ok(()) +} + fn import(pack: &Path, work: &Path) -> Result<(), String> { let pack = import::import(pack)?; fs::create_dir_all(work).map_err(|e| format!("{}: {e}", work.display()))?; diff --git a/crates/horizon-port-pack/src/report.rs b/crates/horizon-port-pack/src/report.rs new file mode 100644 index 000000000..ffa025c79 --- /dev/null +++ b/crates/horizon-port-pack/src/report.rs @@ -0,0 +1,428 @@ +//! Step 7, the coverage report: per mod, ported, partial, not yet or not +//! needed, with the reason, and the totals by class, tier and licence +//! (`coverage.json`, `coverage.md`). It reads what the other steps wrote: +//! the inventory, each mod's `carry-report.json` and its harness result +//! (`tools/mod_port_harness.py`). +use crate::inventory::Record; +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use std::{collections::BTreeMap, fmt::Write, path::Path}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +pub enum Status { + Ported, + Partial, + NotYet, + NotNeeded, +} +impl Status { + pub const ALL: [Status; 4] = [ + Status::Ported, + Status::Partial, + Status::NotYet, + Status::NotNeeded, + ]; + pub fn label(self) -> &'static str { + match self { + Status::Ported => "ported", + Status::Partial => "partial", + Status::NotYet => "not yet", + Status::NotNeeded => "not needed", + } + } +} + +#[derive(Debug, Serialize, Deserialize)] +pub struct Row { + pub key: String, + pub name: String, + pub class: String, + pub tier: String, + pub license: String, + /// `permissive`, `copyleft`, `all-rights-reserved`, `restricted` + /// (non-commercial or no-derivatives), `custom` or `unknown`. + pub license_kind: String, + pub status: Status, + pub reason: String, +} + +/// The licence family of an SPDX id or a `mods.toml` licence text. +pub fn license_kind(license: &str) -> &'static str { + let l = license.to_ascii_lowercase(); + if l.is_empty() || l.starts_with("unknown") { + "unknown" + } else if l.contains("-nc") || l.contains("-nd") || l.contains("noncommercial") { + "restricted" + } else if l.contains("all-rights-reserved") || l.contains("all rights reserved") || l == "arr" { + "all-rights-reserved" + } else if ["gpl", "mpl", "eupl", "general public"] + .iter() + .any(|k| l.contains(k)) + { + "copyleft" + } else if [ + "mit", + "apache", + "bsd", + "cc0", + "cc-by", + "unlicense", + "isc", + "zlib", + ] + .iter() + .any(|k| l.contains(k)) + { + "permissive" + } else { + "custom" + } +} + +/// What still blocks a mod of this tier that has not been carried over. +fn not_yet(tier: &str) -> &'static str { + match tier { + "data" => "data tier: carry-over only, no agent; its jar is not in the work folder", + "logic" => { + "needs mod API 0.3: behaviour callbacks (use, place, break, ticks) and server events" + } + "machines" => "needs mod API 0.4: block entities, menus, capabilities and mod networking", + "deep" => { + "needs mod API 0.5: entities, custom renderers and models, dimensions, new vanilla hooks" + } + "client" => "needs the client interfaces (keys, target, inventory-read, ui, render)", + _ => "not classified", + } +} + +fn not_needed(class: &str) -> &'static str { + match class { + "library" => "library: its API maps to Horizon's mod API and SDK", + "performance" => "performance mod: Horizon's engine is the replacement", + "other" => "pack tooling or an engine feature, folded into the pipeline or the engine", + "client-ui" => "built into Horizon", + _ => "nothing to port", + } +} + +/// A carried-over mod: ported when its harness passes with nothing left +/// out and nothing the templates miss; else partial, with what is missing. +fn carried(work: &Path, key: &str) -> Option<(Status, String)> { + let dir = work.join("mods").join(key); + let carry: Value = + serde_json::from_slice(&std::fs::read(dir.join("carry-report.json")).ok()?).ok()?; + let count = |k: &str| carry[k].as_object().map_or(0, |o| o.len()); + let (blocks, items) = (count("blocks"), carry["items"].as_u64().unwrap_or(0)); + let (left_blocks, left_items) = (count("blocks_unknown"), count("items_unknown")); + // A class of its own is code the facts cannot show; anything else the + // template misses (shapes, sounds) the harness also reports. + let mut differences = 0; + let mut own_code = 0; + for list in carry["differences"] + .as_object() + .into_iter() + .flatten() + .map(|(_, v)| v) + { + let notes: Vec<&str> = list + .as_array() + .into_iter() + .flatten() + .filter_map(Value::as_str) + .collect(); + if notes.iter().any(|n| n.starts_with("class ")) { + own_code += 1; + } + if notes.iter().any(|n| !n.starts_with("class ")) { + differences += 1; + } + } + let mut gaps = Vec::new(); + if left_blocks > 0 { + gaps.push(format!( + "{left_blocks} blocks left out (no vanilla template)" + )); + } + if left_items > 0 { + gaps.push(format!("{left_items} items left out")); + } + if differences > 0 { + gaps.push(format!( + "{differences} blocks or items differ from their templates" + )); + } + let harness: Option = std::fs::read(dir.join("harness/result.json")) + .ok() + .and_then(|b| serde_json::from_slice(&b).ok()); + let mut checked = 0; + match &harness { + Some(h) => { + for (name, c) in h["checks"].as_object().into_iter().flatten() { + let (p, f) = ( + c["passed"].as_u64().unwrap_or(0), + c["failed"].as_u64().unwrap_or(0), + ); + checked += p + f; + if f > 0 { + gaps.push(format!("{name} {p}/{}", p + f)); + } + } + } + None => gaps.push("harness not run".into()), + } + let worldgen = carry["worldgen"].as_u64().unwrap_or(0); + if blocks == 0 && items == 0 && checked == 0 { + let what = if worldgen > 0 { + format!("{worldgen} worldgen files carried, not compared yet") + } else { + "nothing registered to compare".into() + }; + return Some((Status::Partial, what)); + } + let mut summary = format!("{blocks} blocks, {items} items"); + if own_code > 0 { + let _ = write!( + summary, + " ({own_code} with code of their own, not compared)" + ); + } + if gaps.is_empty() { + Some((Status::Ported, format!("{summary}; harness green"))) + } else { + Some((Status::Partial, format!("{summary}; {}", gaps.join("; ")))) + } +} + +pub fn build(records: &[Record], work: &Path) -> Vec { + let mut rows: Vec = records + .iter() + .map(|r| { + let (status, reason) = if r.class == "unknown" { + let why = + "unclassified: its jar (mods.toml, file census) or a reviewed row decides"; + (Status::NotYet, why.to_owned()) + } else if r.tier == "none" || matches!(r.class.as_str(), "library" | "performance") { + (Status::NotNeeded, not_needed(&r.class).to_owned()) + } else if let Some(c) = carried(work, &r.key) { + c + } else { + let mut why = not_yet(&r.tier).to_owned(); + if r.tier == "data" && r.jar.is_some() { + why = "data tier: carry-over not run yet".into(); + } + if r.class == "integration" { + why = format!("after the mods it joins are ported; {why}"); + } + (Status::NotYet, why) + }; + Row { + key: r.key.clone(), + name: r.name.clone(), + class: r.class.clone(), + tier: r.tier.clone(), + license: r.license.clone(), + license_kind: license_kind(&r.license).to_owned(), + status, + reason, + } + }) + .collect(); + // A mod waits on its dependencies that are not ported. + let status: BTreeMap = rows.iter().map(|r| (r.key.clone(), r.status)).collect(); + for (row, r) in rows.iter_mut().zip(records) { + if row.status == Status::NotNeeded { + continue; + } + let waiting: Vec<&str> = r + .depends + .iter() + .filter(|d| status.get(*d) == Some(&Status::NotYet)) + .map(String::as_str) + .collect(); + if !waiting.is_empty() { + let _ = write!(row.reason, "; waits on {}", waiting.join(", ")); + } + } + rows +} + +/// Rows counted by `field` and status. +fn table(rows: &[Row], title: &str, field: fn(&Row) -> &str) -> String { + let mut counts: BTreeMap<&str, [usize; 4]> = BTreeMap::new(); + for r in rows { + let i = Status::ALL.iter().position(|s| *s == r.status).unwrap_or(0); + counts.entry(field(r)).or_default()[i] += 1; + } + let mut out = format!( + "| {title} | ported | partial | not yet | not needed | all |\n|---|---:|---:|---:|---:|---:|\n" + ); + let mut totals = [0usize; 4]; + for (k, c) in &counts { + let all: usize = c.iter().sum(); + let _ = writeln!( + out, + "| {k} | {} | {} | {} | {} | {all} |", + c[0], c[1], c[2], c[3] + ); + for (t, n) in totals.iter_mut().zip(c) { + *t += n; + } + } + let all: usize = totals.iter().sum(); + let _ = writeln!( + out, + "| **all** | **{}** | **{}** | **{}** | **{}** | **{all}** |", + totals[0], totals[1], totals[2], totals[3] + ); + out +} + +pub fn markdown(pack: &str, rows: &[Row]) -> String { + let mut out = format!("# Coverage: {pack}\n\n"); + out += &table(rows, "class", |r| &r.class); + out += "\n"; + out += &table(rows, "tier", |r| &r.tier); + out += "\n"; + out += &table(rows, "licence", |r| &r.license_kind); + out += "\nPorts stay local. Only permissive or copyleft ports could ever be published, and only after Ludovic asks the authors.\n\n"; + out += "| mod | class | tier | licence | status | why |\n|---|---|---|---|---|---|\n"; + let mut sorted: Vec<&Row> = rows.iter().collect(); + sorted.sort_by(|a, b| (a.status, &a.key).cmp(&(b.status, &b.key))); + for r in sorted { + let _ = writeln!( + out, + "| {} | {} | {} | {} | {} | {} |", + r.key, + r.class, + r.tier, + r.license.replace('|', "/"), + r.status.label(), + r.reason.replace('|', "/") + ); + } + out +} + +pub fn counts(rows: &[Row]) -> Vec<(&'static str, usize)> { + Status::ALL + .iter() + .map(|s| (s.label(), rows.iter().filter(|r| r.status == *s).count())) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + fn record(key: &str, class: &str, tier: &str, depends: &[&str]) -> Record { + Record { + key: key.into(), + class: class.into(), + tier: tier.into(), + license: "MIT".into(), + depends: depends.iter().map(|d| (*d).to_owned()).collect(), + ..Record::default() + } + } + + #[test] + fn statuses_and_reasons() { + let work = std::env::temp_dir().join(format!("horizon-report-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&work); + let write = |key: &str, carry: Value, harness: Option| { + let dir = work.join("mods").join(key); + std::fs::create_dir_all(dir.join("harness")).unwrap(); + std::fs::write(dir.join("carry-report.json"), carry.to_string()).unwrap(); + if let Some(h) = harness { + std::fs::write(dir.join("harness/result.json"), h.to_string()).unwrap(); + } + }; + let green = serde_json::json!({"checks": {"blocks": {"passed": 3, "failed": 0}}}); + write( + "doors", + serde_json::json!({"blocks": {"a": "minecraft:oak_door"}, "items": 0, + "differences": {"a": ["class m.Door (behaviour beyond DoorBlock)"]}}), + Some(green), + ); + write( + "paths", + serde_json::json!({"blocks": {"a": "minecraft:stone"}, "items": 1, + "blocks_unknown": {"b": "no vanilla Block"}}), + Some(serde_json::json!({"checks": {"shapes": {"passed": 1, "failed": 2}}})), + ); + let records = [ + record("doors", "content", "data", &[]), + record("paths", "content", "data", &[]), + record("lib", "library", "none", &[]), + record("machine", "content", "machines", &["lib"]), + record("addon", "integration", "logic", &["machine"]), + record("mystery", "unknown", "none", &[]), + ]; + let rows = build(&records, &work); + let by: BTreeMap<&str, &Row> = rows.iter().map(|r| (r.key.as_str(), r)).collect(); + assert_eq!(by["doors"].status, Status::Ported); + assert!( + by["doors"].reason.contains("1 with code of their own"), + "{}", + by["doors"].reason + ); + assert_eq!(by["paths"].status, Status::Partial); + assert!( + by["paths"].reason.contains("1 blocks left out"), + "{}", + by["paths"].reason + ); + assert!( + by["paths"].reason.contains("shapes 1/3"), + "{}", + by["paths"].reason + ); + assert_eq!(by["lib"].status, Status::NotNeeded); + assert_eq!(by["machine"].status, Status::NotYet); + assert!(by["machine"].reason.contains("0.4")); + assert!(by["addon"].reason.starts_with("after the mods it joins")); + assert!( + by["addon"].reason.ends_with("waits on machine"), + "{}", + by["addon"].reason + ); + assert_eq!(by["mystery"].status, Status::NotYet); + assert_eq!( + counts(&rows), + [ + ("ported", 1), + ("partial", 1), + ("not yet", 3), + ("not needed", 1) + ] + ); + let md = markdown("test", &rows); + assert!( + md.contains("| **all** | **1** | **1** | **3** | **1** | **6** |"), + "{md}" + ); + std::fs::remove_dir_all(&work).unwrap(); + } + + #[test] + fn licence_families() { + assert_eq!(license_kind("MIT"), "permissive"); + assert_eq!(license_kind("CC0-1.0"), "permissive"); + assert_eq!(license_kind("LGPL-3.0-only"), "copyleft"); + assert_eq!( + license_kind("GNU Lesser General Public License v3.0"), + "copyleft" + ); + assert_eq!( + license_kind("LicenseRef-All-Rights-Reserved"), + "all-rights-reserved" + ); + assert_eq!(license_kind("CC-BY-NC-SA-4.0"), "restricted"); + assert_eq!(license_kind("LicenseRef-Stardust-Labs-License"), "custom"); + assert_eq!( + license_kind("unknown (read mods.toml at import)"), + "unknown" + ); + } +} diff --git a/docs/modpacks.md b/docs/modpacks.md index 9cdd14774..d3cb7c401 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -262,13 +262,14 @@ inspected: └── coverage.json, coverage.md ``` -**Status.** `import`, `inventory` and `carry` run today: +**Status.** `import`, `inventory`, `carry` and `report` run today: ``` cargo run -p horizon-port-pack -- import ~/Downloads/pack.mrpack ~/.horizon/ports/pack cargo run -p horizon-port-pack -- inventory ~/.horizon/ports/pack # --offline reuses modrinth.json cargo run -p horizon-port-pack -- carry ~/.horizon/ports/pack # content mods with a jar, or name them # --resources : only templates Horizon's tables have +cargo run -p horizon-port-pack -- report ~/.horizon/ports/pack # coverage.json and coverage.md ``` `inventory` reads metadata only: Modrinth answers by file hash, and the jars only if the user's @@ -307,6 +308,7 @@ block's name breaking ties (`_pane`, `_gate`, `_trapdoor`). | CurseForge zip | `manifest.json`: `minecraft.version`, `modLoaders[]`, `files[]` (`projectID`, `fileID`, `required`), `overrides` | the user's installed instance (CurseForge app `minecraftinstance.json` + `mods/`). CurseForge's API needs a key, so we take what the user already downloaded | | Prism / MultiMC instance | `mmc-pack.json` components (`net.minecraft`, `net.neoforged`, `net.fabricmc.fabric-loader`), `instance.cfg`, `.minecraft/mods/*.jar`, packwiz `.pw.toml` files if present | the instance folder | | packwiz | `pack.toml`, `index.toml`, `mods/*.pw.toml` | as listed | +| Crash Assistant `modlist.json` | jar name → mod id, name, version, Modrinth SHA-1; the loader entry (NeoForge `21.1.x` is Minecraft 1.21.1). Packs such as ATM10 publish it in their repository | metadata only; jars put in `/jars/` | `pack.json` holds the Minecraft version, the loader and its version, each file with its hashes and side, and the overrides (configs, KubeJS scripts, datapacks). @@ -458,8 +460,36 @@ and tag of the declared blocks matches. Plus the licence summary (how many ports could be published) and, for a pack, "playable?": whether every required content mod is ported or partial with its blocks and items present. -For ATM10 today: 125 of 495 are not needed. The other 370 are not yet ported; 68 of them are -data tier, so they need registries and carry-over but no agent. + +`horizon-port-pack report ` writes the per-mod rows and the class, tier and licence totals from the inventory, each mod's `carry-report.json` +and its harness result. A data-tier mod is **ported** when its harness is green and nothing was +left out (blocks with a class of their own are counted and named, since facts cannot show +their extra code); **partial** with the failing checks, the blocks left out and what the +templates miss; **not yet** with the API tier it waits for, or the dependency; **not needed** +for libraries, performance mods, pack tooling and what Horizon has built in. Unclassified mods +(the 20 CurseForge-only rows the reviewed table only guesses) count as not yet. + +**ATM10, measured** (`import` of ATM10's `modlist.json` from its repository on 2026-10-16, 496 +files; `inventory`; `carry` and the harness on the eight mods we downloaded; `report`): + +| class | ported | partial | not yet | not needed | all | +|---|---:|---:|---:|---:|---:| +| content | 1 | 7 | 268 | 0 | 276 | +| library | 0 | 0 | 0 | 77 | 77 | +| integration | 0 | 0 | 40 | 3 | 43 | +| client-ui | 0 | 0 | 27 | 2 | 29 | +| other | 0 | 0 | 1 | 23 | 24 | +| unknown | 0 | 0 | 20 | 0 | 20 | +| performance | 0 | 0 | 0 | 16 | 16 | +| server-only | 0 | 0 | 11 | 0 | 11 | +| **all** | **1** | **7** | **367** | **121** | **496** | + +By tier, the 367 not yet: data 57 (carry-over and the harness, no agent: their jars were not +downloaded), logic 66 (API 0.3), machines 97 (0.4), deep 92 (0.5), client 35, unclassified 20. +Ported: Macaw's Trapdoors. Partial: Macaw's Doors, Fences and Walls, Paths and Pavings, +Glassential, Factory Blocks, Cloud Glass (see the harness table) and MVS, whose 784 worldgen +files are carried but not yet read by the game. Of the 8, 7 are MIT and one LGPL; nothing is +published. ## Measuring "10x" 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 10/28] 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 11/28] 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 12/28] 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 13/28] 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 7384db307d5f9be26ddd5f5a1f31cf2260c542cb Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 01:10:35 +0200 Subject: [PATCH 14/28] Block textures: share identical sprites, and draw past 2048 layers Every block sprite is a layer of one texture array, and GPUs give an array at most 2048 layers (Metal, most Vulkan drivers). Vanilla takes 1250; eight real NeoForge mods carried over (docs/modpacks.md) take 2183, and the game stopped at start with "GPU supports 2048 texture layers; 2200 required". - Sprites: a still texture with the same pixels and mip settings as one already loaded reuses its layer (mods copy vanilla's textures under their own names): 17 layers fewer for those mods, none for vanilla. - The renderer splits the layers over up to four arrays of 2048 (8192 sprites). terrain.wgsl picks the array per fragment with derivatives taken in uniform control flow; a pipeline constant keeps vanilla, which needs one array, on the same single textureSample as before. - HORIZON_SPRITE_SPLIT (dev only) forces a smaller split: vanilla drawn from three arrays of 512 renders the same blocks as from one. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/assets.rs | 2 +- crates/horizon-client/src/gfx.rs | 311 ++++++++++++++++--------- crates/horizon-client/src/sprites.rs | 136 ++++++++--- crates/horizon-client/src/terrain.wgsl | 27 ++- 4 files changed, 328 insertions(+), 148 deletions(-) diff --git a/crates/horizon-client/src/assets.rs b/crates/horizon-client/src/assets.rs index 351d57d45..b8551a059 100644 --- a/crates/horizon-client/src/assets.rs +++ b/crates/horizon-client/src/assets.rs @@ -245,7 +245,7 @@ impl Assets { material_states, sprite_size: sprites.size, sprite_minimum_size: sprites.minimum_size, - texture_layers: u32::try_from(sprites.layers.len())?, + texture_layers: u32::try_from(sprites.count())?, pixels: sprites.pixels, model_catalog: models.catalog, model_library, diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 4401ea22d..e69106e6b 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -290,7 +290,13 @@ pub struct Renderer { group: wgpu::BindGroup, globals: wgpu::Buffer, lightmap: wgpu::Texture, - sprite_texture: wgpu::Texture, + /// The block sprites, [`SPRITE_SPLIT`] layers per array (the first is + /// `sprites` in terrain.wgsl, the others `sprites_1`...). + sprite_textures: Vec, + /// A 1-layer array bound where a pack needs fewer arrays. + sprite_unused: wgpu::TextureView, + /// Layers per sprite array ([`SPRITE_SPLIT`] but in tests). + sprite_split: u32, mip_levels: u32, /// The mipmap levels sampled (the Mipmap Levels option), at most `mip_levels - 1`. mipmaps: u32, @@ -354,6 +360,79 @@ pub struct Renderer { } /// Every layer's mip levels, layer major (`first` is the first layer's /// index into `settings`), made by `MipmapGenerator`. +/// Block sprite layers per texture array: the smallest +/// `max_texture_array_layers` of the GPUs Horizon runs on. Mods add sprites +/// past it into more arrays (terrain.wgsl's `sprite`). +pub(crate) const SPRITE_SPLIT: u32 = 2048; +/// [`SPRITE_SPLIT`], or a smaller split from `HORIZON_SPRITE_SPLIT` (dev +/// only: vanilla's sprites drawn from several arrays must look the same). +fn sprite_split() -> u32 { + std::env::var("HORIZON_SPRITE_SPLIT") + .ok() + .and_then(|v| v.parse().ok()) + .filter(|&n| (1..=SPRITE_SPLIT).contains(&n)) + .unwrap_or(SPRITE_SPLIT) +} +/// Sprite arrays terrain.wgsl binds (`sprites`, `sprites_1`...). +const SPRITE_ARRAYS: u32 = 4; +/// The views of terrain.wgsl's sprite arrays, the unused ones a 1-layer +/// stand-in. +fn sprite_views( + textures: &[wgpu::Texture], + unused: &wgpu::TextureView, + mips: Option, +) -> Vec { + (0..SPRITE_ARRAYS as usize) + .map(|i| match textures.get(i) { + Some(t) => t.create_view(&wgpu::TextureViewDescriptor { + dimension: Some(wgpu::TextureViewDimension::D2Array), + mip_level_count: mips, + ..Default::default() + }), + None => unused.clone(), + }) + .collect() +} +/// terrain.wgsl's group 0. +#[allow(clippy::too_many_arguments)] +fn terrain_group( + device: &wgpu::Device, + label: &str, + layout: &wgpu::BindGroupLayout, + globals: &wgpu::Buffer, + sprites: &[wgpu::TextureView], + sprite_sampler: &wgpu::Sampler, + lightmap: &wgpu::TextureView, + lightmap_sampler: &wgpu::Sampler, +) -> wgpu::BindGroup { + let view = |binding, view| wgpu::BindGroupEntry { + binding, + resource: wgpu::BindingResource::TextureView(view), + }; + device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some(label), + layout, + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: globals.as_entire_binding(), + }, + view(1, &sprites[0]), + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::Sampler(sprite_sampler), + }, + view(3, lightmap), + wgpu::BindGroupEntry { + binding: 4, + resource: wgpu::BindingResource::Sampler(lightmap_sampler), + }, + view(5, &sprites[1]), + view(6, &sprites[2]), + view(7, &sprites[3]), + ], + }) +} fn mip_chain( pixels: &[u8], size: u32, @@ -494,10 +573,19 @@ impl Renderer { ), ); let limits = adapter.limits(); - if limits.max_texture_array_layers < layers { + let split = sprite_split(); + if layers > split * SPRITE_ARRAYS { return Err(format!( - "GPU supports {} texture layers; {layers} required", - limits.max_texture_array_layers + "{layers} block textures; Horizon draws at most {}", + split * SPRITE_ARRAYS + ) + .into()); + } + if limits.max_texture_array_layers < layers.min(split) { + return Err(format!( + "GPU supports {} texture layers; {} required", + limits.max_texture_array_layers, + layers.min(split) ) .into()); } @@ -565,6 +653,19 @@ impl Renderer { count: None, }; let vf = wgpu::ShaderStages::VERTEX_FRAGMENT; + let sprite_array = wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: true }, + view_dimension: wgpu::TextureViewDimension::D2Array, + multisampled: false, + }; + let sprite_arrays = layers.div_ceil(split).max(1); + if sprite_arrays > 1 { + log::info!("Horizon: {layers} block textures in {sprite_arrays} arrays"); + } + let sprite_constants = [ + ("SPRITE_ARRAYS", f64::from(sprite_arrays)), + ("SPRITE_SPLIT", f64::from(split)), + ]; let bindings = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("Horizon terrain bindings"), entries: &[ @@ -605,6 +706,9 @@ impl Renderer { vf, wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), ), + entry(5, vf, sprite_array), + entry(6, vf, sprite_array), + entry(7, vf, sprite_array), ], }); let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { @@ -677,7 +781,10 @@ impl Renderer { fragment: Some(wgpu::FragmentState { module: &shader, entry_point: Some(fragment), - compilation_options: Default::default(), + compilation_options: wgpu::PipelineCompilationOptions { + constants: &sprite_constants, + ..Default::default() + }, targets: &[Some(wgpu::ColorTargetState { format: config.format.remove_srgb_suffix(), blend, @@ -784,30 +891,62 @@ impl Renderer { usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); - let (mips, mip_levels) = mip_chain(sprite_pixels, sprite_size, sprite_mips, 0, layers); - let sprite_texture = device.create_texture_with_data( - &queue, - &wgpu::TextureDescriptor { - label: Some("Block sprites"), + let layer_bytes = (sprite_size * sprite_size * 4) as usize; + let mut mip_levels = 1; + let sprite_textures: Vec = (0..sprite_arrays) + .map(|array| { + let first = array * split; + let count = layers.saturating_sub(first).clamp(1, split); + let start = (first as usize * layer_bytes).min(sprite_pixels.len()); + let (mips, levels) = mip_chain( + &sprite_pixels[start..], + sprite_size, + sprite_mips, + first, + count, + ); + mip_levels = levels; + device.create_texture_with_data( + &queue, + &wgpu::TextureDescriptor { + label: Some("Block sprites"), + size: wgpu::Extent3d { + width: sprite_size, + height: sprite_size, + depth_or_array_layers: count, + }, + mip_level_count: levels, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + view_formats: &[], + }, + wgpu::util::TextureDataOrder::LayerMajor, + &mips, + ) + }) + .collect(); + let sprite_unused = device + .create_texture(&wgpu::TextureDescriptor { + label: Some("Block sprites (unused)"), size: wgpu::Extent3d { - width: sprite_size, - height: sprite_size, - depth_or_array_layers: layers, + width: 1, + height: 1, + depth_or_array_layers: 1, }, - mip_level_count: mip_levels, + mip_level_count: 1, sample_count: 1, dimension: wgpu::TextureDimension::D2, format: wgpu::TextureFormat::Rgba8Unorm, - usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + usage: wgpu::TextureUsages::TEXTURE_BINDING, view_formats: &[], - }, - wgpu::util::TextureDataOrder::LayerMajor, - &mips, - ); - let sprite_view = sprite_texture.create_view(&wgpu::TextureViewDescriptor { - dimension: Some(wgpu::TextureViewDimension::D2Array), - ..Default::default() - }); + }) + .create_view(&wgpu::TextureViewDescriptor { + dimension: Some(wgpu::TextureViewDimension::D2Array), + ..Default::default() + }); + let sprite_views = sprite_views(&sprite_textures, &sprite_unused, None); let sprite_sampler = device.create_sampler(&wgpu::SamplerDescriptor { label: Some("Block sprites"), address_mode_u: wgpu::AddressMode::Repeat, @@ -838,58 +977,26 @@ impl Renderer { min_filter: wgpu::FilterMode::Linear, ..Default::default() }); - let group = device.create_bind_group(&wgpu::BindGroupDescriptor { - label: Some("Horizon terrain resources"), - layout: &bindings, - entries: &[ - wgpu::BindGroupEntry { - binding: 0, - resource: globals.as_entire_binding(), - }, - wgpu::BindGroupEntry { - binding: 1, - resource: wgpu::BindingResource::TextureView(&sprite_view), - }, - wgpu::BindGroupEntry { - binding: 2, - resource: wgpu::BindingResource::Sampler(&sprite_sampler), - }, - wgpu::BindGroupEntry { - binding: 3, - resource: wgpu::BindingResource::TextureView(&lightmap_view), - }, - wgpu::BindGroupEntry { - binding: 4, - resource: wgpu::BindingResource::Sampler(&lightmap_sampler), - }, - ], - }); - let crosshair_group = device.create_bind_group(&wgpu::BindGroupDescriptor { - label: Some("Debug crosshair resources"), - layout: &bindings, - entries: &[ - wgpu::BindGroupEntry { - binding: 0, - resource: crosshair_globals.as_entire_binding(), - }, - wgpu::BindGroupEntry { - binding: 1, - resource: wgpu::BindingResource::TextureView(&sprite_view), - }, - wgpu::BindGroupEntry { - binding: 2, - resource: wgpu::BindingResource::Sampler(&sprite_sampler), - }, - wgpu::BindGroupEntry { - binding: 3, - resource: wgpu::BindingResource::TextureView(&lightmap_view), - }, - wgpu::BindGroupEntry { - binding: 4, - resource: wgpu::BindingResource::Sampler(&lightmap_sampler), - }, - ], - }); + let group = terrain_group( + &device, + "Horizon terrain resources", + &bindings, + &globals, + &sprite_views, + &sprite_sampler, + &lightmap_view, + &lightmap_sampler, + ); + let crosshair_group = terrain_group( + &device, + "Debug crosshair resources", + &bindings, + &crosshair_globals, + &sprite_views, + &sprite_sampler, + &lightmap_view, + &lightmap_sampler, + ); let index_quads = 1 << 16; let indices = Self::quad_indices(&device, index_quads); let instance_capacity = 4096; @@ -1575,7 +1682,9 @@ impl Renderer { group, globals, lightmap, - sprite_texture, + sprite_textures, + sprite_unused, + sprite_split: split, mip_levels, mipmaps: mip_levels - 1, terrain_layout: bindings, @@ -1864,7 +1973,7 @@ impl Renderer { pub fn set_mipmap_levels(&mut self, levels: u32) { let levels = sprite_mipmap_limit( levels, - self.sprite_texture.width(), + self.sprite_textures[0].width(), self.sprite_minimum_size, self.mip_levels, ); @@ -1872,39 +1981,17 @@ impl Renderer { return; } self.mipmaps = levels; - let sprite_view = self - .sprite_texture - .create_view(&wgpu::TextureViewDescriptor { - dimension: Some(wgpu::TextureViewDimension::D2Array), - mip_level_count: Some(levels + 1), - ..Default::default() - }); - self.group = self.device.create_bind_group(&wgpu::BindGroupDescriptor { - label: Some("Horizon terrain resources"), - layout: &self.terrain_layout, - entries: &[ - wgpu::BindGroupEntry { - binding: 0, - resource: self.globals.as_entire_binding(), - }, - wgpu::BindGroupEntry { - binding: 1, - resource: wgpu::BindingResource::TextureView(&sprite_view), - }, - wgpu::BindGroupEntry { - binding: 2, - resource: wgpu::BindingResource::Sampler(&self.sprite_sampler), - }, - wgpu::BindGroupEntry { - binding: 3, - resource: wgpu::BindingResource::TextureView(&self.lightmap_view), - }, - wgpu::BindGroupEntry { - binding: 4, - resource: wgpu::BindingResource::Sampler(&self.lightmap_sampler), - }, - ], - }); + let views = sprite_views(&self.sprite_textures, &self.sprite_unused, Some(levels + 1)); + self.group = terrain_group( + &self.device, + "Horizon terrain resources", + &self.terrain_layout, + &self.globals, + &views, + &self.sprite_sampler, + &self.lightmap_view, + &self.lightmap_sampler, + ); } pub fn view_projection(&self, frame: &Frame) -> Mat4 { self.projection( @@ -2001,12 +2088,12 @@ impl Renderer { self.uploads.texture( encoder, wgpu::TexelCopyTextureInfo { - texture: &self.sprite_texture, + texture: &self.sprite_textures[(layer / self.sprite_split) as usize], mip_level: level, origin: wgpu::Origin3d { x: 0, y: 0, - z: layer, + z: layer % self.sprite_split, }, aspect: wgpu::TextureAspect::All, }, diff --git a/crates/horizon-client/src/sprites.rs b/crates/horizon-client/src/sprites.rs index d050e5fda..c26e02ea7 100644 --- a/crates/horizon-client/src/sprites.rs +++ b/crates/horizon-client/src/sprites.rs @@ -82,6 +82,10 @@ pub struct Sprites { /// Each layer's frames at the texture's own resolution (square), and the /// frame shown first. native: Vec<(u32, Arc>>, usize)>, + /// Still textures by their pixels and mip settings: mods copy vanilla's + /// textures under their own names, and one layer serves them all (the + /// GPU's array may hold as few as 2048). + still: std::collections::HashMap<(Vec, u32, [u32; 2], [bool; 4]), u32>, } /// Edge length of vanilla's block textures: the smallest array layer. pub const SPRITE_SIZE: u32 = 16; @@ -104,6 +108,10 @@ fn resample(frame: &[u8], from: u32, to: u32) -> Vec { out } impl Sprites { + /// How many array layers the textures take. + pub fn count(&self) -> usize { + self.native.len() + } /// Lay every layer out at one size: the largest texture's (resource packs /// may ship 32x, 64x... textures, like vanilla's stitched atlas), rounded /// up to a power of two and limited to [`MAX_ARRAY_BYTES`]. Smaller @@ -152,7 +160,7 @@ impl Sprites { } }) .collect(); - let layer = u32::try_from(self.layers.len())?; + let layer = u32::try_from(self.native.len())?; self.opaque.push(true); self.translucent.push(false); self.mips.push(crate::mipmap::Settings::default()); @@ -209,7 +217,7 @@ impl Sprites { }; pixels.extend(rgba); } - let layer = u32::try_from(self.layers.len())?; + let layer = u32::try_from(self.native.len())?; let columns = info.width / width; let count = columns * (info.height / height); // Layers are square; a frame of another shape is nearest-resampled to @@ -230,6 +238,46 @@ impl Sprites { } frames.push(frame); } + let settings = crate::mipmap::Settings { + native_size: side, + strategy: texture_section(metadata.as_ref()) + .as_ref() + .and_then(|t| t["mipmap_strategy"].as_str()) + .and_then(crate::mipmap::Strategy::parse) + .unwrap_or_default(), + alpha_cutoff_bias: texture_section(metadata.as_ref()) + .as_ref() + .and_then(|t| t["alpha_cutoff_bias"].as_f64()) + .unwrap_or(0.0) as f32, + has_transparent: pixels.as_chunks::<4>().0.iter().any(|p| p[3] == 0), + item: name + .split_once(':') + .is_some_and(|(_, p)| p.starts_with("item/")), + }; + let opaque = pixels.as_chunks::<4>().0.iter().all(|p| p[3] == 255); + let translucent = pixels + .as_chunks::<4>() + .0 + .iter() + .any(|p| p[3] != 0 && p[3] != 255); + let still = (animation.is_none() && frames.len() == 1).then(|| { + ( + frames[0].clone(), + side, + [ + settings.strategy as u32, + settings.alpha_cutoff_bias.to_bits(), + ], + [settings.has_transparent, settings.item, opaque, translucent], + ) + }); + if let Some(&same) = still.as_ref().and_then(|k| self.still.get(k)) { + self.layers.insert(name.to_owned(), same); + return Ok(same); + } + if let Some(key) = still { + self.still.insert(key, layer); + } let frames = Arc::new(frames); let mut initial = 0; if let Some(clip) = animation @@ -245,43 +293,25 @@ impl Sprites { clip: Arc::new(clip), }); } - // SpriteContents: TextureMetadataSection's mipmap strategy and alpha - // cutoff bias, and the whole image's NativeImage.computeTransparency. - let texture = metadata - .as_ref() - .and_then(|v| v.get("texture")) - .and_then(|v| serde_json::from_str::(v.get()).ok()); - self.mips.push(crate::mipmap::Settings { - native_size: side, - strategy: texture - .as_ref() - .and_then(|t| t["mipmap_strategy"].as_str()) - .and_then(crate::mipmap::Strategy::parse) - .unwrap_or_default(), - alpha_cutoff_bias: texture - .as_ref() - .and_then(|t| t["alpha_cutoff_bias"].as_f64()) - .unwrap_or(0.0) as f32, - has_transparent: pixels.as_chunks::<4>().0.iter().any(|p| p[3] == 0), - item: name - .split_once(':') - .is_some_and(|(_, p)| p.starts_with("item/")), - }); - self.opaque - .push(pixels.as_chunks::<4>().0.iter().all(|p| p[3] == 255)); - self.translucent.push( - pixels - .as_chunks::<4>() - .0 - .iter() - .any(|p| p[3] != 0 && p[3] != 255), - ); + self.mips.push(settings); + self.opaque.push(opaque); + self.translucent.push(translucent); self.layers.insert(name.to_owned(), layer); self.native.push((side, frames, initial)); Ok(layer) } } +/// SpriteContents: the `.mcmeta` `texture` section (TextureMetadataSection's +/// mipmap strategy and alpha cutoff bias). +fn texture_section( + metadata: Option<&BTreeMap>>, +) -> Option { + metadata + .and_then(|v| v.get("texture")) + .and_then(|v| serde_json::from_str(v.get()).ok()) +} + #[cfg(test)] pub(crate) fn test_animation(size: u32, layer: u32) -> SpriteAnimation { test_clip(size, layer, r#"{"frametime":1,"frames":[0,1]}"#) @@ -305,6 +335,46 @@ pub(crate) fn test_clip(size: u32, layer: u32, metadata: &str) -> SpriteAnimatio mod tests { use super::*; #[test] + fn identical_still_textures_share_a_layer() { + let root = + std::env::temp_dir().join(format!("horizon-sprite-share-{}", std::process::id())); + let directory = root.join("assets/a/textures/block"); + fs::create_dir_all(&directory).unwrap(); + let write = |name: &str, red: u8| { + let mut encoder = + png::Encoder::new(File::create(directory.join(name)).unwrap(), 16, 16); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + let pixels: Vec = (0..256).flat_map(|i| [red, i as u8, 0, 255]).collect(); + encoder + .write_header() + .unwrap() + .write_image_data(&pixels) + .unwrap(); + }; + write("one.png", 10); + write("copy.png", 10); + write("other.png", 20); + let mut sprites = Sprites::default(); + let one = sprites.insert(&root, "a:block/one").unwrap(); + let copy = sprites.insert(&root, "a:block/copy").unwrap(); + let other = sprites.insert(&root, "a:block/other").unwrap(); + // The same pixels as an item sprite mip differently: a layer of its own. + fs::create_dir_all(root.join("assets/a/textures/item")).unwrap(); + fs::copy( + directory.join("one.png"), + root.join("assets/a/textures/item/one.png"), + ) + .unwrap(); + let item = sprites.insert(&root, "a:item/one").unwrap(); + fs::remove_dir_all(&root).unwrap(); + assert_eq!((one, copy, other, item), (0, 0, 1, 2)); + assert_eq!((sprites.count(), sprites.layers.len()), (3, 4)); + assert_eq!((sprites.opaque.len(), sprites.mips.len()), (3, 3)); + sprites.finish(); + assert_eq!(sprites.pixels.len(), 3 * 16 * 16 * 4); + } + #[test] fn a_32px_only_atlas_does_not_add_an_extra_mipmap() { let mut sprites = Sprites { native: vec![ diff --git a/crates/horizon-client/src/terrain.wgsl b/crates/horizon-client/src/terrain.wgsl index 26e32cb89..4689e7d2b 100644 --- a/crates/horizon-client/src/terrain.wgsl +++ b/crates/horizon-client/src/terrain.wgsl @@ -27,6 +27,29 @@ struct Globals { @group(0) @binding(2) var sprite_sampler: sampler; @group(0) @binding(3) var lightmap: texture_2d; @group(0) @binding(4) var lightmap_sampler: sampler; +// Layers past the first array's SPRITE_SPLIT (2048, gfx.rs): mods' sprites. +@group(0) @binding(5) var sprites_1: texture_2d_array; +@group(0) @binding(6) var sprites_2: texture_2d_array; +@group(0) @binding(7) var sprites_3: texture_2d_array; +// How many sprite arrays hold layers (a pipeline constant): 1 for vanilla, +// which then samples exactly as before. +override SPRITE_ARRAYS: u32 = 1u; +override SPRITE_SPLIT: u32 = 2048u; +fn sprite(uv: vec2, layer: u32) -> vec4 { + if SPRITE_ARRAYS == 1u { + return textureSample(sprites, sprite_sampler, uv, i32(layer)); + } + // The array is chosen per fragment: sample with the derivatives taken here. + let dx = dpdx(uv); + let dy = dpdy(uv); + let l = i32(layer % SPRITE_SPLIT); + switch layer / SPRITE_SPLIT { + case 0u: { return textureSampleGrad(sprites, sprite_sampler, uv, l, dx, dy); } + case 1u: { return textureSampleGrad(sprites_1, sprite_sampler, uv, l, dx, dy); } + case 2u: { return textureSampleGrad(sprites_2, sprite_sampler, uv, l, dx, dy); } + default: { return textureSampleGrad(sprites_3, sprite_sampler, uv, l, dx, dy); } + } +} struct TerrainOut { @builtin(position) clip: vec4, @@ -67,12 +90,12 @@ fn apply_fog(color: vec4, spherical: f32, cylindrical: f32) -> vec4 { } @fragment fn fs_solid(in: TerrainOut) -> @location(0) vec4 { // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout. - let color = textureSample(sprites, sprite_sampler, in.uv, i32(in.layer & 0x7fffu)) * in.color; + let color = sprite(in.uv, in.layer & 0x7fffu) * in.color; if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; } return apply_fog(vec4(color.rgb, 1.0), in.spherical, in.cylindrical); } @fragment fn fs_translucent(in: TerrainOut) -> @location(0) vec4 { - let color = textureSample(sprites, sprite_sampler, in.uv, i32(in.layer & 0x7fffu)) * in.color; + let color = sprite(in.uv, in.layer & 0x7fffu) * in.color; if color.a < 0.01 { discard; } return apply_fog(color, in.spherical, in.cylindrical); } 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 15/28] 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 16/28] 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 17/28] 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 a024409a1a66e99ee335622d0943b9e78aae9e7d Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 19:41:02 -0400 Subject: [PATCH 18/28] Show live connection packet rates and server brands in F3 --- crates/horizon-client/src/debug_chart.rs | 39 +++++++++++++++++ crates/horizon-client/src/game/debug_keys.rs | 45 +++++++++++++------- crates/horizon-client/src/game/integrated.rs | 12 +++++- crates/horizon-client/src/game/remote.rs | 7 +++ crates/horizon-client/src/net.rs | 44 ++++++++++++++++++- crates/horizon-protocol/src/connection.rs | 2 + 6 files changed, 131 insertions(+), 18 deletions(-) diff --git a/crates/horizon-client/src/debug_chart.rs b/crates/horizon-client/src/debug_chart.rs index d006a8ab6..35fd40bd4 100644 --- a/crates/horizon-client/src/debug_chart.rs +++ b/crates/horizon-client/src/debug_chart.rs @@ -74,6 +74,10 @@ pub struct DebugCharts { pub bandwidth: SampleLogger, /// `MinecraftServer.smoothedTickTimeMillis`. pub smoothed_tick_ms: f32, + /// Connection's smoothed packets per second, sent then received. + pub packet_rates: [f32; 2], + packet_totals: [i64; 2], + packet_tick: u8, previous_tick: Option, bytes_seen: Option, } @@ -113,6 +117,9 @@ impl DebugCharts { self.previous_tick = None; self.bytes_seen = None; self.smoothed_tick_ms = 0.0; + self.packet_rates = [0.0; 2]; + self.packet_totals = [0; 2]; + self.packet_tick = 0; } /// One integrated server tick that started at `started` and ran its /// tick method for `method` (`MinecraftServer.logFullTickTime` and @@ -136,6 +143,17 @@ impl DebugCharts { } self.bytes_seen = Some(total); } + /// `Connection.tickSecond`: sampled on the first tick, then every 20 ticks. + pub fn log_packets(&mut self, totals: [i64; 2]) { + if self.packet_tick == 0 { + for (i, total) in totals.into_iter().enumerate() { + let count = (total - self.packet_totals[i]).max(0) as f32; + self.packet_rates[i] = count + 0.75 * (self.packet_rates[i] - count); + } + self.packet_totals = totals; + } + self.packet_tick = (self.packet_tick + 1) % 20; + } /// The charts along the bottom of the screen (`extractRenderState`): /// frame times left and tick times right, or bandwidth left (remote /// servers only) and ping right. `mspt` is the level's milliseconds @@ -524,6 +542,27 @@ mod tests { assert!(draws.contains(&fill(361, 174, 365, 178, 0xFF0A_141E))); } + #[test] + fn packet_rates_follow_connection_smoothing_and_reset_between_worlds() { + let mut charts = DebugCharts::default(); + charts.log_packets([80, 400]); + assert_eq!(charts.packet_rates, [20.0, 100.0]); + for _ in 1..20 { + charts.log_packets([180, 800]); + } + assert_eq!(charts.packet_rates, [20.0, 100.0]); + charts.log_packets([180, 800]); + assert_eq!(charts.packet_rates, [40.0, 175.0]); + for _ in 0..20 { + charts.log_packets([180, 800]); + } + assert_eq!(charts.packet_rates, [30.0, 131.25]); + charts.reset(); + assert_eq!(charts.packet_rates, [0.0, 0.0]); + charts.log_packets([4, 8]); + assert_eq!(charts.packet_rates, [1.0, 2.0]); + } + #[test] fn ticks_and_bandwidth_log_their_differences() { let mut c = DebugCharts::default(); diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index 3aac02ae7..6eba74062 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -194,15 +194,17 @@ impl Game<'_> { } return; }; - let received = r - .session - .counters - .lock() - .unwrap() - .as_ref() - .map(|c| c.bytes_in.load(std::sync::atomic::Ordering::Relaxed)); - if let Some(total) = received { - self.debug_charts.log_bandwidth(total); + let received = r.session.counters.lock().unwrap().as_ref().map(|c| { + let order = std::sync::atomic::Ordering::Relaxed; + [ + c.bytes_in.load(order), + c.sent.load(order), + c.received.load(order), + ] + }); + if let Some([bytes, sent, received]) = received { + self.debug_charts.log_bandwidth(bytes); + self.debug_charts.log_packets([sent, received]); } if shown { use horizon_protocol::packets::{play::Serverbound, status::Ping}; @@ -403,8 +405,9 @@ impl Game<'_> { ], ); } - // tps: DebugEntryTps for the integrated server (it counts no packets). - if self.player.is_some() && self.remote.is_none() { + // tps: DebugEntryTps for local and remote connections. + if self.player.is_some() { + let [tx, rx] = self.debug_charts.packet_rates.map(|n| n.round() as i64); let (target, status) = if self.clock.sprinting() { ("-".to_owned(), " (sprinting)") } else if self.clock.stepping() { @@ -417,10 +420,22 @@ impl Game<'_> { } else { (format!("{:.1}", 1000.0 / self.clock.rate()), "") }; - d.line(format!( - "Integrated server @ {:.1}/{target} ms{status}, 0 tx, 0 rx", - self.debug_charts.smoothed_tick_ms - )); + if self.remote.is_none() || self.integrated.is_some() { + let tick_ms = self + .integrated + .as_ref() + .map_or(self.debug_charts.smoothed_tick_ms, |server| { + server.smoothed_tick_ms() + }); + d.line(format!( + "Integrated server @ {tick_ms:.1}/{target} ms{status}, {tx} tx, {rx} rx", + )); + } else if let Some(remote) = &self.remote { + d.line(format!( + "\"{}\" server{status}, {tx} tx, {rx} rx", + remote.brand + )); + } } let (left, right) = d.columns(&self.debug_chart_lines()); let atlas = &self.atlas; diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index 6edbb6e40..9c3b34e02 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -26,7 +26,7 @@ use std::{ path::Path, sync::{ Arc, - atomic::{AtomicBool, Ordering}, + atomic::{AtomicBool, AtomicU32, Ordering}, mpsc::{Sender, channel}, }, thread::JoinHandle, @@ -39,6 +39,7 @@ struct Flags { /// `Minecraft.pause`: a single-player pause screen is open. paused: AtomicBool, stop: AtomicBool, + smoothed_tick_ms: AtomicU32, } /// The window's handle on its server thread. @@ -47,6 +48,9 @@ pub(super) struct Integrated { thread: Option>, } impl Integrated { + pub fn smoothed_tick_ms(&self) -> f32 { + f32::from_bits(self.flags.smoothed_tick_ms.load(Ordering::Relaxed)) + } /// `IntegratedServer.tickServer` skips the world while the game is paused. pub fn set_paused(&self, paused: bool) { self.flags.paused.store(paused, Ordering::Relaxed); @@ -233,7 +237,13 @@ impl Game<'_> { // Only the connections run. self.tick_lan(); } else { + let started = Instant::now(); self.tick()?; + self.debug_charts.log_tick(started, started.elapsed()); + flags.smoothed_tick_ms.store( + self.debug_charts.smoothed_tick_ms.to_bits(), + Ordering::Relaxed, + ); } let rate = self.clock.rate().max(1.0); next += Duration::from_secs_f64(1.0 / f64::from(rate)); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index e31e270b8..48435b308 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -68,6 +68,7 @@ struct Lerp { pub(super) struct Remote { pub session: Session, + pub brand: String, builtin: Arc, lang: Arc, registries: Arc, @@ -238,6 +239,7 @@ impl Game<'_> { self.apply_settings(); self.remote = Some(Remote { session, + brand: "unknown".into(), builtin: Arc::new(builtin), lang, registries: Arc::new(Dynamic::default()), @@ -442,6 +444,11 @@ impl Game<'_> { r.status = format!("Joined as {name}; loading terrain..."); } } + Event::Brand(brand) => { + if let Some(remote) = &mut self.remote { + remote.brand = brand; + } + } Event::Reconfigured(registries) => self.set_registries(registries), Event::DecodeError(e) => { if let Some(r) = self.remote.as_mut() { diff --git a/crates/horizon-client/src/net.rs b/crates/horizon-client/src/net.rs index d260498a0..f9ad5992a 100644 --- a/crates/horizon-client/src/net.rs +++ b/crates/horizon-client/src/net.rs @@ -29,6 +29,8 @@ use std::{ pub enum Event { /// Progress text for the connecting screen. Status(String), + /// The server's `minecraft:brand` custom payload. + Brand(String), /// Configuration finished: the play state begins with these registries. Joined { registries: Arc, @@ -374,7 +376,7 @@ fn run( .map_err(e)?; let (mut reader, writer) = c.split(); *shared_writer.lock().unwrap() = Some(writer); - let registries = configure(&mut reader, shared_writer, lang)?; + let registries = configure(&mut reader, shared_writer, lang, send)?; let _ = send.send(Event::Joined { registries: Arc::new(registries), uuid: profile.uuid, @@ -413,10 +415,13 @@ fn run( } play::Clientbound::StartConfiguration(_) => { reply(play::Serverbound::ConfigurationAcknowledged(Empty)); - let registries = configure(&mut reader, shared_writer, lang)?; + let registries = configure(&mut reader, shared_writer, lang, send)?; let _ = send.send(Event::Reconfigured(Arc::new(registries))); } play::Clientbound::Disconnect(d) => return Ok(plain(&d.reason, lang)), + play::Clientbound::CustomPayload(p) if p.channel == "minecraft:brand" => { + receive_brand(&p, send); + } other => { if send.send(Event::Packet(Box::new(other))).is_err() { return Ok("Disconnected".into()); @@ -432,6 +437,7 @@ fn configure( reader: &mut ConnReader, writer: &Mutex>, lang: &Language, + send: &Sender, ) -> Result { let mut registries = Dynamic::default(); let reply = |p: cfg::Serverbound| -> Result<(), String> { @@ -444,6 +450,7 @@ fn configure( let (id, payload) = reader.recv().map_err(|e| e.to_string())?; match cfg::Clientbound::decode(id, &payload).map_err(|e| e.to_string())? { cfg::Clientbound::KeepAlive(k) => reply(cfg::Serverbound::KeepAlive(k))?, + cfg::Clientbound::CustomPayload(p) => receive_brand(&p, send), cfg::Clientbound::Ping(p) => reply(cfg::Serverbound::Pong(p))?, // Know no packs: the server then sends every registry entry in full. cfg::Clientbound::SelectKnownPacks(_) => { @@ -477,6 +484,14 @@ fn configure( } } +fn receive_brand(payload: &cfg::CustomPayload, send: &Sender) { + if payload.channel == "minecraft:brand" + && let Ok(brand) = horizon_protocol::buf::Reader::new(&payload.data).string(32767) + { + let _ = send.send(Event::Brand(brand)); + } +} + /// The minecraft:brand payload: a string naming the client. fn brand() -> Vec { let mut w = horizon_protocol::buf::Writer::new(); @@ -565,3 +580,28 @@ pub fn ping(address: &str, timeout: Duration) -> Result<(serde_json::Value, u128 let _ = c.recv().map_err(e)?; Ok((json, start.elapsed().as_millis())) } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn server_brand_payload_is_decoded_and_invalid_or_unrelated_payloads_are_ignored() { + let (send, events) = channel(); + let mut writer = horizon_protocol::buf::Writer::new(); + writer.string("vanilla"); + let mut payload = cfg::CustomPayload { + channel: "minecraft:brand".into(), + data: writer.data, + }; + receive_brand(&payload, &send); + assert!(matches!(events.try_recv(), Ok(Event::Brand(brand)) if brand == "vanilla")); + payload.channel = "example:other".into(); + receive_brand(&payload, &send); + assert!(events.try_recv().is_err()); + payload.channel = "minecraft:brand".into(); + payload.data = vec![0xff]; + receive_brand(&payload, &send); + assert!(events.try_recv().is_err()); + } +} diff --git a/crates/horizon-protocol/src/connection.rs b/crates/horizon-protocol/src/connection.rs index 3c6087f2e..8329d9360 100644 --- a/crates/horizon-protocol/src/connection.rs +++ b/crates/horizon-protocol/src/connection.rs @@ -355,6 +355,8 @@ mod tests { big.extend(std::iter::repeat_n(3u8, 1000)); c.send(&big).unwrap(); assert_eq!(c.recv().unwrap(), (9, vec![1, 2])); + assert_eq!(c.reader.counters.sent.load(Ordering::Relaxed), 1); + assert_eq!(c.reader.counters.received.load(Ordering::Relaxed), 1); server.join().unwrap(); assert!(c.recv().is_err()); } 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 19/28] 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 20/28] 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 21/28] 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 fab2a7cb0607e84f7d7b339e2407f7a17d97595c Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:40:07 -0400 Subject: [PATCH 22/28] Expose Horizon Extras in Classic Options --- crates/horizon-client/src/game/control.rs | 1 + crates/horizon-client/src/options_ui.rs | 113 +++++++++++++++++++++- 2 files changed, 113 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index e1169b2c8..87b6de5de 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -464,6 +464,7 @@ impl Game<'_> { "packs" => Page::Packs, "graphics" => Page::Graphics, "graphics-advanced" => Page::GraphicsAdvanced, + "extras" => Page::Extras, other => return Err(format!("unknown options page {other}").into()), }; if self.screen == Screen::Playing && self.title.is_none() { diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 38be29576..11a398cc6 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -714,6 +714,7 @@ pub enum Page { /// Horizon's controller settings and button binds. Controller, PadBinds, + Extras, } #[derive(Clone, Debug, PartialEq)] enum Act { @@ -721,6 +722,7 @@ enum Act { Push(Page), Done, Cycle(Opt), + Extra(crate::extras::Item), Key(&'static str), ResetKey(&'static str), ResetKeys, @@ -974,6 +976,7 @@ impl OptionsUi { Page::Graphics | Page::GraphicsAdvanced => "options.videoTitle", Page::Controller => "Controller Settings", Page::PadBinds => "Controller Binds", + Page::Extras => "Horizon Extras", } } fn scrollbar_x(&self, width: f32) -> f32 { @@ -986,6 +989,22 @@ impl OptionsUi { } fn list_rows(&self, s: &Settings) -> Vec { match self.page() { + Page::Extras => crate::extras::rows() + .into_iter() + .map(|row| match row { + Err(header) => Row::Header(header), + Ok(item) => { + let value = format!("{}: {}", item.caption(), item.value(&s.extras)); + let label = + if item.key_name().is_some() && self.selected_key == item.key_name() { + Text::literal(format!("> {value} <")).with_color(text::YELLOW) + } else { + Text::literal(value) + }; + Row::Buttons(button(0.0, 0.0, 310.0, label, Act::Extra(item)), None) + } + }) + .collect(), Page::Video => { // Horizon's graphics screens, Simple and Advanced. let mut rows = vec![Row::Buttons( @@ -1207,7 +1226,7 @@ impl OptionsUi { ("options.resourcepack", Some(Page::Packs)), ("options.accessibility", Some(Page::Accessibility)), ("options.telemetry", None), - ("options.credits_and_attribution", None), + ("Horizon Extras...", Some(Page::Extras)), ]; let gy = (61.0 + 30.0f32).min(h - 33.0 - 120.0); for (i, (key, page)) in entries.iter().enumerate() { @@ -1631,6 +1650,13 @@ impl OptionsUi { let hover = ui::hovered(cursor, wd.x, wd.y, wd.w, wd.h) && (!wd.list || cursor.1 >= top && cursor.1 < bottom); if hover { + if let WKind::Button { + act: Act::Extra(item), + .. + } = &wd.kind + { + tooltip = Some(atlas.font.split(&Text::literal(item.description()), 170.0)); + } let key = match &wd.kind { WKind::Button { act: Act::Cycle(opt), @@ -1919,6 +1945,14 @@ impl OptionsUi { } events.push(Event::Changed); } + Act::Extra(item) => { + if let Some(name) = item.key_name() { + self.selected_key = Some(name); + } else { + item.cycle(&mut s.extras, right); + events.push(Event::Changed); + } + } Act::Key(name) => self.selected_key = Some(name), Act::ResetKey(name) => { s.keys.set(name, KeyBinds::default_of(name)); @@ -2316,6 +2350,83 @@ mod tests { } } + #[test] + fn classic_extras_entry_edits_shared_settings_and_returns_without_changing_style() { + let previous_style = style(); + set_style(MenuStyle::Classic); + let atlas = atlas(); + let mut s = Settings::default(); + let mut ui = OptionsUi::default(); + let size = (480.0, 480.0); + let click = |ui: &mut OptionsUi, s: &mut Settings, act: Act| { + let (widgets, _, _, _) = ui.layout(s, size.0, size.1); + let widget = widgets + .iter() + .find( + |w| matches!(&w.kind, WKind::Button { act: a, active: true, .. } if *a == act), + ) + .unwrap(); + ui.click( + s, + &atlas, + widget.x + 1.0, + widget.y + 1.0, + size, + [960, 960], + false, + false, + ) + }; + assert_eq!( + click(&mut ui, &mut s, Act::Push(Page::Extras)), + vec![Event::ButtonClick] + ); + assert_eq!(ui.page(), Page::Extras); + let (widgets, _, _, _) = ui.layout(&s, size.0, size.1); + assert_eq!( + widgets + .iter() + .filter(|w| matches!( + w.kind, + WKind::Button { + act: Act::Extra(_), + .. + } + )) + .count(), + crate::extras::rows().iter().filter(|r| r.is_ok()).count() + ); + assert_eq!( + click(&mut ui, &mut s, Act::Extra(crate::extras::Item::Zoom)), + vec![Event::ButtonClick, Event::Changed] + ); + assert!(s.extras.zoom); + assert_eq!( + click(&mut ui, &mut s, Act::Extra(crate::extras::Item::ZoomKey)), + vec![Event::ButtonClick] + ); + assert_eq!(ui.selected_key, Some(crate::extras::ZOOM_KEY)); + assert_eq!( + ui.key(&mut s, &atlas, winit::keyboard::KeyCode::KeyC, None), + vec![Event::Changed] + ); + assert_eq!(s.extras.zoom_key, "key.keyboard.c"); + assert_eq!( + crate::extras::Extras::parse(&s.extras.serialize()), + s.extras + ); + ui.scroll(&s, size, -1000.0); + let (_, top, bottom, content) = ui.layout(&s, size.0, size.1); + assert_eq!(ui.scroll, content - (bottom - top)); + assert_eq!( + ui.key(&mut s, &atlas, winit::keyboard::KeyCode::Escape, None), + vec![Event::Changed] + ); + assert_eq!(ui.page(), Page::Main); + assert_eq!(style(), MenuStyle::Classic); + set_style(previous_style); + } + #[test] fn classic_graphics_presets_set_the_distances() { let atlas = atlas(); 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 23/28] 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 d98ee9a7603f9220239cbcb059664311e12526c3 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Fri, 16 Oct 2026 21:44:57 -0400 Subject: [PATCH 24/28] Route mouse-bound hotbar keys through container swaps --- crates/horizon-client/src/game.rs | 12 +++++++ crates/horizon-client/src/keybinds.rs | 49 +++++++++++++++++++++++++++ 2 files changed, 61 insertions(+) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 5ffcd9124..3d17c0f74 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9363,6 +9363,18 @@ impl ApplicationHandler for Game<'_> { } WindowEvent::MouseInput { state, button, .. } => { let pressed = state == ElementState::Pressed; + if matches!(self.screen, Screen::Inventory | Screen::Creative) + && let Some(key) = self + .settings + .keys + .container_mouse_key(button, self.creative) + { + if pressed && self.carried.is_none() { + self.inventory_hotkey(key); + } + // Neither edge of a bound button is an ordinary slot click. + return Ok(()); + } match self.screen { Screen::Playing => { if pressed && !self.captured { diff --git a/crates/horizon-client/src/keybinds.rs b/crates/horizon-client/src/keybinds.rs index 155ffcc24..5f8c0876b 100644 --- a/crates/horizon-client/src/keybinds.rs +++ b/crates/horizon-client/src/keybinds.rs @@ -373,11 +373,60 @@ impl KeyBinds { } Some(Err(button)) } + /// `AbstractContainerScreen.checkHotbarMouseClicked`: off hand, then hotbar. + pub fn container_mouse_key(&self, button: MouseButton, creative: bool) -> Option { + let name = mouse_name(button); + if matches!(button, MouseButton::Left | MouseButton::Right) + || (creative && self.get("key.pickItem") == name) + { + return None; + } + std::iter::once("key.swapOffhand") + .chain( + MAPPINGS + .iter() + .map(|m| m.0) + .filter(|n| n.starts_with("key.hotbar.")), + ) + .find(|mapping| self.get(mapping) == name) + .and_then(|mapping| key_code(Self::default_of(mapping))) + } } #[cfg(test)] mod tests { use super::*; + #[test] + fn container_mouse_hotkeys_follow_slot_bindings_and_pick_item_priority() { + for button in [MouseButton::Back, MouseButton::Forward, MouseButton::Middle] { + for (mapping, default, _) in MAPPINGS.iter().filter(|m| m.0.starts_with("key.hotbar.")) + { + let mut keys = KeyBinds::default(); + keys.set(mapping, &mouse_name(button)); + assert_eq!(keys.container_mouse_key(button, false), key_code(default)); + assert_eq!( + keys.container_mouse_key(button, true), + if button == MouseButton::Middle { + None + } else { + key_code(default) + } + ); + } + } + let mut keys = KeyBinds::default(); + keys.set("key.hotbar.1", "key.mouse.4"); + keys.set("key.swapOffhand", "key.mouse.4"); + assert_eq!( + keys.container_mouse_key(MouseButton::Back, false), + Some(KeyCode::KeyF) + ); + keys.set("key.hotbar.2", "key.mouse.left"); + assert_eq!(keys.container_mouse_key(MouseButton::Left, false), None); + assert_eq!(keys.container_mouse_key(MouseButton::Right, false), None); + assert_eq!(keys.container_mouse_key(MouseButton::Forward, false), None); + } + #[test] fn rebinding_translates_to_defaults() { let mut k = KeyBinds::default(); 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 25/28] 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 26/28] 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 27/28] 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 From 2822d4e1b7146a1a41392421d3ddb818452fb522 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 01:17:09 +0200 Subject: [PATCH 28/28] Content mods: refuse more block states than chunks hold; the pack against NeoForge, measured Loading the eight carried-over mods in the game (not only the probe) showed two limits real packs reach. Block textures past 2048 layers are another PR; this one handles block states and measures a pack. - Chunk sections store a block state in 16 bits. Vanilla 26.3 has 35,723 states; Macaw's four mods add 36,154, the eight 41,389. Past 65,536 ids wrapped onto other blocks (a trapdoor became a hanging sign). mod_content::build now refuses a set of mods past MAX_STATES and names the states per mod; the game then starts without content mods, as for any refused content. - tools/mod_port_harness.py probes each mod on its own against vanilla, as a player adding it would load it. - tools/perf_bench.py --game neoforge: Minecraft 1.21.1 on NeoForge 21.1.259 with --mod-jars and --deps, driven by a dev-only NeoForge port of the bench mod (mods/horizon/src/neoforge-bench); --port-work loads a work folder's carried-over mods into Horizon. tools/neoforge_oracle.py installs the client once under .local/neoforge-oracle (the installer, then the vanilla libraries it inherits, sha1-checked) and builds the driver. A NeoForge start that crashes before the driver loads (FML reading fml.toml while creating it) is retried once. Measured (docs/modpacks.md): six ported mods in Horizon against the same mods on NeoForge, Mac mini M4 Pro, 2 games per row on a loaded machine. The world is ready 3.1x sooner at 8 and 16 chunks, the flights run 1.7x and 3.6x the frames, and Horizon's RSS is not lower (+1.1 GB with the mods). Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/mod_content.rs | 19 ++ .../horizon-client/src/mod_content_tests.rs | 26 ++ docs/modpacks.md | 52 +++- .../neoforgebench/NeoForgeBench.java | 275 ++++++++++++++++++ .../resources/META-INF/neoforge.mods.toml | 11 + tools/mod_port_harness.py | 20 +- tools/neoforge_oracle.py | 96 +++++- tools/perf_bench.py | 99 ++++++- 8 files changed, 571 insertions(+), 27 deletions(-) create mode 100644 mods/horizon/src/neoforge-bench/java/dev/horizonlab/neoforgebench/NeoForgeBench.java create mode 100644 mods/horizon/src/neoforge-bench/resources/META-INF/neoforge.mods.toml diff --git a/crates/horizon-client/src/mod_content.rs b/crates/horizon-client/src/mod_content.rs index 4556a4d6c..f78808da7 100644 --- a/crates/horizon-client/src/mod_content.rs +++ b/crates/horizon-client/src/mod_content.rs @@ -314,6 +314,22 @@ impl<'a> Plan<'a> { }); } } + if next > MAX_STATES { + let mut by_mod: BTreeMap<&str, u32> = BTreeMap::new(); + for b in &blocks { + *by_mod + .entry(&b.decl.id[..b.decl.id.find(':').unwrap_or(0)]) + .or_default() += b.rename.states.len() as u32; + } + let list: Vec = by_mod.iter().map(|(m, n)| format!("{m} {n}")).collect(); + return Err(format!( + "{next} block states, more than the {MAX_STATES} chunks can hold ({} in the game; \ + the mods: {})", + names.len(), + list.join(", ") + ) + .into()); + } // Block items copy the template block's item. let gameplay = read_json(&base.join("gameplay-facts.json"))?; let rows = match gameplay.get("states") { @@ -628,6 +644,9 @@ const NBT_TABLES: [&str; 6] = [ /// In a root built here: the content mods' ids, the namespaces loaders /// read besides `minecraft`. const MARKER: &str = "horizon-mod-content.json"; +/// Block states a world can hold: chunk sections store a state in 16 bits +/// (crate::chunk). Mods past it are refused, not wrapped onto other blocks. +pub const MAX_STATES: u32 = 1 << 16; /// The content mods' namespaces in a root built by [`build`]; none in any /// other root, so vanilla's loaders read exactly what they did. diff --git a/crates/horizon-client/src/mod_content_tests.rs b/crates/horizon-client/src/mod_content_tests.rs index d7627fa27..eff9ddeaa 100644 --- a/crates/horizon-client/src/mod_content_tests.rs +++ b/crates/horizon-client/src/mod_content_tests.rs @@ -220,6 +220,32 @@ fn refuses_unknown_templates_and_vanilla_ids() { fs::remove_dir_all(&scratch).unwrap(); } +#[test] +fn refuses_more_states_than_chunks_hold() { + let Some(base) = prepared() else { + return; + }; + let scratch = std::env::temp_dir().join(format!("horizon-mod-states-{}", std::process::id())); + let _ = fs::remove_dir_all(&scratch); + let mut m = ruby_mod(&scratch.join("ruby")); + // Redstone wire has 1296 states: 40 copies pass any game's 65536. + let mut wire = m.content.blocks[0].clone(); + wire.template = "minecraft:redstone_wire".into(); + for i in 0..40 { + let mut b = wire.clone(); + b.id = format!("ruby:wire_{i}"); + m.content.blocks.push(b); + } + let e = build(&base, std::slice::from_ref(&m), &scratch.join("out")).unwrap_err(); + assert!( + e.to_string() + .contains("more than the 65536 chunks can hold"), + "{e}" + ); + assert!(e.to_string().contains("the mods: ruby "), "{e}"); + fs::remove_dir_all(&scratch).unwrap(); +} + #[test] fn no_content_keeps_the_base_root() { let base = Path::new("/nonexistent/base"); diff --git a/docs/modpacks.md b/docs/modpacks.md index d3cb7c401..1d8609cef 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -237,6 +237,11 @@ How the game loads them, without touching vanilla's path: - Loaders that read only `data/minecraft/` (recipes, loot, tags) read every namespace, as vanilla does. With no mods there is only `minecraft`, so nothing changes. - The overlay is cached like the resource-pack overlay and rebuilt when a mod file changes. +- **Limits.** Chunk sections store a block state in 16 bits: vanilla 26.3 has 35,723 states, + so mods may add 29,813. Past that the content root is refused with the states per mod + (Macaw's Doors, Fences, Paths and Trapdoors alone add 36,154: not all four fit). Block + sprites fill texture arrays of 2048 layers, four at most (8,192; vanilla takes 1,250, + identical textures share a layer). Wider state ids are the next step for big packs. - Not in 0.2: multiplayer registry sync (single player and the integrated server first), worlds opened without a mod they used (vanilla turns unknown blocks into air; we will ask first), vanilla ids redefined by a mod (refused). @@ -494,10 +499,12 @@ published. ## Measuring "10x" `tools/perf_bench.py` already measures Horizon against vanilla and vanilla with performance -mods on the same machine, world and camera path ([benchmark.md](benchmark.md)). It gains -`--game pack --pack `: the pack on its own loader (NeoForge 21.1.259 for -ATM10), launched with the pack's recommended JVM arguments, driven by the same dev-only bench -mod, ported to that loader. +mods on the same machine, world and camera path ([benchmark.md](benchmark.md)). With +`--game neoforge --mod-jars --deps ` it runs the mods on their own loader (NeoForge +21.1.259 for ATM10, installed under `.local/neoforge-oracle`, `-Xmx2G` like the launcher), +driven by the same steps through a dev-only NeoForge port of the bench mod +(`mods/horizon/src/neoforge-bench`). `--game horizon --port-work ` loads a work folder's +carried-over mods into Horizon. A whole pack (`--pack`, its recommended JVM arguments) is next. | Metric | How | Horizon side | |---|---|---| @@ -520,6 +527,37 @@ confidence interval. Other ratios are reported as they come out. Caveat (in ever the pack runs Minecraft 1.21.1 and Horizon runs 26.3, so the vanilla parts differ by a few versions. +### Measured: six ported mods against the same mods on NeoForge + +Cloud Glass, Factory Blocks, Glassential, Macaw's Fences, Paths and Trapdoors (Doors left out: +with Trapdoors it passes the block states chunks hold, see Limits), carried over and loaded as +dev mods in Horizon, against their jars plus Architectury and Fusion on NeoForge 21.1.259. +Mac mini M4 Pro, 1280x720, seed 1234, the four flight scenes, 2 games per row, 2026-10-17. +Means; FPS is the mean of the four scenes. "Title" is start to title screen, "world" start to +a fresh world drawn around the spawn, "scene load" a teleport to every chunk drawn. + +| RD | game | title s | world s | scene load s | FPS | RSS steady / peak MB | load avg | +|---|---|---:|---:|---:|---:|---:|---:| +| 8 | Horizon + 6 mods | 9.8 | 16.2 | 4.0 | 122 | 2,644 / 2,771 | 32 | +| 8 | NeoForge + 6 mods | 19.5 | 50.0 | 30.2 | 72 | 2,325 / 2,592 | 56 | +| 8 | Horizon | 5.0 | 11.0 | 4.0 | 124 | 1,559 / 1,629 | 51 | +| 8 | NeoForge | 12.8 | 36.1 | 21.9 | 104 | 2,334 / 2,558 | 30 | +| 16 | Horizon + 6 mods | 10.8 | 27.0 | 11.3 | 90 | 2,925 / 3,032 | 40 | +| 16 | NeoForge + 6 mods | 26.4 | 82.5 | 64.3 | 25 | 3,016 / 3,519 | 45 | +| 16 | Horizon | 3.5 | 10.0 | 7.4 | 119 | 1,732 / 1,871 | 56 | +| 16 | NeoForge | 16.9 | 73.7 | 43.2 | 36 | 2,748 / 3,425 | 48 | + +Same content, Horizon against NeoForge: the world is ready 3.1x sooner at 8 chunks and 3.1x at +16, the title screen 2.0x and 2.4x sooner, and the flights run 1.7x and 3.6x the frames. RAM is +not lower: Horizon's steady RSS grows 1.1 GB with the mods (61,816 block states against +vanilla's 35,723; the per-state tables are the next thing to measure), while the JVM stays +inside its 2 GB heap. Caveats, so none of this is a "10x" claim yet: other sessions and CI +runners kept the machine's load average between 30 and 56 on 14 threads, so the confidence +intervals are as wide as the means (`perf_bench.py --table`); Horizon's frames are paced near +the display's 144 Hz at 8 chunks; Horizon's title time includes building the content overlay on +a first start (about 5 s, cached afterwards); and the pack runs 1.21.1 against Horizon's 26.3. +A quiet rerun with more games is the next measurement. + ## The working version for 2026-10-23 In scope (each is a PR or a small stack): @@ -545,7 +583,11 @@ In scope (each is a PR or a small stack): 6. **Measured:** load time, RAM and FPS of that pack on NeoForge 1.21.1 against Horizon, with the full ATM10 on NeoForge as the reference row. -Out of scope for that date, and next in order: worldgen carry-over (the 30 or so structure and biome mods), +Out of scope for that date, and next in order: worldgen carry-over (the 30 or so structure and biome mods; +the first one looked at, Moog's Voyager Structures, declares all 130 structures and 116 structure +sets with MoogsStructureLib's own `generic_jigsaw_structure` and `advanced_random_spread` types and +NeoForge's `c:` biome tags, so its carry needs a mapping to vanilla's jigsaw and random spread +types plus the oracle's biome tags, not only bundle merging), behaviour callbacks and server events (0.3), block entities, menus, capabilities and net (0.4), the first agent-ported logic-tier mod as the pilot of step 5, then machines. Porting all of ATM10 is a campaign. Each step publishes its coverage number; we make no claim beyond what diff --git a/mods/horizon/src/neoforge-bench/java/dev/horizonlab/neoforgebench/NeoForgeBench.java b/mods/horizon/src/neoforge-bench/java/dev/horizonlab/neoforgebench/NeoForgeBench.java new file mode 100644 index 000000000..5992ed27a --- /dev/null +++ b/mods/horizon/src/neoforge-bench/java/dev/horizonlab/neoforgebench/NeoForgeBench.java @@ -0,0 +1,275 @@ +package dev.horizonlab.neoforgebench; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.mojang.blaze3d.platform.GlUtil; +import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardOpenOption; +import java.util.ArrayList; +import java.util.List; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.screens.TitleScreen; +import net.minecraft.client.player.LocalPlayer; +import net.minecraft.world.Difficulty; +import net.minecraft.world.level.GameRules; +import net.minecraft.world.level.GameType; +import net.minecraft.world.level.LevelSettings; +import net.minecraft.world.level.WorldDataConfiguration; +import net.minecraft.world.level.levelgen.WorldOptions; +import net.minecraft.world.level.levelgen.presets.WorldPresets; +import net.minecraft.world.phys.Vec3; +import net.neoforged.api.distmarker.Dist; +import net.neoforged.fml.common.Mod; +import net.neoforged.neoforge.client.event.RenderFrameEvent; +import net.neoforged.neoforge.common.NeoForge; + +/** + * Dev-only benchmark driver for a NeoForge 1.21.1 client (tools/perf_bench.py + * --game neoforge): the steps of mods/horizon/src/bench's VanillaBench, on + * NeoForge's events. From the title screen it creates a fresh creative world + * with the script's seed, waits for the spawn area, then per scene teleports, + * waits for the chunks, settles and flies a straight line at constant speed, + * recording every frame time. Events go to horizon.bench.out as JSON lines; + * the game quits after the last scene. Never shipped. + */ +@Mod(value = "horizon_bench", dist = Dist.CLIENT) +public final class NeoForgeBench { + private enum Phase { TITLE, WORLD, TELEPORT, LOAD, SETTLE, FLY, DONE } + + private final JsonObject script; + private final Path out; + private final List scenes = new ArrayList<>(); + private Phase phase = Phase.TITLE; + private int scene = -1; + private long phaseStart; + private long lastFrame; + private long readyCheck; + private int lastLoaded = -1; + private long lastChange; + private final List frames = new ArrayList<>(); + + public NeoForgeBench() { + String scriptPath = System.getProperty("horizon.bench.script"); + String outPath = System.getProperty("horizon.bench.out"); + if (scriptPath == null || outPath == null) { + script = null; + out = null; + return; + } + try { + script = JsonParser.parseString(Files.readString(Path.of(scriptPath))).getAsJsonObject(); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + out = Path.of(outPath); + for (var element : script.getAsJsonArray("scenes")) scenes.add(element.getAsJsonObject()); + NeoForge.EVENT_BUS.addListener(RenderFrameEvent.Pre.class, e -> step(Minecraft.getInstance())); + event("init"); + } + + private void step(Minecraft mc) { + long now = System.nanoTime(); + float frameMs = lastFrame == 0 ? 0 : (now - lastFrame) / 1e6f; + lastFrame = now; + double elapsed = (now - phaseStart) / 1e9; + if (phase != Phase.TITLE && phase != Phase.DONE && elapsed > script.get("timeout").getAsDouble() + && phase != Phase.FLY && phase != Phase.SETTLE) { + JsonObject e = new JsonObject(); + e.addProperty("phase", phase.name()); + event("timeout", e); + finish(mc); + return; + } + switch (phase) { + case TITLE -> { + if (mc.screen instanceof TitleScreen && mc.getOverlay() == null) { + event("title", renderer(mc)); + LevelSettings settings = new LevelSettings(script.get("world").getAsString(), GameType.CREATIVE, + false, Difficulty.NORMAL, true, new GameRules(), WorldDataConfiguration.DEFAULT); + WorldOptions options = new WorldOptions(script.get("seed").getAsLong(), true, false); + enter(Phase.WORLD, now); + mc.createWorldOpenFlows().createFreshLevel(script.get("world").getAsString(), settings, options, + WorldPresets::createNormalWorldDimensions, mc.screen); + } + } + case WORLD -> { + if (ready(mc, null, now)) { + JsonObject e = new JsonObject(); + e.addProperty("ready_epoch_ms", epochMs(lastChange)); + e.addProperty("chunks", lastLoaded); + event("world", e); + mc.player.connection.sendCommand("weather clear"); + next(mc, now); + } + } + case TELEPORT -> { + JsonObject s = scenes.get(scene); + Vec3 from = vec(s.getAsJsonArray("from")); + LocalPlayer player = mc.player; + player.connection.sendCommand("time set 6000"); + player.connection.sendCommand(String.format(java.util.Locale.ROOT, "tp @s %.3f %.3f %.3f %.3f %.3f", + from.x, from.y, from.z, yaw(s), s.get("pitch").getAsFloat())); + event("teleport", named(s)); + enter(Phase.LOAD, now); + } + case LOAD -> { + JsonObject s = scenes.get(scene); + Vec3 from = vec(s.getAsJsonArray("from")); + if (mc.player != null && mc.player.position().distanceToSqr(from) < 1024.0) place(mc, s, 0); + if (ready(mc, from, now)) { + JsonObject e = named(s); + e.addProperty("load_ms", (lastChange - phaseStart) / 1e6); + e.addProperty("chunks", lastLoaded); + event("loaded", e); + enter(Phase.SETTLE, now); + } + } + case SETTLE -> { + place(mc, scenes.get(scene), 0); + if (elapsed >= script.get("settle").getAsDouble()) { + frames.clear(); + event("fly", named(scenes.get(scene))); + enter(Phase.FLY, now); + } + } + case FLY -> { + frames.add(frameMs); + double t = Math.min(1.0, elapsed / script.get("seconds").getAsDouble()); + place(mc, scenes.get(scene), t); + if (t >= 1.0) { + JsonObject e = named(scenes.get(scene)); + JsonArray times = new JsonArray(); + frames.forEach(times::add); + e.add("frame_ms", times); + e.addProperty("chunks", mc.level.getChunkSource().getLoadedChunksCount()); + event("flown", e); + next(mc, now); + } + } + case DONE -> { } + } + } + + private void next(Minecraft mc, long now) { + scene++; + if (scene >= scenes.size()) { + finish(mc); + } else { + enter(Phase.TELEPORT, now); + } + } + + private void finish(Minecraft mc) { + phase = Phase.DONE; + event("done"); + mc.stop(); + } + + private void enter(Phase next, long now) { + phase = next; + phaseStart = now; + lastLoaded = -1; + lastChange = now; + } + + /** As VanillaBench.ready: spawned (near {@code at}), no screen, every chunk around, nothing to compile, 1 s stable. */ + private boolean ready(Minecraft mc, Vec3 at, long now) { + if (now - readyCheck < 10_000_000L) return false; + readyCheck = now; + if (mc.level == null || mc.player == null || mc.screen != null || mc.getOverlay() != null + || (at != null && mc.player.position().distanceToSqr(at) > 4.0)) { + lastChange = now; + lastLoaded = -1; + return false; + } + int loaded = mc.level.getChunkSource().getLoadedChunksCount(); + if (loaded != lastLoaded || !mc.levelRenderer.hasRenderedAllSections() || !chunksAround(mc)) { + lastLoaded = loaded; + lastChange = now; + return false; + } + return now - lastChange >= 1_000_000_000L; + } + + private static boolean chunksAround(Minecraft mc) { + int r = Math.max(1, mc.options.getEffectiveRenderDistance() - 1); + var center = mc.player.chunkPosition(); + var chunks = mc.level.getChunkSource(); + for (int dx = -r; dx <= r; dx++) { + for (int dz = -r; dz <= r; dz++) { + if (dx * dx + dz * dz <= r * r && !chunks.hasChunk(center.x + dx, center.z + dz)) return false; + } + } + return true; + } + + private static void place(Minecraft mc, JsonObject s, double t) { + LocalPlayer player = mc.player; + if (player == null) return; + Vec3 a = vec(s.getAsJsonArray("from")), b = vec(s.getAsJsonArray("to")); + Vec3 at = a.add(b.subtract(a).scale(t)); + player.setPos(at.x, at.y, at.z); + player.setYRot(yaw(s)); + player.setXRot(s.get("pitch").getAsFloat()); + player.setOldPosAndRot(); + player.setDeltaMovement(Vec3.ZERO); + player.fallDistance = 0; + if (!player.getAbilities().flying) { + player.getAbilities().flying = true; + player.onUpdateAbilities(); + } + } + + private static float yaw(JsonObject s) { + Vec3 a = vec(s.getAsJsonArray("from")), b = vec(s.getAsJsonArray("to")); + return (float) Math.toDegrees(Math.atan2(-(b.x - a.x), b.z - a.z)); + } + + private static Vec3 vec(JsonArray a) { + return new Vec3(a.get(0).getAsDouble(), a.get(1).getAsDouble(), a.get(2).getAsDouble()); + } + + private static JsonObject named(JsonObject s) { + JsonObject e = new JsonObject(); + e.addProperty("scene", s.get("name").getAsString()); + return e; + } + + private static JsonObject renderer(Minecraft mc) { + JsonObject e = new JsonObject(); + e.addProperty("gpu", GlUtil.getRenderer()); + e.addProperty("vendor", GlUtil.getVendor()); + e.addProperty("backend", "OpenGL"); + e.addProperty("driver", GlUtil.getOpenGLVersion()); + JsonArray size = new JsonArray(); + size.add(mc.getWindow().getWidth()); + size.add(mc.getWindow().getHeight()); + e.add("size", size); + e.addProperty("render_distance", mc.options.renderDistance().get()); + e.addProperty("simulation_distance", mc.options.simulationDistance().get()); + return e; + } + + private static long epochMs(long nanos) { + return System.currentTimeMillis() - (System.nanoTime() - nanos) / 1_000_000L; + } + + private void event(String name) { + event(name, new JsonObject()); + } + + private void event(String name, JsonObject e) { + e.addProperty("event", name); + e.addProperty("epoch_ms", System.currentTimeMillis()); + try { + Files.writeString(out, e + "\n", StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.APPEND); + } catch (IOException error) { + throw new UncheckedIOException(error); + } + } +} diff --git a/mods/horizon/src/neoforge-bench/resources/META-INF/neoforge.mods.toml b/mods/horizon/src/neoforge-bench/resources/META-INF/neoforge.mods.toml new file mode 100644 index 000000000..0fb0c3029 --- /dev/null +++ b/mods/horizon/src/neoforge-bench/resources/META-INF/neoforge.mods.toml @@ -0,0 +1,11 @@ +# Dev-only: the benchmark driver for a NeoForge client (tools/perf_bench.py --game neoforge). +# Built and run by tools/perf_bench.py; never shipped. +modLoader = "javafml" +loaderVersion = "[4,)" +license = "MIT" + +[[mods]] +modId = "horizon_bench" +version = "1" +displayName = "Horizon benchmark driver (dev only)" +description = "Flies the client along tools/perf_bench.py's paths and records frame times." diff --git a/tools/mod_port_harness.py b/tools/mod_port_harness.py index 23f7e82b9..181e6533b 100644 --- a/tools/mod_port_harness.py +++ b/tools/mod_port_harness.py @@ -17,7 +17,8 @@ and what the game's loaders make of it. For every block and item the mod registe - recipes: each recipe's result, count and ingredients; - items: present, and their stack size. -Writes WORK/mods//harness/result.json per mod and prints a table. Jars, facts and results stay +Each mod is probed on its own, against vanilla. Writes WORK/mods//harness/{horizon,result}.json +per mod and prints a table. Jars, facts and results stay in WORK, outside the repository. """ import argparse @@ -185,18 +186,23 @@ def main(): metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=ROOT, text=True)) probe = Path(metadata['target_directory']) / 'release/examples/mod_port_probe' - out = work / 'horizon.json' - subprocess.run([str(probe), args.resources, str(work), str(out), *args.mods], check=True) oracle = json.loads(facts.read_text()) - horizon = json.loads(out.read_text()) - upgrades = sound_upgrades(oracle, horizon) old_items = set(oracle.get('vanilla_items', [])) mods = args.mods or sorted(p.name for p in (work / 'mods').iterdir() if (p / 'carry').is_dir()) - print(f'{"mod":<16} {"result":<7} ' + ' '.join(f'{c:>12}' for c in CHECKS)) + rows = [] for mod in mods: + # One mod at a time: each against vanilla, as a player adding it would load it (and a pack's + # sum may pass the block states a world holds, which the probe would refuse). + out = work / 'mods' / mod / 'harness' / 'horizon.json' + out.parent.mkdir(parents=True, exist_ok=True) + subprocess.run([str(probe), args.resources, str(work), str(out), mod], check=True) + horizon = json.loads(out.read_text()) carry_report = work / 'mods' / mod / 'carry-report.json' carry = json.loads(carry_report.read_text()) if carry_report.exists() else {} - result = compare_mod(mod, oracle, horizon, carry, upgrades, old_items) + rows.append(compare_mod(mod, oracle, horizon, carry, sound_upgrades(oracle, horizon), old_items)) + print(f'{"mod":<16} {"result":<7} ' + ' '.join(f'{c:>12}' for c in CHECKS)) + for result in rows: + mod = result['mod'] (work / 'mods' / mod / 'harness').mkdir(parents=True, exist_ok=True) (work / 'mods' / mod / 'harness' / 'result.json').write_text(json.dumps(result, indent=1)) cols = [] diff --git a/tools/neoforge_oracle.py b/tools/neoforge_oracle.py index f72bbec3e..7410c1fb5 100644 --- a/tools/neoforge_oracle.py +++ b/tools/neoforge_oracle.py @@ -45,6 +45,84 @@ def install(): return home +def client(): + """The NeoForge client (tools/perf_bench.py --game neoforge), installed once per version: the installer's + own files, then the vanilla libraries its version inherits, fetched as the launcher does (sha1-checked).""" + sys.path.insert(0, str(ROOT / 'tools')) + import hashlib + import lab + home = LOCAL / f'client-{NEOFORGE}' + profile = home / 'versions' / f'neoforge-{NEOFORGE}' / f'neoforge-{NEOFORGE}.json' + if not profile.exists(): + install() # the installer jar + home.mkdir(parents=True, exist_ok=True) + (home / 'launcher_profiles.json').write_text('{"profiles":{}}') + with (LOCAL / f'install-client-{NEOFORGE}.log').open('w') as log: + subprocess.run(['java', '-jar', str(LOCAL / f'neoforge-{NEOFORGE}-installer.jar'), '--installClient', + str(home)], cwd=LOCAL, stdout=log, stderr=subprocess.STDOUT, check=True) + neo = json.loads(profile.read_text()) + base = json.loads((home / 'versions' / neo['inheritsFrom'] / f'{neo["inheritsFrom"]}.json').read_text()) + jars = [] + for manifest in (neo, base): + names = {library['name'] for library in manifest['libraries']} + for library in manifest['libraries']: + artifact = library.get('downloads', {}).get('artifact') + if not artifact or not lab.library_allowed(library) or not lab.native_library_matches(library, None, names): + continue + path = home / 'libraries' / artifact['path'] + if not path.exists(): + with urllib.request.urlopen(artifact['url'], timeout=120) as r: + data = r.read() + if hashlib.sha1(data).hexdigest() != artifact['sha1']: + sys.exit(f'{artifact["url"]}: sha1 mismatch') + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(data) + if path not in jars: + jars.append(path) + return home, neo, base, jars + + +def client_command(java, heap, game_dir, natives, assets, jvm=(), game=()): + """The command the launcher would run for the NeoForge client profile, with no account.""" + home, neo, base, jars = client() + import lab + values = {'library_directory': str(home / 'libraries'), 'classpath_separator': os.pathsep, + 'version_name': f'neoforge-{NEOFORGE}', 'natives_directory': str(natives), + 'launcher_name': 'horizon-bench', 'launcher_version': '1'} + expand = lambda s: s.replace('${', '{').format(**values) + command = [str(java), f'-Xmx{heap}'] + for argument in base['arguments']['jvm']: + if isinstance(argument, dict): + if lab.library_allowed(argument): + command += [argument['value']] if isinstance(argument['value'], str) else argument['value'] + elif argument == '${classpath}': + # Every library; not the vanilla jar, which NeoForge's patched client replaces. + command.append(os.pathsep.join(map(str, jars))) + else: + command.append(expand(argument)) + command += [expand(a) for a in neo['arguments']['jvm']] + command += [*jvm, neo['mainClass']] + command += ['--username', 'Bench', '--uuid', '00000000000000000000000000000000', '--accessToken', '0', + '--version', f'neoforge-{NEOFORGE}', '--gameDir', str(game_dir), '--assetsDir', str(assets), + '--assetIndex', base['assetIndex']['id'], '--userType', 'msa', '--versionType', 'release', + *neo['arguments']['game'], *game] + return home, command + + +def build_bench(home): + """The NeoForge benchmark driver (mods/horizon/src/neoforge-bench), against the client.""" + return build(home, ROOT / 'mods/horizon/src/neoforge-bench', 'horizon-bench-neoforge.jar', client_classpath(home)) + + +def client_classpath(home): + libs = home / 'libraries' + first = [libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-client.jar', + libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-universal.jar'] + rest = sorted(p for p in libs.rglob('*.jar') if p not in first and 'slim' not in p.name + and 'extra' not in p.name and not p.name.endswith('-unpacked.jar')) + return os.pathsep.join(map(str, first + rest)) + + def classpath(home): libs = home / 'libraries' first = [libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-server.jar', @@ -54,27 +132,27 @@ def classpath(home): return os.pathsep.join(map(str, first + rest)) -def build(home): - """The exporter mod jar, rebuilt when its sources change.""" +def build(home, source=SOURCE, name='horizon-oracle.jar', cp=None): + """A dev-only mod jar (by default the exporter), rebuilt when its sources change.""" out = LOCAL / 'build' - jar = out / 'horizon-oracle.jar' - sources = sorted((SOURCE / 'java').rglob('*.java')) - resources = sorted(p for p in (SOURCE / 'resources').rglob('*') if p.is_file()) + jar = out / name + sources = sorted((source / 'java').rglob('*.java')) + resources = sorted(p for p in (source / 'resources').rglob('*') if p.is_file()) newest = max(p.stat().st_mtime for p in sources + resources) if jar.exists() and jar.stat().st_mtime > newest: return jar - classes = out / 'classes' + classes = out / f'classes-{Path(name).stem}' shutil.rmtree(classes, ignore_errors=True) classes.mkdir(parents=True) - javac = subprocess.run(['javac', '--release', '21', '-proc:none', '-nowarn', '-cp', classpath(home), + javac = subprocess.run(['javac', '--release', '21', '-proc:none', '-nowarn', '-cp', cp or classpath(home), '-d', str(classes), *map(str, sources)], capture_output=True, text=True) if javac.returncode: - sys.exit(f'the exporter does not compile:\n{javac.stdout}{javac.stderr}') + sys.exit(f'{name} does not compile:\n{javac.stdout}{javac.stderr}') with zipfile.ZipFile(jar, 'w', zipfile.ZIP_DEFLATED) as z: for p in sorted(classes.rglob('*.class')): z.write(p, p.relative_to(classes).as_posix()) for p in resources: - z.write(p, p.relative_to(SOURCE / 'resources').as_posix()) + z.write(p, p.relative_to(source / 'resources').as_posix()) return jar diff --git a/tools/perf_bench.py b/tools/perf_bench.py index 96fb7c8e7..013df41d6 100644 --- a/tools/perf_bench.py +++ b/tools/perf_bench.py @@ -13,6 +13,11 @@ for every game. RSS is sampled from outside the process for every game too. python3 tools/perf_bench.py --game vanilla-mods --label mods-m4 python3 tools/perf_bench.py --table horizon-m4 vanilla-m4 mods-m4 +A ported mod pack against the same mods on their own loader (docs/modpacks.md, "Measured"): + + python3 tools/perf_bench.py --game horizon --port-work WORK --label pack-horizon + python3 tools/perf_bench.py --game neoforge --mod-jars JARS --deps DEPS --label pack-neoforge + Games: horizon target/release/horizon-client, driven over its control socket vanilla your own 26.3 client.jar + Fabric Loader + a dev-only driver @@ -20,6 +25,13 @@ Games: is redistributed vanilla-mods the same + Sodium, Lithium, FerriteCore and ImmediatelyFast (pinned in packs/mods.lock.json) + neoforge Minecraft 1.21.1 on NeoForge (dev-only, tools/neoforge_oracle.py + installs it under .local/neoforge-oracle) + a driver mod + (mods/horizon/src/neoforge-bench) + the jars of --mod-jars and + --deps, the user's own; 26.3 options it does not know are ignored + +--port-work loads the mods a horizon-port-pack work folder carried over into +Horizon as dev mods. Results: benchmarks/perf/