From 260dd423c99eb4339b94e07cb25ea573b095c33c Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Sun, 25 Oct 2026 14:30:42 +0000 Subject: [PATCH 01/62] Keep sprint as a state so a sprint-jump keeps its forward impulse MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PlayerInput was rewriting the server sprint flag from the Ctrl and forward keys. That flag is synced back onto the client, and jumpFromGround adds its 0.2 look-direction impulse only while the flag is set, so releasing Ctrl before the jump (or double-tapping forward) produced a plain hop. Sprint still starts and stops through PlayerCommand. Co-Authored-By: Grok Co-authored-by: 一水合氨NH3-H2O --- crates/horizon-client/src/game/agent.rs | 3 +- crates/horizon-client/src/lan/hub.rs | 8 +- crates/horizon-client/src/sprint.rs | 73 ++++++++++++++ crates/horizon-client/tests/lan_bot.rs | 61 ++++++++++++ crates/horizon-world/src/living_motion.rs | 116 ++++++++++++++++++++++ 5 files changed, 259 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index f6b68aa74..944641bef 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -469,7 +469,8 @@ impl Game<'_> { "flying": p.flying, "fall_flying": p.fall_flying, "sneaking": self.keys.contains(&KeyCode::ShiftLeft), - "sprinting": self.keys.contains(&KeyCode::ControlLeft), + // The sprint flag jumpFromGround reads, not whether Ctrl is down. + "sprinting": p.sprinting, "health": p.health.health(), "absorption": p.health.absorption(), // The hurt animation's ticks left (the camera's hurt tilt). diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index c2a395899..657e81cb2 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -1982,9 +1982,15 @@ impl Hub { g.center = None; } S::PlayerInput(p) => { + // ServerGamePacketListenerImpl.handlePlayerInput records the + // keys and updates crouching. Sprinting is not a held key: + // PlayerCommand start/stop owns the flag, so releasing Ctrl + // (or double-tapping forward, which never holds it) must not + // clear it. The flag is synced back to the client, and + // LivingEntity.jumpFromGround adds its 0.2 look-direction + // impulse only while that flag is set. self.guests[i].input = p.flags; self.guests[i].sneaking = p.flags & 32 != 0; - self.guests[i].sprinting = p.flags & 64 != 0 && p.flags & 1 != 0; } // OPEN_INVENTORY (the ridden mount's inventory) and // START_FALL_FLYING (checked against the guest's chest slot diff --git a/crates/horizon-client/src/sprint.rs b/crates/horizon-client/src/sprint.rs index c2099306c..872667b55 100644 --- a/crates/horizon-client/src/sprint.rs +++ b/crates/horizon-client/src/sprint.rs @@ -134,3 +134,76 @@ impl SprintState { Ok(()) } } + +#[cfg(test)] +mod tests { + use super::*; + + fn standing() -> Conditions { + Conditions { + enough_food: true, + on_ground: true, + ..Conditions::default() + } + } + + fn step(state: &mut SprintState, keys: Keys, sprinting: &mut bool) { + let current = *sprinting; + let mut next = current; + state + .tick( + keys, + Conditions { + sprinting: current, + ..standing() + }, + 7, + |value| { + next = value; + Ok::<(), ()>(()) + }, + ) + .unwrap(); + *sprinting = next; + } + + /// Vanilla sprint is a state. Releasing the sprint key, including on the + /// jump tick, keeps it while forward is held; releasing forward stops it. + #[test] + fn sprint_survives_releasing_the_key_through_a_jump() { + let mut state = SprintState::default(); + let mut sprinting = false; + step( + &mut state, + Keys { + forward: true, + sprint: true, + ..Keys::default() + }, + &mut sprinting, + ); + assert!(sprinting); + step( + &mut state, + Keys { + forward: true, + jump: true, + ..Keys::default() + }, + &mut sprinting, + ); + assert!( + sprinting, + "a jump after the sprint key comes up must stay a sprint" + ); + step( + &mut state, + Keys { + jump: true, + ..Keys::default() + }, + &mut sprinting, + ); + assert!(!sprinting); + } +} diff --git a/crates/horizon-client/tests/lan_bot.rs b/crates/horizon-client/tests/lan_bot.rs index 6dd1b8258..ed1cc635b 100644 --- a/crates/horizon-client/tests/lan_bot.rs +++ b/crates/horizon-client/tests/lan_bot.rs @@ -278,6 +278,67 @@ fn run( handle.join().unwrap().unwrap() } +/// PlayerCommand owns sprint. PlayerInput (the jump bit included) must not +/// clear it, or the client's jumpFromGround skips the 0.2 forward impulse. +#[test] +fn sprint_commands_survive_keyboard_input_changes() { + let Some(resources) = resources() else { + return; + }; + let mut s = server(&resources); + let port = s.hub.lan.port; + let _bot = run(&mut s, move || connect(port, "Sprinter", true)); + let deadline = Instant::now() + Duration::from_secs(5); + while s.hub.guests.is_empty() { + s.tick(&[]); + assert!(Instant::now() < deadline, "guest did not join"); + thread::yield_now(); + } + let id = s.hub.guests[0].entity_id; + s.hub.guests[0].loaded = true; + s.hub.guests[0] + .inbox + .push_back(S::PlayerCommand(play::PlayerCommand { + id, + action: 1, + data: 0, + })); + s.tick(&[]); + assert!(s.hub.guests[0].sprinting); + // Forward with the sprint key (65), forward alone after Ctrl is released + // (1), no keys, and forward plus jump (17): the sprint a jump needs. + for flags in [65u8, 1, 0, 17, 33] { + s.hub.guests[0] + .inbox + .push_back(S::PlayerInput(play::PlayerInput { flags })); + s.tick(&[]); + let g = &s.hub.guests[0]; + assert!( + g.sprinting, + "keyboard input {flags} cleared the sprint flag" + ); + assert_eq!(g.input, flags); + assert_eq!(g.sneaking, flags & 32 != 0); + } + s.hub.guests[0] + .inbox + .push_back(S::PlayerCommand(play::PlayerCommand { + id, + action: 2, + data: 0, + })); + s.tick(&[]); + assert!(!s.hub.guests[0].sprinting); + s.hub.guests[0] + .inbox + .push_back(S::PlayerInput(play::PlayerInput { flags: 65 })); + s.tick(&[]); + assert!( + !s.hub.guests[0].sprinting, + "keyboard input started a sprint" + ); +} + #[test] fn status_and_join() { let Some(resources) = resources() else { diff --git a/crates/horizon-world/src/living_motion.rs b/crates/horizon-world/src/living_motion.rs index b44da8b7b..9c496ed63 100644 --- a/crates/horizon-world/src/living_motion.rs +++ b/crates/horizon-world/src/living_motion.rs @@ -122,3 +122,119 @@ pub fn air_drag(world: &mut W) -> Result { }; Ok(modified_friction(drag, world.air_drag_modifier()? as f32)) } + +#[cfg(test)] +mod tests { + use super::*; + use horizon_core::geometry::{Vec3, trig}; + + struct Jumper { + velocity: Vec3, + sprinting: bool, + yaw: f32, + synced: bool, + } + impl LivingMotionWorld for Jumper { + type Error = (); + fn velocity(&self) -> Vec3 { + self.velocity + } + fn set_velocity(&mut self, velocity: Vec3) -> Result<(), ()> { + self.velocity = velocity; + Ok(()) + } + fn jump_strength(&mut self) -> Result { + Ok(0.42) + } + fn block_jump_factor(&mut self) -> Result { + Ok(1.0) + } + fn has_jump_boost(&mut self) -> Result { + Ok(false) + } + fn jump_boost_amplifier(&mut self) -> Result { + Ok(0) + } + fn sprinting(&mut self) -> Result { + Ok(self.sprinting) + } + fn yaw(&mut self) -> Result { + Ok(self.yaw) + } + fn mark_needs_sync(&mut self) { + self.synced = true; + } + fn no_gravity(&mut self) -> Result { + Ok(false) + } + fn gravity_attribute(&mut self) -> Result { + Ok(0.08) + } + fn has_slow_falling(&mut self) -> Result { + Ok(false) + } + fn controlling_passenger_is_player(&mut self) -> Result { + Ok(false) + } + fn speed(&mut self) -> Result { + Ok(0.1) + } + fn omnidirectional_air_mover(&mut self) -> Result { + Ok(false) + } + fn air_drag_modifier(&mut self) -> Result { + Ok(0.0) + } + } + + fn impulse(yaw: f32) -> (f64, f64) { + let angle = f64::from(yaw * trig::DEG_TO_RAD); + ( + f64::from(-trig::sin(angle)) * 0.2, + f64::from(trig::cos(angle)) * 0.2, + ) + } + + /// LivingEntity.jumpFromGround: a sprint adds ~0.2 along look; a walk does not. + #[test] + fn sprint_jump_adds_look_direction_impulse() { + for yaw in [0.0, 45.0, 90.0, 180.0, 270.0, 300.0] { + let before = Vec3::new(0.13, -0.08, -0.05); + let mut sprinting = Jumper { + velocity: before, + sprinting: true, + yaw, + synced: false, + }; + jump_from_ground(&mut sprinting).unwrap(); + let (dx, dz) = impulse(yaw); + let horizontal = ((dx * dx) + (dz * dz)).sqrt(); + assert!( + (horizontal - 0.2).abs() < 1.0e-4, + "yaw {yaw}: impulse length {horizontal}" + ); + assert!( + (sprinting.velocity.x - (before.x + dx)).abs() < 1.0e-9, + "yaw {yaw}: x {:?} expected {}", + sprinting.velocity, + before.x + dx + ); + assert!((sprinting.velocity.z - (before.z + dz)).abs() < 1.0e-9); + // jump_power narrows the 0.42 strength through float, as vanilla does. + let jump_y = f64::from(0.42_f32); + assert!((sprinting.velocity.y - jump_y).abs() < 1.0e-9); + assert!(sprinting.synced); + + let mut walking = Jumper { + velocity: before, + sprinting: false, + yaw, + synced: false, + }; + jump_from_ground(&mut walking).unwrap(); + assert_eq!(walking.velocity.x, before.x); + assert_eq!(walking.velocity.z, before.z); + assert!((walking.velocity.y - jump_y).abs() < 1.0e-9); + } + } +} From 3a35e147e54714c6cc626e6c3277131ef4776a68 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 25 Oct 2026 18:48:13 +0100 Subject: [PATCH 02/62] Server mods run in the game: server thread, in-frame, LAN hosts, dedicated The game that simulates a world now starts its server mods (API 0.3, experimental): single player's server thread, single player in-frame (beside client mods), a LAN host either way, and the dedicated server. Windows that are clients of a server never run them. game/server_mods.rs: tick_server_mods at the end of the tick diffs the players (player_joined, player_left), delivers the tick's chat and block events in order, then calls tick. Block events come from players' breaking and placing (the acting player is the guest during as_guest); chat from the local chat path and the hub's new HostEvent::PlayerChat; a guest's /command reaches its mod before vanilla's dispatcher. tell and command replies go to their player (the window's chat or a SystemChat); broadcast goes to every player and the log. --dev-mod now works on the server thread, and servers check a dev mod's file once a second from their tick. Every hook returns at once when no server mod runs; without the mods feature they are empty stubs. Docs: docs/mods.md (where server mods run, when hooks run, not yet), docs/api/mods.md. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 7 + crates/horizon-client/src/game/chat.rs | 6 +- crates/horizon-client/src/game/integrated.rs | 4 +- crates/horizon-client/src/game/lan.rs | 3 + crates/horizon-client/src/game/lan_actions.rs | 4 + crates/horizon-client/src/game/mods.rs | 103 +++-- crates/horizon-client/src/game/server_mods.rs | 356 ++++++++++++++++++ crates/horizon-client/src/lan/hub.rs | 5 + crates/horizon-client/src/lan/hub/chat.rs | 4 + docs/api/mods.md | 12 +- docs/mods.md | 46 ++- 11 files changed, 511 insertions(+), 39 deletions(-) create mode 100644 crates/horizon-client/src/game/server_mods.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 699468651..fd6688daf 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -140,6 +140,7 @@ mod scoreboard; mod screens; mod sculk; mod sculk_fixture; +mod server_mods; mod server_packs; mod server_travel; mod shader_packs; @@ -3238,6 +3239,7 @@ impl Game<'_> { self.pad_rumble(horizon_client::gamepad::Rumble::BlockBroken); // ServerPlayerGameMode.destroyBlock. let state = self.world.block(pos[0], pos[1], pos[2]); + let broken = state; let facts = self.res.facts().get(state).clone(); let state = self.crack_mined_pot(pos, state); // Block.playerWillDestroy: mining their gold angers all nearby piglins. @@ -3269,6 +3271,9 @@ impl Game<'_> { creative, ) }); + if removed { + self.mod_block_event(pos, broken, false); + } if removed && !creative { let held = self.held().cloned(); self.mine_block_with_held(&facts.name, facts.hardness); @@ -3581,6 +3586,7 @@ impl Game<'_> { return Ok(true); }; let target = [pos.x, pos.y, pos.z]; + self.mod_block_event(target, state, true); if let Some(entity) = BlockEntity::for_block(&self.res.facts().get(state).name) { let key = (target[0], target[1], target[2]); self.world.block_entities.insert(key, entity); @@ -4109,6 +4115,7 @@ impl Game<'_> { self.update_totem_ready(); self.tick_command_extras(); self.tick_mods(); + self.tick_server_mods(); let camera_eye = self.camera_eye_height(); let stick = self.pad_move(); if self.riding.is_some() && self.player.is_some() { diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index ec85732ae..fe00088ea 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -582,7 +582,10 @@ impl Game<'_> { return; } if let Some(command) = message.strip_prefix('/') { - self.run_command(command); + // A client mod's command first, then a server mod's, as on a server. + if !self.mod_command(command) && !self.local_server_mod_command(command) { + self.run_command(command); + } } else { let line = Text::translate( "chat.type.text", @@ -597,6 +600,7 @@ impl Game<'_> { self.mods_chat(&line); } self.lan_host_chat(message); + self.mod_player_chat(super::server_mods::Who::Local, message); } } pub(super) fn chat_scroll(&mut self, amount: f32) { diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index d4726f2f1..3cca73a12 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -222,7 +222,6 @@ impl Game<'_> { options.report = None; options.server = None; options.world = None; - options.dev_mods.clear(); self.join_world_rest()?; let (res, pack, settings) = (self.res.clone(), self.pack.clone(), self.settings.clone()); let flags = Arc::new(Flags::default()); @@ -292,6 +291,9 @@ impl Game<'_> { launch.create.as_ref(), )?)?; let saved = Box::new(self.level.clone()); + // IntegratedServer runs the server mods; the window the client mods. + self.mods.dev = self.options.dev_mods.clone(); + self.start_mods(); // Math.max(2, options.renderDistance): past vanilla's 32 when the // window's render distance is (Horizon's options go to 64). let view_distance = self.settings.render_distance.max(2); diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 8460f54e6..20a66b117 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -934,6 +934,9 @@ impl Game<'_> { event @ (HostEvent::Chat { .. } | HostEvent::Warn(_) | HostEvent::Error(_)) => { self.lan_log_event(event); } + HostEvent::PlayerChat { sender, text } => { + self.mod_player_chat(super::server_mods::Who::Uuid(sender), &text); + } HostEvent::Joined(conn) => { self.lan_guest_joined(&mut host, conn, state.as_ref(), entities, spawn); if self.options.dedicated.is_some() diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 2c7019c73..6c928ec5c 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1407,6 +1407,10 @@ impl Game<'_> { ); return; } + // A server mod's command, for every player whatever their level. + if self.guest_server_mod_command(host, conn, command.trim_start_matches('/')) { + return; + } // An integrated server runs every player's commands at their own // permission level (`CommandSourceStack.permissions`); a LAN world // follows its Allow Commands, and a dedicated server leaves it to diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs index 5cd7bc368..b1ce4207c 100644 --- a/crates/horizon-client/src/game/mods.rs +++ b/crates/horizon-client/src/game/mods.rs @@ -17,20 +17,21 @@ use std::{path::PathBuf, time::Duration}; #[cfg(feature = "mods")] use { super::Screen, + super::{execution_role::ExecutionRole, lan::LanHost, server_mods::ModEvent}, horizon_client::{ extras::Corner, extras_hud, mod_list::Installed, text::{self, Text}, }, - horizon_mods::{Clock, Mods, Output, Player, Runs, Snapshot, Status}, + horizon_mods::{Clock, Mods, Output, Player, Runs, ServerPlayer, Snapshot, Status}, std::time::Instant, }; #[derive(Default)] pub(super) struct ModsState { #[cfg(feature = "mods")] - mods: Mods, + pub(super) mods: Mods, /// `--dev-mod PATH`: always on, reloaded when rebuilt. pub(super) dev: Vec, /// When dev mods were last checked for a rebuild. @@ -39,6 +40,15 @@ pub(super) struct ModsState { /// The chat's command tree while a running mod owns commands. #[cfg(feature = "mods")] tree: Option, + /// A server mod runs here: what players do is queued for it. + #[cfg(feature = "mods")] + pub(super) server: bool, + /// The players server mods saw last tick, for joins and leaves. + #[cfg(feature = "mods")] + pub(super) players: Vec, + /// What players did this tick, for server mods at its end. + #[cfg(feature = "mods")] + pub(super) events: Vec, } impl ModsState { /// The chat's command tree: vanilla's, plus the running mods' commands. @@ -185,14 +195,24 @@ impl Game<'_> { .collect(); let enabled = &self.settings.mods.enabled; let on = |id: &str| enabled.contains(id) || dev_ids.iter().any(|d| d == id); - let mods = Mods::load_for(Runs::Client, &paths, on, vanilla_command); + let mods = Mods::load_for(self.mod_runs(), &paths, on, vanilla_command); self.mods.mods = mods; self.list_mods(); self.sync_mod_commands(); self.show_mod_output(); } + /// Which mods this game runs: a server the server mods, the window + /// client mods, and both when it simulates the world itself (in-frame). + fn mod_runs(&self) -> Runs { + match self.options.execution_role { + ExecutionRole::IntegratedServer | ExecutionRole::DedicatedServer => Runs::Server, + ExecutionRole::Client if self.options.server_thread => Runs::Client, + ExecutionRole::Client => Runs::Both, + } + } /// The Mods page's rows, from what loaded. fn list_mods(&mut self) { + self.mods.server = self.mods.mods.runs_server(); let dev = &self.mods.dev; self.settings.mods.installed = self .mods @@ -263,8 +283,18 @@ impl Game<'_> { self.start_mods(); } } - /// What mods read this tick. + /// What mods read this tick: the server's players as they were at the + /// last tick's end. fn mod_snapshot(&self) -> Snapshot { + let players = if self.mods.server { + self.mods.players.clone() + } else { + Vec::new() + }; + self.mod_snapshot_with(players) + } + /// What mods read, with these players on the server. + pub(super) fn mod_snapshot_with(&self, players: Vec) -> Snapshot { let player = self.player.as_ref().map(|p| Player { x: p.position.x, y: p.position.y, @@ -282,7 +312,7 @@ impl Game<'_> { Snapshot { player, clock, - players: Vec::new(), + players, } } /// A game tick. @@ -295,21 +325,30 @@ impl Game<'_> { self.mods.mods.tick(self.ticks); self.show_mod_output(); } - /// Once per frame: the frame hook, and dev mods' rebuilds. - pub(super) fn mods_frame(&mut self, elapsed: Duration) { - if !self.mods.dev.is_empty() - && self + /// Restarts the dev mods rebuilt since the last check, once a second. + pub(super) fn reload_dev_mods(&mut self) { + if self.mods.dev.is_empty() + || self .mods .checked - .is_none_or(|t| t.elapsed() >= RELOAD_CHECK) + .is_some_and(|t| t.elapsed() < RELOAD_CHECK) { - self.mods.checked = Some(Instant::now()); - if self.mods.mods.reload_changed(vanilla_command) { - self.list_mods(); - self.sync_mod_commands(); + return; + } + self.mods.checked = Some(Instant::now()); + if self.mods.mods.reload_changed(vanilla_command) { + self.list_mods(); + self.sync_mod_commands(); + if self.options.execution_role.is_client() { self.system_message(Text::literal("Mods reloaded").with_color(text::GRAY)); + } else { + log::info!("Horizon: mods reloaded"); } } + } + /// Once per frame: the frame hook, and dev mods' rebuilds. + pub(super) fn mods_frame(&mut self, elapsed: Duration) { + self.reload_dev_mods(); if !self.mods.mods.is_running() { return; } @@ -335,8 +374,13 @@ impl Game<'_> { self.mods.mods.chat(line); self.show_mod_output(); } - /// Chat lines, command feedback and stopped mods, into the chat. - fn show_mod_output(&mut self) { + /// What mods showed: client mods' lines into the chat, server mods' + /// to their players. + pub(super) fn show_mod_output(&mut self) { + self.route_mod_output(None); + } + /// [`Game::show_mod_output`], with the hub when it is out of `self.lan`. + pub(super) fn route_mod_output(&mut self, mut host: Option<&mut LanHost>) { for output in self.mods.mods.drain() { let line = match output { Output::Chat { name, text } => { @@ -349,18 +393,29 @@ impl Game<'_> { Output::Stopped { name, reason } => { self.list_mods(); self.sync_mod_commands(); - Text::literal(format!("Mod {name} stopped: {reason}")).with_color(text::RED) + let line = format!("Mod {name} stopped: {reason}"); + if self.options.dedicated.is_some() { + super::dedicated::log("WARN", &line); + } + Text::literal(line).with_color(text::RED) + } + server + @ (Output::Tell { .. } | Output::Broadcast { .. } | Output::Reply { .. }) => { + self.route_server_output(host.as_deref_mut(), server); + continue; } - // Server mods' lines: this game runs no server mod yet. - Output::Tell { .. } | Output::Broadcast { .. } | Output::Reply { .. } => continue, }; - // Not through system_message: a mod must not hear its own lines. - let focused = self.screen == Screen::Chat; - self.ui - .chat - .add(&self.gui.atlas, line, None, self.ticks, focused); + self.add_mod_chat_line(line); } } + /// A mod's line in the window's chat; not through system_message: a mod + /// must not hear its own lines. + pub(super) fn add_mod_chat_line(&mut self, line: Text) { + let focused = self.screen == Screen::Chat; + self.ui + .chat + .add(&self.gui.atlas, line, None, self.ticks, focused); + } /// The mods' HUD panels, stacked with the extras in their corners. pub(super) fn draw_mod_panels(&self, batch: &mut HudBatch, corners: &mut Corners) { for panel in self.mods.mods.panels() { diff --git a/crates/horizon-client/src/game/server_mods.rs b/crates/horizon-client/src/game/server_mods.rs new file mode 100644 index 000000000..db88639eb --- /dev/null +++ b/crates/horizon-client/src/game/server_mods.rs @@ -0,0 +1,356 @@ +//! Server mods in the game (`docs/mods.md`, "Server mods"): the game that +//! simulates the world (in-frame single player, the server thread, a LAN +//! host, the dedicated server) runs them. At the end of each tick it tells +//! them who joined and left, then what players said, broke and placed since +//! the last one, then ticks them; a player's command reaches them at once. +//! Their lines go to the players they name. With no server mod on, each hook +//! here is one check. +use super::{Game, lan::LanHost}; +#[cfg(not(feature = "mods"))] +use horizon_world::registry::BlockStateId; + +/// Who did something a server mod hears about, resolved at the tick's end. +#[cfg_attr(not(feature = "mods"), allow(dead_code))] +pub(super) enum Who { + /// The window's own player, in-frame. + Local, + /// A connection's player (the server thread's owner is one). + Conn(u32), + Uuid(u128), +} + +/// What players did during a tick, for the server mods at its end. +#[cfg_attr(not(feature = "mods"), allow(dead_code))] +pub(super) enum ModEvent { + Chat(Who, String), + Block { + who: Who, + pos: [i32; 3], + state: String, + placed: bool, + }, +} + +#[cfg(not(feature = "mods"))] +impl Game<'_> { + pub(super) fn tick_server_mods(&mut self) {} + pub(super) fn mod_block_event(&mut self, _pos: [i32; 3], _state: BlockStateId, _placed: bool) {} + pub(super) fn mod_player_chat(&mut self, _who: Who, _text: &str) {} + pub(super) fn local_server_mod_command(&mut self, _line: &str) -> bool { + false + } + pub(super) fn guest_server_mod_command( + &mut self, + _host: &mut LanHost, + _conn: u32, + _line: &str, + ) -> bool { + false + } +} + +#[cfg(feature = "mods")] +mod run { + use super::{Game, LanHost, ModEvent, Who}; + use horizon_client::{ + command::args::GameMode as Mode, + lan::data::component_nbt, + text::{self, Text}, + }; + use horizon_mods::{BlockPos, GameMode, Output, ServerPlayer}; + use horizon_protocol::packets::play::{self, Clientbound as C}; + use horizon_world::registry::BlockStateId; + + /// `UUID.toString()`. + fn uuid_string(u: u128) -> String { + let h = format!("{u:032x}"); + format!( + "{}-{}-{}-{}-{}", + &h[..8], + &h[8..12], + &h[12..16], + &h[16..20], + &h[20..] + ) + } + + fn mode(id: i32) -> GameMode { + match id { + 1 => GameMode::Creative, + 2 => GameMode::Adventure, + 3 => GameMode::Spectator, + _ => GameMode::Survival, + } + } + + impl Game<'_> { + /// The players on this game's server: the window's own player + /// in-frame, then every connection's. `host` is the hub when it is + /// out of `self.lan`. + pub(in crate::game) fn server_players(&self, host: Option<&LanHost>) -> Vec { + let mut out = Vec::new(); + if self.options.execution_role.is_client() + && self.remote.is_none() + && let Some(p) = &self.player + { + out.push(ServerPlayer { + id: self.player_uuid_string(), + name: crate::game::chat::PLAYER_NAME.to_owned(), + x: p.position.x, + y: p.position.y, + z: p.position.z, + dimension: self.dim.id().to_owned(), + game_mode: match self.mode { + Mode::Survival => GameMode::Survival, + Mode::Creative => GameMode::Creative, + Mode::Adventure => GameMode::Adventure, + Mode::Spectator => GameMode::Spectator, + }, + health: p.health.health(), + }); + } + let guests = host + .or(self.lan.as_ref()) + .into_iter() + .flat_map(|h| &h.hub.guests); + out.extend(guests.filter(|g| g.placed).map(|g| ServerPlayer { + id: uuid_string(g.uuid), + name: g.name.clone(), + x: g.position[0], + y: g.position[1], + z: g.position[2], + dimension: g.dimension.clone(), + game_mode: mode(g.game_mode), + health: g.health, + })); + out + } + + /// Whether what players do now reaches server mods: one is running + /// and this game simulates the world. + fn hears_players(&self) -> bool { + self.mods.server && self.remote.is_none() + } + + /// The tick's end: joins and leaves, the tick's events, the tick hook. + pub(in crate::game) fn tick_server_mods(&mut self) { + if !self.options.execution_role.is_client() { + // A server has no frames to check its dev mods in. + self.reload_dev_mods(); + } + if !self.mods.server { + return; + } + let players = self.server_players(None); + let snapshot = self.mod_snapshot_with(players.clone()); + self.mods.mods.set_snapshot(snapshot); + let before = std::mem::take(&mut self.mods.players); + for p in before + .iter() + .filter(|p| !players.iter().any(|q| q.id == p.id)) + { + self.mods.mods.player_left(p); + } + for p in players + .iter() + .filter(|p| !before.iter().any(|q| q.id == p.id)) + { + self.mods.mods.player_joined(p); + } + for event in std::mem::take(&mut self.mods.events) { + let who = |w: &Who| { + let id = match w { + Who::Local => self.player_uuid_string(), + Who::Uuid(u) => uuid_string(*u), + Who::Conn(c) => { + let guests = self.lan.iter().flat_map(|h| &h.hub.guests); + let g = guests.into_iter().find(|g| g.conn == *c); + g.map_or_else(String::new, |g| uuid_string(g.uuid)) + } + }; + players.iter().chain(&before).find(|p| p.id == id).cloned() + }; + match event { + ModEvent::Chat(w, text) => { + if let Some(p) = who(&w) { + self.mods.mods.player_chat(&p, &text); + } + } + ModEvent::Block { + who: w, + pos, + state, + placed, + } => { + let Some(p) = who(&w) else { continue }; + let pos = BlockPos { + x: pos[0], + y: pos[1], + z: pos[2], + }; + if placed { + self.mods.mods.block_placed(&p, pos, &state); + } else { + self.mods.mods.block_broken(&p, pos, &state); + } + } + } + } + self.mods.mods.server_tick(self.ticks); + self.mods.players = players; + self.show_mod_output(); + } + + /// A player broke (or placed) `state` at `pos`: the player acting now. + pub(in crate::game) fn mod_block_event( + &mut self, + pos: [i32; 3], + state: BlockStateId, + placed: bool, + ) { + if !self.hears_players() { + return; + } + let who = self.lan_acting.map_or(Who::Local, Who::Conn); + let state = self.state_string(state); + self.mods.events.push(ModEvent::Block { + who, + pos, + state, + placed, + }); + } + + /// A chat message a player sent. + pub(in crate::game) fn mod_player_chat(&mut self, who: Who, text: &str) { + if self.hears_players() { + self.mods.events.push(ModEvent::Chat(who, text.to_owned())); + } + } + + /// `/line` typed by the window's own player in-frame: true when a + /// server mod owns it. + pub(in crate::game) fn local_server_mod_command(&mut self, line: &str) -> bool { + if !self.hears_players() { + return false; + } + let players = self.server_players(None); + let Some(me) = players.first().cloned() else { + return false; + }; + let snapshot = self.mod_snapshot_with(players); + self.mods.mods.set_snapshot(snapshot); + let owned = self.mods.mods.server_command(&me, line); + self.show_mod_output(); + owned + } + + /// `/line` typed by a connection's player: true when a server mod + /// owns it, whatever the player's permission level. + pub(in crate::game) fn guest_server_mod_command( + &mut self, + host: &mut LanHost, + conn: u32, + line: &str, + ) -> bool { + if !self.hears_players() { + return false; + } + let Some(g) = host.hub.guest(conn) else { + return false; + }; + let id = uuid_string(g.uuid); + let players = self.server_players(Some(host)); + let Some(me) = players.iter().find(|p| p.id == id).cloned() else { + return false; + }; + let snapshot = self.mod_snapshot_with(players); + self.mods.mods.set_snapshot(snapshot); + if !self.mods.mods.server_command(&me, line) { + return false; + } + self.route_mod_output(Some(host)); + true + } + + /// Sends a server mod's line to the player with this id: the + /// window's own chat for the local player, a system message for a + /// connection's. `host` is the hub when it is out of `self.lan`. + pub(in crate::game) fn tell_server_player( + &mut self, + host: Option<&mut LanHost>, + id: &str, + line: Text, + ) { + let local = self.options.execution_role.is_client() + && self.remote.is_none() + && self.player.is_some(); + if local && self.player_uuid_string() == id { + self.add_mod_chat_line(line); + return; + } + let Some(host) = host.or(self.lan.as_mut()) else { + return; + }; + let to = host + .hub + .guests + .iter() + .find(|g| g.placed && uuid_string(g.uuid) == id); + if let Some(conn) = to.map(|g| g.conn) { + host.hub.send_to( + conn, + &C::SystemChat(play::SystemChat { + content: component_nbt(&line.component()), + overlay: false, + }), + ); + } + } + + /// Routes a server mod's output: `Tell` and `Reply` to their player, + /// `Broadcast` to everyone and the log. + pub(in crate::game) fn route_server_output( + &mut self, + mut host: Option<&mut LanHost>, + output: Output, + ) { + let named = |name: &str, text: String| { + let mut line = Text::literal(format!("[{name}] ")).with_color(text::GRAY); + line.push(Text::literal(text)); + line + }; + match output { + Output::Tell { name, player, text } => { + self.tell_server_player(host, &player, named(&name, text)); + } + Output::Reply { + player, + text, + error, + } => { + let line = Text::literal(text); + let line = if error { + line.with_color(text::RED) + } else { + line + }; + self.tell_server_player(host, &player, line); + } + Output::Broadcast { name, text } => { + let plain = format!("[{name}] {text}"); + if self.options.dedicated.is_some() { + super::super::dedicated::log("INFO", &plain); + } else { + log::info!("{plain}"); + } + for p in self.server_players(host.as_deref()) { + let line = named(&name, text.clone()); + self.tell_server_player(host.as_deref_mut(), &p.id, line); + } + } + _ => {} + } + } + } +} diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index c2a395899..761d31af4 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -128,6 +128,11 @@ pub enum HostEvent { line: String, secure: bool, }, + /// A chat message a player sent (after it was broadcast), for server mods. + PlayerChat { + sender: u128, + text: String, + }, /// A server log warning (ServerGamePacketListenerImpl's LOGGER.warn). Warn(String), /// A server log error (LOGGER.error). diff --git a/crates/horizon-client/src/lan/hub/chat.rs b/crates/horizon-client/src/lan/hub/chat.rs index 7e75c84c5..efec59127 100644 --- a/crates/horizon-client/src/lan/hub/chat.rs +++ b/crates/horizon-client/src/lan/hub/chat.rs @@ -219,6 +219,10 @@ impl Hub { }; let line = format!("<{name}> {}", message.content); self.broadcast_chat(&message, &bound, line, events); + events.push(HostEvent::PlayerChat { + sender: uuid, + text: message.content, + }); } /// handleChatSessionUpdate: a new profile key, validated against the diff --git a/docs/api/mods.md b/docs/api/mods.md index 5db01a9b8..5fb9d9c1e 100644 --- a/docs/api/mods.md +++ b/docs/api/mods.md @@ -1,7 +1,7 @@ # Mod API -Mods are Rust crates compiled to sandboxed WebAssembly components. They run in the player's game and, once server -mods land, wherever a world is simulated. Design and the runtime: [mods.md](../mods.md). +Mods are Rust crates compiled to sandboxed WebAssembly components. Client mods run in the player's game; server mods +(experimental) run wherever a world is simulated: single player, a LAN host, the dedicated server. Design and the runtime: [mods.md](../mods.md). ## Overview @@ -83,9 +83,10 @@ release. What real mods need next, in the order modpacks and servers need it: -- **Server mods in the game** (`api = "0.3"`, [Server mods](../mods.md#server-mods-api-03-experimental)): the - contract, runtime and SDK are here; next the server thread, LAN host and dedicated server start them and call - their hooks, then entity events, game rules and server commands with typed arguments. +- **More for server mods** (`api = "0.3"`, [Server mods](../mods.md#server-mods-api-03-experimental)): they run + on the server thread, a LAN host and the dedicated server today, with joins, chat, commands and players' block + breaking and placing; next entity events, game rules, server commands with typed arguments sent to clients' + command trees. - **World and blocks**: read blocks, block states and biomes in loaded chunks; change them through the server's block log, so clients and the parity harnesses see vanilla's updates. - **Items and inventories**: the player's inventory, held item and open container; item stacks with components. @@ -101,6 +102,7 @@ What real mods need next, in the order modpacks and servers need it: ## Changelog +- Server mods run in the game: single player (server thread and in-frame), LAN hosts, the dedicated server. - API 0.3 (server mods, experimental): world `horizon-server-mod`, capability `players`, the `server-events` hooks; SDK `server::ServerMod`; example `welcome`. - SDK: `cargo horizon-mod test` and `horizon_mods::testing`, test scripts in TOML; the template has one. diff --git a/docs/mods.md b/docs/mods.md index 6a095adba..f0df45994 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -478,10 +478,40 @@ its component targets the WIT world `horizon-server-mod` instead of Capabilities that act on a local player (`game-read`, `chat`, `hud`) are for client mods; `players` is for server mods. In Rust: `impl horizon_mod_sdk::server::ServerMod` and `export_server_mod!`; the example is -[`welcome`](../crates/horizon-mod-sdk/examples/welcome/src/lib.rs). The -runtime, the registry's `check` and the SDK run them today; the game starts -them once its server code calls these hooks (the next step), and until then a -server mod that is turned on shows as run elsewhere. +[`welcome`](../crates/horizon-mod-sdk/examples/welcome/src/lib.rs). + +**Where they run.** The game that simulates the world starts the server mods +that are on, and only that one: + +| Mode | Runs server mods | Players they see | +|---|---|---| +| Single player (default) | the server thread | the window's player, a connection like any other | +| Single player `--in-frame` | the window's own game, beside its client mods | the window's player | +| Open to LAN, Play with Friends | the host's server thread (or its window, in-frame) | the host and every guest | +| Dedicated server (`--dedicated`, `horizon-server`) | the server | every connected player | + +A window that is a client of a server (single player's window, a LAN guest, +any multiplayer server) never runs them; its Mods page lists a server mod with +the others, and its switch takes effect the next time a world opens. The mods +live in `horizon-mods/` of the game folder, or of the server's folder on a +dedicated server, and are turned on as client mods are: Options > Mods, or +`mod.:true` in `horizon-mods.txt`. `--dev-mod ` runs one always +on and reloads it when its file changes, on a server too. + +**When hooks run.** At the end of each server tick the game tells the server +mods who joined and who left since the last one, then what players said, +broke and placed, in order, then calls `tick`. A command a player types +reaches its mod at once, whatever the player's permission level, and its +answer goes to that player. `tell` reaches one player, the window's own +chat for the in-frame player and a system message for a connection; +`broadcast` reaches every player and the server's log. With no server mod +on, each of these points costs one branch (measured in the PR that added +them). + +**Not yet.** Clients aren't sent server mods' commands with vanilla's +command tree, so a player's chat box doesn't complete or colour them; typing +them works. Block events are a player's own breaking and placing, not +explosions, pistons or other mods. ## Versions and compatibility @@ -502,10 +532,10 @@ server mod that is turned on shows as run elsewhere. in single player and on any server, vanilla or Horizon. They see only what the client already knows (the snapshot), like F3 does, and act only on the local screen and chat. A server cannot see them. -- **Server mods** (`side = "server"`) will run where the world is simulated: - Horizon's integrated server in single player and LAN, and the dedicated - server. Vanilla clients can join if the mod only uses vanilla content - (rules, commands, events). +- **Server mods** (`side = "server"`, API 0.3) run where the world is + simulated: single player's server thread (or the window, in-frame), a LAN + host and the dedicated server ([Server mods](#server-mods-api-03-experimental)). + They use only vanilla messages, so any client, vanilla or Horizon, can join. - **Both** (`side = "both"`): a server mod with a client half (new blocks, their textures, a custom screen). On join the Horizon server announces its mods (id, version, SHA-256) on a `horizon:mods` custom payload channel; a From 97e78e0f11565ab89a7017b82784a56e4e47431a Mon Sep 17 00:00:00 2001 From: some-du6e <103129948+some-du6e@users.noreply.github.com> Date: Sun, 25 Oct 2026 17:22:32 -0600 Subject: [PATCH 03/62] horizon-prepare: find 26.3 in ATLauncher's and the CurseForge app's folders ATLauncher saves Mojang's version JSON as is in configs/json/minecraft and the client jar as the library net.minecraft:client:, with the libraries at their version JSON paths and the assets and Java runtimes in Mojang's layouts. horizon-prepare now reads that layout, in the chosen folder, the launcher above a chosen instances/ folder, or, with no folder chosen, ATLauncher's default folder on each system after the official launcher's, then the CurseForge app's Install folder. The lock's pins gate it as before, and nothing is downloaded. The error names every folder looked in and the launchers Horizon reads. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-prepare/src/artifacts.rs | 275 +++++++++++++++++++++--- crates/horizon-prepare/src/lib.rs | 2 +- crates/horizon-prepare/src/sounds.rs | 20 +- 3 files changed, 258 insertions(+), 39 deletions(-) diff --git a/crates/horizon-prepare/src/artifacts.rs b/crates/horizon-prepare/src/artifacts.rs index 805dd80d4..1348361de 100644 --- a/crates/horizon-prepare/src/artifacts.rs +++ b/crates/horizon-prepare/src/artifacts.rs @@ -1,5 +1,5 @@ //! The player's own game files: the pinned version JSON, client jar and libraries from their -//! official launcher install, and the server jar they downloaded, each checked against +//! official launcher or ATLauncher install, and the server jar they downloaded, each checked against //! research-lock.json before it is copied to `.local/minecraft/` (tools/lab.py's //! `prepare`, which the Python preparer ran first), then checked again on every run //! (tools/test_rust_parity.py's `verify_artifacts`). @@ -12,9 +12,10 @@ use std::path::{Component, Path, PathBuf}; const LAUNCHER_HINT: &str = "Horizon does not download the game: play {version} once in the launcher you play \ -Minecraft Java Edition with (the official launcher, Prism Launcher, MultiMC...) so it downloads \ -the game's files, then rerun. If that launcher keeps them in another folder, pass \ ---minecraft-dir or set HORIZON_MINECRAFT_DIR."; +Minecraft Java Edition with so it downloads the game's files, then rerun. Horizon reads the \ +official launcher's folder, ATLauncher's and the CurseForge app's; for Prism Launcher, MultiMC, \ +the Modrinth App or GDLauncher, prepare from the Horizon launcher, which finds their files. If your launcher keeps \ +them in another folder, pass --minecraft-dir or set HORIZON_MINECRAFT_DIR."; const SERVER_HINT: &str = "Horizon does not download the game: download the {version} server jar yourself (minecraft.net/download/server \ while {version} is the current release, otherwise the downloads.server.url in your launcher's \ versions/{version}/{version}.json), then pass --server-jar PATH or set HORIZON_SERVER_JAR."; @@ -23,11 +24,6 @@ fn hint(text: &str, version: &str) -> String { text.replace("{version}", version) } -/// What to do when the player's launcher install lacks the pinned version's files. -pub(crate) fn launcher_hint(version: &str) -> String { - hint(LAUNCHER_HINT, version) -} - /// research-lock.json and the folder the pinned version's files go to. pub struct Lock { pub json: Value, @@ -134,6 +130,134 @@ pub fn minecraft_dir(chosen: Option<&Path>) -> PathBuf { } } +/// One launcher's copy of the pinned version: its version JSON (Mojang's file, checked by its +/// sha1), the client jar, and the folder holding its `libraries` (at the version JSON's paths) +/// and `assets`. +pub struct GameFiles { + pub folder: PathBuf, + pub manifest: PathBuf, + pub client: PathBuf, + /// Mojang's Java runtimes the launcher downloaded (java::minecraft_runtimes). + pub runtimes: PathBuf, + /// The folders looked in, each with its launcher, when none held the version. + searched: Vec<(&'static str, PathBuf)>, +} + +impl GameFiles { + /// What to do when these files are missing, with the folders looked in. + pub(crate) fn hint(&self, version: &str) -> String { + let mut text = hint(LAUNCHER_HINT, version); + if !self.searched.is_empty() { + text += &format!(" Horizon looked for {version} in:"); + for (launcher, folder) in &self.searched { + text += &format!("\n {} ({launcher})", folder.display()); + } + } + text + } +} + +/// The layouts horizon-prepare reads in `folder`: the official launcher's, then ATLauncher's, +/// which saves Mojang's version JSON as is in `configs/json/minecraft` and the client jar as +/// the library `net.minecraft:client:` (its `InstanceInstaller`). +fn layouts(folder: &Path, version: &str) -> [GameFiles; 2] { + let files = |manifest: String, client: String, runtimes: &str| GameFiles { + folder: folder.to_path_buf(), + manifest: folder.join(manifest), + client: folder.join(client), + runtimes: folder.join(runtimes), + searched: Vec::new(), + }; + let v = version; + [ + files( + format!("versions/{v}/{v}.json"), + format!("versions/{v}/{v}.jar"), + "runtime", + ), + files( + format!("configs/json/minecraft/{v}.json"), + format!("libraries/net/minecraft/client/{v}/client-{v}.jar"), + "runtimes/minecraft", + ), + ] +} + +/// The launchers whose folders are looked in when none is chosen: the official launcher's +/// (`minecraft_dir`), ATLauncher's, then the CurseForge app's `Install` folder, where it runs +/// the official launcher (its default modding folder, `curseforge/minecraft`, is in the home +/// folder on Windows and in Documents elsewhere). ATLauncher keeps its files in its working folder: +/// where its Windows installer puts it, inside the macOS app, and the folders its Linux +/// packages and Flatpak start it in. +fn launcher_folders() -> Vec<(&'static str, PathBuf)> { + let mut folders = vec![("the official launcher", minecraft_dir(None))]; + let atlauncher: Vec = if cfg!(target_os = "macos") { + let app = Path::new("Applications/ATLauncher.app/Contents/Java"); + vec![Path::new("/").join(app), home().join(app)] + } else if cfg!(windows) { + std::env::var_os("APPDATA") + .map(|d| PathBuf::from(d).join("ATLauncher")) + .into_iter() + .collect() + } else { + let data = std::env::var_os("XDG_DATA_HOME") + .filter(|d| !d.is_empty()) + .map_or_else(|| home().join(".local/share"), PathBuf::from); + vec![ + data.join("atlauncher"), + home().join(".var/app/com.atlauncher.ATLauncher/data"), + ] + }; + folders.extend(atlauncher.into_iter().map(|dir| ("ATLauncher", dir))); + let curseforge = if cfg!(windows) { "" } else { "Documents" }; + folders.push(( + "the CurseForge app", + home().join(curseforge).join("curseforge/minecraft/Install"), + )); + folders +} + +/// The pinned version's files in the chosen folder (`--minecraft-dir`, HORIZON_MINECRAFT_DIR), +/// or the launcher above it when an instance folder (`instances/`) is chosen; with no +/// folder chosen, in the first launcher folder that has them. When none does, the official +/// layout of the first folder is returned, for the errors to name, with the folders looked in. +pub fn game_files(chosen: Option<&Path>, version: &str) -> GameFiles { + let chosen = chosen + .filter(|d| !d.as_os_str().is_empty()) + .map(Path::to_path_buf) + .or_else(|| std::env::var_os("HORIZON_MINECRAFT_DIR").map(PathBuf::from)) + .filter(|d| !d.as_os_str().is_empty()) + .map(|d| expand_user(&d)); + let folders = match chosen { + Some(dir) => { + let launcher = dir + .ancestors() + .find(|a| a.file_name().is_some_and(|n| n == "instances")) + .and_then(Path::parent) + .map(Path::to_path_buf); + let mut folders = vec![("the folder chosen", dir)]; + folders.extend(launcher.map(|dir| ("the launcher above it", dir))); + folders + } + None => launcher_folders(), + }; + // A folder with both files first: a version JSON left without its jar is used, for the + // error to name the jar, only when no folder has both. + let complete = |files: &GameFiles| files.manifest.is_file() && files.client.is_file(); + let partial = |files: &GameFiles| files.manifest.is_file(); + for found in [complete, partial] { + let mut all = folders + .iter() + .flat_map(|(_, folder)| layouts(folder, version)); + if let Some(files) = all.find(found) { + return files; + } + } + let [mut files, _] = layouts(&folders[0].1, version); + files.searched = folders; + files +} + /// Copy one file from the player's install, checked like a download; an existing verified /// copy is kept. pub(crate) fn import_copy( @@ -170,17 +294,14 @@ pub(crate) fn import_copy( Ok(destination.to_path_buf()) } -/// The pinned version JSON from the launcher's versions/ directory. The launcher's copy wins -/// over the cached one so the manifest matches the asset index installed alongside it. -pub(crate) fn import_manifest(lock: &Lock, minecraft: &Path) -> Result { +/// The pinned version JSON from the launcher's install. The launcher's copy wins over the +/// cached one so the manifest matches the asset index installed alongside it. +pub(crate) fn import_manifest(lock: &Lock, files: &GameFiles) -> Result { let version = &lock.version; let destination = lock.directory.join("manifest.json"); - let source = minecraft - .join("versions") - .join(version) - .join(format!("{version}.json")); + let source = &files.manifest; if source.is_file() { - let manifest = read_json(&source)?; + let manifest = read_json(source)?; let downloads = manifest.get("downloads"); let sha1 = |side: &str| { downloads @@ -197,7 +318,7 @@ pub(crate) fn import_manifest(lock: &Lock, minecraft: &Path) -> Result Result, log: Log, ) -> Result<(), String> { - let minecraft = minecraft_dir(minecraft); - let version = &lock.version; - let manifest = import_manifest(lock, &minecraft)?; + let files = game_files(minecraft, &lock.version); + let minecraft = &files.folder; + let manifest = import_manifest(lock, &files)?; let client = import_copy( - &minecraft - .join("versions") - .join(version) - .join(format!("{version}.jar")), + &files.client, &lock.directory.join("jars/client.jar"), lock.pin("client_sha1")?, "sha1", - &hint(LAUNCHER_HINT, version), + &files.hint(&lock.version), )?; let downloads = manifest.get("downloads"); if downloads.and_then(|d| d.get("client_mappings")).is_some() @@ -560,7 +678,7 @@ pub fn import( for (name, artifact) in client_library_artifacts(&manifest)? { let (path, sha1) = artifact_fields(artifact)?; let relative = safe_relative(path).ok_or("Unsafe library path")?; - let source = launcher_library(&minecraft, name, &relative); + let source = launcher_library(minecraft, name, &relative); let destination = lock.directory.join("libraries/client").join(&relative); if runs_without(name) && !source.is_file() && !destination.exists() { log(&format!( @@ -574,7 +692,7 @@ pub fn import( &destination, sha1, "sha1", - &hint(LAUNCHER_HINT, version), + &files.hint(&lock.version), )?); } write_import_metadata( @@ -1208,6 +1326,103 @@ mod tests { assert!(prepare().unwrap_err().starts_with("Missing ")); } + /// ATLauncher keeps Mojang's version JSON in `configs/json/minecraft` and the client jar as + /// a library; its folder, or one of its instances, prepares like the official launcher's, + /// with the same pins. + #[test] + fn an_atlauncher_install_prepares() { + let fixture = Imports::new(); + let old = fixture.imported(&fixture.source); + let atlauncher = fixture.directory.join("ATLauncher"); + let put = |path: &str, data: &[u8]| { + let path = atlauncher.join(path); + fs::create_dir_all(path.parent().unwrap()).unwrap(); + fs::write(path, data).unwrap(); + }; + let client = fs::read(old.join("jars/client.jar")).unwrap(); + put("libraries/net/minecraft/client/9.9/client-9.9.jar", &client); + put("libraries/client.jar", b"client library"); + put("instances/Minecraft99/instance.json", b"{}"); + // A version JSON left without its jar does not hide the launcher's complete copy. + put("instances/Minecraft99/versions/9.9/9.9.json", b"{}"); + let manifest = fs::read_to_string(old.join("manifest.json")).unwrap(); + let manifest = manifest.replacen('{', r#"{"javaVersion":{"majorVersion":25},"#, 1); + put("configs/json/minecraft/9.9.json", manifest.as_bytes()); + let pinned = digest(&atlauncher.join("configs/json/minecraft/9.9.json"), "sha1").unwrap(); + let lock_path = fixture.target.join("research-lock.json"); + let text = fs::read_to_string(&lock_path).unwrap(); + let old_sha1 = digest(&old.join("manifest.json"), "sha1").unwrap(); + fs::write(&lock_path, text.replace(&old_sha1, &pinned)).unwrap(); + let lock = Lock::read(&fixture.target).unwrap(); + let server = old.join("jars/server.jar"); + let prepare = |dir: &Path| { + let _ = fs::remove_dir_all(&lock.directory); + import(&fixture.target, &lock, Some(dir), Some(&server), &|_| {}) + }; + + for chosen in [atlauncher.clone(), atlauncher.join("instances/Minecraft99")] { + prepare(&chosen).unwrap(); + let artifacts = verify(&lock).unwrap(); + assert_eq!(fs::read(&artifacts.jars["client"]).unwrap(), client); + assert_eq!( + client_libraries(&lock, &artifacts.manifest).unwrap().len(), + 1 + ); + } + let files = game_files(Some(&atlauncher), "9.9"); + assert_eq!(files.runtimes, atlauncher.join("runtimes/minecraft")); + + // The pins gate it as they gate the official layout. + put( + "libraries/net/minecraft/client/9.9/client-9.9.jar", + b"other", + ); + assert!(prepare(&atlauncher) + .unwrap_err() + .contains("is not the pinned file")); + put("libraries/net/minecraft/client/9.9/client-9.9.jar", &client); + put( + "configs/json/minecraft/9.9.json", + manifest.replace(',', ", ").as_bytes(), + ); + assert!(prepare(&atlauncher) + .unwrap_err() + .contains("does not know yet")); + } + + /// With no launcher's files in the chosen folder, the error names where Horizon looked and + /// the launchers it reads. + #[test] + fn the_error_names_the_folders_looked_in() { + let fixture = Imports::new(); + let empty = fixture.directory.join("instances/empty"); + fs::create_dir_all(&empty).unwrap(); + let lock = Lock::read(&fixture.target).unwrap(); + let error = import(&fixture.target, &lock, Some(&empty), None, &|_| {}).unwrap_err(); + assert!(error.starts_with(&format!( + "Missing {}", + empty.join("versions/9.9/9.9.json").display() + ))); + assert!(error.contains("Horizon looked for 9.9 in:"), "{error}"); + assert!(error.contains(&format!("\n {} (the folder chosen)", empty.display()))); + assert!(error.contains(&format!( + "\n {} (the launcher above it)", + fixture.directory.display() + ))); + assert!(error.contains("ATLauncher")); + } + + #[test] + fn every_launcher_horizon_reads_is_looked_in() { + let launchers: Vec<_> = launcher_folders() + .into_iter() + .map(|(name, _)| name) + .collect(); + for name in ["the official launcher", "ATLauncher", "the CurseForge app"] { + assert!(launchers.contains(&name), "{name}"); + } + } + #[test] fn runs_without_only_netty_native_transports() { assert!(runs_without( diff --git a/crates/horizon-prepare/src/lib.rs b/crates/horizon-prepare/src/lib.rs index c7e443c7d..912fc4a9d 100644 --- a/crates/horizon-prepare/src/lib.rs +++ b/crates/horizon-prepare/src/lib.rs @@ -407,7 +407,7 @@ pub fn prepare(options: &Options, log: Log) -> Result { // Java first: nothing below can finish without it, and the player should hear it at once. let mut homes: Vec = options.java_home.iter().cloned().collect(); homes.extend(java::minecraft_runtimes( - &artifacts::minecraft_dir(options.minecraft_dir.as_deref()).join("runtime"), + &artifacts::game_files(options.minecraft_dir.as_deref(), &lock.version).runtimes, )); let jdk = java::find(lock.java_major, &homes)?; if options.import && !artifacts::reuse_imported(root, log)? { diff --git a/crates/horizon-prepare/src/sounds.rs b/crates/horizon-prepare/src/sounds.rs index 15d4a7a08..2de43fe17 100644 --- a/crates/horizon-prepare/src/sounds.rs +++ b/crates/horizon-prepare/src/sounds.rs @@ -1,5 +1,5 @@ //! The pinned version's sounds, title panorama, Unifont glyphs and built-in resource packs -//! from the player's own official launcher install, each object checked against the asset index's SHA-1, copied into +//! from the player's own launcher install, each object checked against the asset index's SHA-1, copied into //! `.local/horizon-client//assets` where the game reads them (tools/fetch_sounds.py and //! the tools/lab.py functions it called). Nothing is downloaded. @@ -17,10 +17,10 @@ use std::path::{Path, PathBuf}; fn launcher_assets( lock: &Lock, manifest: &Value, - minecraft: &Path, + files: &artifacts::GameFiles, log: Log, ) -> Result<(PathBuf, PathBuf), String> { - let assets = minecraft.join("assets"); + let assets = files.folder.join("assets"); let info = manifest .get("assetIndex") .ok_or("The version JSON has no assetIndex")?; @@ -39,7 +39,7 @@ fn launcher_assets( return Err(format!( "Missing {}. {}", index.display(), - artifacts::launcher_hint(version) + files.hint(version) )); } let checksum = digest(&index, "sha1")?; @@ -208,9 +208,9 @@ fn copy_assets( required: &[&str], ) -> Result { let lock = Lock::read(root)?; - let minecraft = artifacts::minecraft_dir(minecraft); - let manifest = artifacts::import_manifest(&lock, &minecraft)?; - let (store, index) = launcher_assets(&lock, &manifest, &minecraft, log)?; + let files = artifacts::game_files(minecraft, &lock.version); + let manifest = artifacts::import_manifest(&lock, &files)?; + let (store, index) = launcher_assets(&lock, &manifest, &files, log)?; let id = manifest .get("id") .and_then(Value::as_str) @@ -566,7 +566,11 @@ mod tests { for missing in ["store", "install", "last-object"] { let f = Fixture::new(&format!("optional-panorama-{missing}")); // The JARs and manifest were imported earlier; the launcher need not remain. - artifacts::import_manifest(&Lock::read(&f.root).unwrap(), &f.minecraft).unwrap(); + artifacts::import_manifest( + &Lock::read(&f.root).unwrap(), + &artifacts::game_files(Some(&f.minecraft), "9.9"), + ) + .unwrap(); let target = f.root.join(".local/horizon-client/9.9/assets"); for name in PANORAMA { let path = target.join(name); From 920a728989a59e1ea36c2309ba8e0aca8d6ad9a4 Mon Sep 17 00:00:00 2001 From: socksprox Date: Mon, 26 Oct 2026 00:56:00 +0100 Subject: [PATCH 04/62] World text parity: same-frame glyph uploads, display lines, name-tag colours Atlas patches rasterized while building world text (display text, name tags, sign glyphs, map items) drained into the HUD batch before entity_geometry ran, uploading a frame late: for that frame the quads sampled unwritten atlas cells, so text flickered or showed the wrong glyphs whenever content changed or new text entered view. Display text also lined up 10 px apart where vanilla's lineHeight is 9, its background quad stopped a pixel short of vanilla's -1..width+1 fill, and name tags used 0x7F where renderNameTag's colours are 0x20FFFFFF (discrete) and 0x80FFFFFF (see-through). lightCoordsWithEmission floors only the block channel at 2 and leaves the sky alone, and a discrete name's background draws lit in the normal pass rather than unlit. Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- crates/horizon-client/src/game.rs | 6 +++-- crates/horizon-client/src/game/names.rs | 26 +++++++++++++------ .../horizon-client/src/game/text_displays.rs | 8 +++--- 3 files changed, 26 insertions(+), 14 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1e6158bc4..e40b93586 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -10090,8 +10090,6 @@ impl Game<'_> { Vec::new() }; let mut hud = horizon_client::spans::time("hud", || self.hud(size)); - // Map textures changed since the last drawn frame (game/maps.rs). - hud.patches.append(&mut self.map_patches); // LevelLoadingScreen (Reason.OTHER) draws the title's panorama. let title = self.title.is_some() || self.loading_reason() == Some(horizon_client::level_loading::Reason::Other); @@ -10193,6 +10191,10 @@ impl Game<'_> { } else { self.shader_pack_inputs(camera, alpha as f32) }; + // Map textures and font glyphs changed while building this frame's + // geometry (game/maps.rs, world text) upload with this batch; draining + // map_patches any earlier leaves them a frame behind. + hud.patches.append(&mut self.map_patches); let frame = Frame { weather: &weather, weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32), diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index 7655fb489..d62e064f7 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -252,17 +252,27 @@ impl Game<'_> { out: &mut Vec, see_through: &mut Vec, ) { - // The text alpha that goes with getBackgroundOpacity(0.25): - // max((0.25 + 0.75) / 2, 0.5), as ARGB.color (the floor of 255 times it). - const FADED: u32 = 0x7F; + // renderNameTag's text colours: a discrete name's faded 0x20FFFFFF, + // the see-through copy's 0x80FFFFFF. + const DISCRETE: u32 = 0x20; + const FADED: u32 = 0x80; for tag in self.name_tags(camera, alpha) { let o = tag.at - camera; if tag.discrete { - self.name_tag_quads(o, &tag.lines, FADED, true, 0, vertex_light(tag.light), out); + self.name_tag_quads( + o, + &tag.lines, + DISCRETE, + true, + 0, + vertex_light(tag.light), + out, + ); continue; } - // LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2). - let lit = (tag.light >> 4).max(2) << 4 | (tag.light & 15).max(2); + // LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2): the block + // channel at least 2, the sky channel unchanged. + let lit = (tag.light & 0xF0) | (tag.light & 15).max(2); self.name_tag_quads(o, &tag.lines, 0xFF, false, 0, vertex_light(lit), out); // RenderPipelines.TEXT_SEE_THROUGH: no depth test, no lightmap. self.name_tag_quads(o, &tag.lines, FADED, true, 2, 0, see_through); @@ -270,7 +280,7 @@ impl Game<'_> { } /// The lines of one name tag, `o` from the camera: the text at /// `text_alpha` in its layer, on the translucent black background - /// (unlit, a hair behind) when `background`. + /// (in `text_layer` like the glyphs, a hair behind) when `background`. #[allow(clippy::too_many_arguments)] fn name_tag_quads( &self, @@ -342,7 +352,7 @@ impl Game<'_> { [white.u0, white.v0, white.u1, white.v1], BACKGROUND, true, - 2, + text_layer, ); } let mut x = x0; diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs index f6c946bcc..45191e15e 100644 --- a/crates/horizon-client/src/game/text_displays.rs +++ b/crates/horizon-client/src/game/text_displays.rs @@ -198,7 +198,7 @@ impl Game<'_> { Lines { lines, width } }); let width = *width; - let height = lines.len() as f32 * 10.0 - 1.0; + let height = lines.len() as f32 * 9.0 - 1.0; matrix *= glam::Mat4::from_translation(glam::Vec3::new(1.0 - width / 2.0, -height, 0.0)); let mut batch = HudBatch::new([1, 1]); @@ -212,8 +212,8 @@ impl Game<'_> { atlas, -1.0, -1.0, - width + 1.0, - height + 1.0, + width + 2.0, + height + 2.0, rgba( (bg >> 16) as u8, (bg >> 8) as u8, @@ -233,7 +233,7 @@ impl Game<'_> { atlas, line, x, - i as f32 * 10.0, + i as f32 * 9.0, rgba(255, 255, 255, d.opacity as u8), d.flags & 1 != 0, ); From 467413df5bc20568bc825f65431e322150c6f059 Mon Sep 17 00:00:00 2001 From: DanielGodriNeto Date: Sun, 25 Oct 2026 20:47:24 -0300 Subject: [PATCH 05/62] fix(benchmark): wait for the post-teleport load before measuring wait_loaded declared a scene loaded during the idle second right after a teleport, so village and mountain were measured with 0 chunks. Port the guard from tools/perf_bench.py: counts must change once (or stay full for 5 s) and resident chunks must reach 80% of the view circle. Co-Authored-By: Claude --- crates/horizon-client/src/benchmark.rs | 31 ++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/crates/horizon-client/src/benchmark.rs b/crates/horizon-client/src/benchmark.rs index bcb94589c..12e38e78a 100644 --- a/crates/horizon-client/src/benchmark.rs +++ b/crates/horizon-client/src/benchmark.rs @@ -323,10 +323,15 @@ const QUIET_MESHES_PER_S: f64 = 100.0; /// happened (`tools/perf_bench.py`'s `wait_loaded`). With `status.streaming`, the sections are /// drawn once no stage has held work for half a second: blocks changing after the load (fluids /// settling, random ticks) only remesh in bursts. Without it, meshing has to go quiet. +/// +/// Right after a teleport (and at spawn) the game reports nothing queued and steady counts for over +/// a second before it starts loading: the counts must change once, or stay full for 5 s, and the +/// resident chunks reach [`view_chunks`], before "steady" means loaded. fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result { let deadline = Instant::now() + LOAD_LIMIT; let (mut last, mut changed, mut meshing) = (None, Instant::now(), Instant::now()); let mut previous: Option<(Instant, f64)> = None; + let (mut first, mut moved, began) = (None, false, Instant::now()); while Instant::now() < deadline { let s = control.status(); let now = Instant::now(); @@ -339,6 +344,19 @@ fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result 0 + && resident >= min_chunks + && now - began > Duration::from_secs(5)); + if min_chunks > 0 && (!moved || resident < min_chunks) { + (last, changed, previous, meshing) = (None, now, None, now); + thread::sleep(Duration::from_millis(50)); + continue; + } if last != Some(counts) { (last, changed) = (Some(counts), now); } @@ -370,6 +388,12 @@ fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result u64 { + (0.8 * std::f64::consts::PI * (distance * distance) as f64) as u64 +} + /// Vanilla's yaw facing from `start` to `end`. fn yaw(start: [f64; 3], end: [f64; 3]) -> f64 { (-(end[0] - start[0])).atan2(end[2] - start[2]).to_degrees() @@ -420,6 +444,13 @@ mod tests { assert!(scenes("nether").is_none()); } + #[test] + fn view_chunks_matches_perf_bench() { + assert_eq!(view_chunks(12), 361); + assert_eq!(view_chunks(32), 2573); + assert_eq!(view_chunks(0), 0); + } + #[test] fn yaw_matches_vanilla() { // South (+Z) is 0, west (-X) 90, east (+X) -90. From 258dd8561df05c8493a14d63d4eaa89074bb780b Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 03:34:33 +0300 Subject: [PATCH 06/62] Frames: one scan for breaking progress, and no name formatting per crack `entity_geometry` ran `cracks()` twice per frame: once for the block-entity pass that draws `render_breaking`, once for the overlay near the end of the same function. Each run walked `mining` and the `destroying` map, and formatted `block/destroy_stage_` for every crack it found before looking that string up in the atlas. The list is computed once, at the top of the function, and the passes read it. The ten stage names are a const table, so a crack costs one lookup and no allocation. Nothing between the two passes touches `mining` or `destroying`, which are only read there, so the list the second pass used to rebuild was always identical to the first one. No behaviour change: the same ten sprite names, and a stage above 9 still finds no sprite and skips the crack. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/game.rs | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1e6158bc4..bfc90f1ec 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -6750,6 +6750,9 @@ impl Game<'_> { ) -> Vec { self.prepare_entity_culling(camera); self.prepare_trims(); + // One scan for both passes that draw them (block entities below and the + // overlay near the end of this function). + let cracks = self.cracks(camera); let fire_yaw = if self.camera_type == perspective::CameraType::ThirdPersonFront { self.yaw + 180.0 } else { @@ -6964,7 +6967,7 @@ impl Game<'_> { .block_entity_render() .render(&scene, visible, &mut out); } - for (pos, stage) in self.cracks(camera) { + for &(pos, stage) in &cracks { let state = self.world.block(pos[0], pos[1], pos[2]); self.res .block_entity_render() @@ -7089,7 +7092,7 @@ impl Game<'_> { &mut out, ); // Breaking progress overlays (destroy_stage_0..9): ours and the other players'. - for (pos, stage) in self.cracks(camera) { + for &(pos, stage) in &cracks { let o = (glam::DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])) - camera) .as_vec3(); @@ -7137,6 +7140,20 @@ impl Game<'_> { /// other players' (`renderBlockDestroyAnimation`: within 32 blocks of the camera, the /// furthest progress on each block). fn cracks(&self, camera: glam::DVec3) -> Vec<([i32; 3], [f32; 2])> { + // `destroy_stage_0` .. `destroy_stage_9`: the sprite name by stage, so the + // lookup does not format a string per crack. + const DESTROY_STAGES: [&str; 10] = [ + "block/destroy_stage_0", + "block/destroy_stage_1", + "block/destroy_stage_2", + "block/destroy_stage_3", + "block/destroy_stage_4", + "block/destroy_stage_5", + "block/destroy_stage_6", + "block/destroy_stage_7", + "block/destroy_stage_8", + "block/destroy_stage_9", + ]; let mut stages: Vec<([i32; 3], u32)> = Vec::new(); let mut add = |pos: [i32; 3], stage: u32| match stages.iter_mut().find(|c| c.0 == pos) { Some(c) => c.1 = c.1.max(stage), @@ -7162,11 +7179,8 @@ impl Game<'_> { d.length_squared() <= 1024.0 }) .filter_map(|(pos, stage)| { - let r = self - .gui - .atlas - .sprites - .get(&format!("block/destroy_stage_{stage}"))?; + let name = DESTROY_STAGES.get(stage as usize)?; + let r = self.gui.atlas.sprites.get(*name)?; Some((pos, [r.u0, r.v0])) }) .collect() From 5e2871dbfd892a9d50c185cb5e5cf5b17013114c Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 01:39:30 +0000 Subject: [PATCH 07/62] Show critical-hit particles on server clients Queue successful mob and player crit animations until the hub can send them to the attacker and tracking clients. Cover falling, grounded and refused attacks in both host modes. Fixes #1898. Co-Authored-By: OpenCode (agentrouter/gpt-6.1-sol) --- crates/horizon-client/src/game.rs | 10 ++- crates/horizon-client/src/game/lan.rs | 31 ++++++++ crates/horizon-client/src/game/lan_pvp.rs | 22 ++++++ crates/horizon-client/src/game/levels.rs | 3 + crates/horizon-client/src/lan/containers.rs | 15 ++++ tools/lan_e2e.py | 88 +++++++++++++++++++++ 6 files changed, 165 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f9f2a0363..f34eef456 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1555,6 +1555,8 @@ struct Game<'a> { /// position) for the guests. lan_block_events: Vec<([i32; 3], i32, i32, u32)>, lan_entity_events: Vec<(i32, i8, [f64; 3])>, + /// Successful crits (attacking guest, hit entity), queued while the hub is taken. + lan_critical_hits: Vec<(Option, i32)>, /// Global level events for every guest (`ServerLevel.globalLevelEvent`). lan_global_events: Vec<(i32, [i32; 3], i32)>, /// `ContainerOpenersCounter`: how many players (the host and the guests) @@ -7437,10 +7439,9 @@ impl Game<'_> { self.stats .custom("damage_dealt", (actual * 10.0).round() as i32); if crit { - self.particles.tracking_emitter( - horizon_client::particles::ParticleOptions::simple( - horizon_client::particles::ParticleType::Crit, - ), + self.critical_hit( + self.lan_acting, + self.mobs[index].id as i32, feet, width, height, @@ -12118,6 +12119,7 @@ impl<'a> Game<'a> { lan_events: Vec::new(), lan_block_events: Vec::new(), lan_entity_events: Vec::new(), + lan_critical_hits: Vec::new(), lan_global_events: Vec::new(), lid_openers: HashMap::new(), lan_acting: None, diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index ee7477f28..e2b853b07 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -634,6 +634,7 @@ impl Game<'_> { self.world.light_log = None; self.audio.capture = None; self.lan_events.clear(); + self.lan_critical_hits.clear(); self.streaming.extra.clear(); if announce { self.system_message(Text::translate( @@ -1162,8 +1163,30 @@ impl Game<'_> { self.lan_entity_events.push((id, event, at)); } } + /// `ServerPlayer.crit`: this window's emitter, and an animation for the + /// attacker's client and observers once the hub is back in place. + pub(super) fn critical_hit( + &mut self, + attacker: Option, + id: i32, + feet: [f64; 3], + width: f64, + height: f64, + ) { + use horizon_client::particles::{ParticleOptions, ParticleType}; + self.particles.tracking_emitter( + ParticleOptions::simple(ParticleType::Crit), + feet, + width, + height, + ); + if self.audio.capture.is_some() { + self.lan_critical_hits.push((attacker, id)); + } + } /// Send the tick's level events, sounds and mob animations. fn lan_flush_effects(&mut self, host: &mut LanHost) { + let critical_hits = std::mem::take(&mut self.lan_critical_hits); for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) { if kind == 2001 { host.broken @@ -1236,6 +1259,14 @@ impl Game<'_> { seen.insert(m.id, (m.hurt_time, dead, swing)); } host.mob_state.insert(self.dim, seen); + for (attacker, target) in critical_hits { + let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| { + host.hub.guest(conn).map(|g| g.entity_id) + }) else { + continue; + }; + host.hub.critical_hit(attacker, target); + } } /// Keep the chunks around every guest loaded. diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index 467c4537c..c7c6b6525 100644 --- a/crates/horizon-client/src/game/lan_pvp.rs +++ b/crates/horizon-client/src/game/lan_pvp.rs @@ -32,6 +32,8 @@ pub(super) enum Victim { /// The attacker's side of the hit. pub(super) struct Strike { + /// The attacking guest, kept after their turn through `as_guest` ends. + attacker: Option, amount: f32, scale: f32, crit: bool, @@ -119,6 +121,7 @@ impl Game<'_> { } self.swing_arm(); Some(Strike { + attacker: self.lan_acting, amount, scale, crit, @@ -250,6 +253,25 @@ impl Game<'_> { Victim::Host => land(self), Victim::Guest(conn) => self.guest_struck_by(host, conn, land).unwrap_or(false), }; + if hurt && s.crit { + let target = match victim { + Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)), + Victim::Guest(conn) => host + .hub + .guest(conn) + .and_then(|g| g.motion.as_deref().map(|p| (g.entity_id, p))), + }; + if let Some((id, p)) = target { + let d = p.dimensions; + self.critical_hit( + s.attacker, + id, + [p.position.x, p.position.y, p.position.z], + f64::from(d.width), + f64::from(d.height), + ); + } + } let sound = match (hurt, s.crit, s.scale > 0.9) { (false, ..) => "minecraft:entity.player.attack.nodamage", (true, true, _) => "minecraft:entity.player.attack.crit", diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs index 588f425a4..65bf4940f 100644 --- a/crates/horizon-client/src/game/levels.rs +++ b/crates/horizon-client/src/game/levels.rs @@ -73,6 +73,7 @@ pub(super) struct Parked { lan_events: Vec<(i32, [i32; 3], i32, Option)>, lan_block_events: Vec<([i32; 3], i32, i32, u32)>, lan_entity_events: Vec<(i32, i8, [f64; 3])>, + lan_critical_hits: Vec<(Option, i32)>, /// Only the per-level parts of these are used (`swap_level`). anims: BlockEntityAnims, raiding: Raiding, @@ -150,6 +151,7 @@ impl Game<'_> { lan_events: Vec::new(), lan_block_events: Vec::new(), lan_entity_events: Vec::new(), + lan_critical_hits: Vec::new(), anims: Default::default(), raiding: Default::default(), sculk: Default::default(), @@ -197,6 +199,7 @@ impl Game<'_> { swap(&mut self.lan_events, &mut p.lan_events); swap(&mut self.lan_block_events, &mut p.lan_block_events); swap(&mut self.lan_entity_events, &mut p.lan_entity_events); + swap(&mut self.lan_critical_hits, &mut p.lan_critical_hits); let (a, b) = (&mut self.be_anims, &mut p.anims); swap(&mut a.chests, &mut b.chests); swap(&mut a.books, &mut b.books); diff --git a/crates/horizon-client/src/lan/containers.rs b/crates/horizon-client/src/lan/containers.rs index 7e150e7bd..002f95cbb 100644 --- a/crates/horizon-client/src/lan/containers.rs +++ b/crates/horizon-client/src/lan/containers.rs @@ -120,6 +120,21 @@ impl Hub { ); } + /// `ServerPlayer.crit`: send the victim's animation to the players tracking + /// the attacker and the attacker themselves (`sendToTrackingPlayersAndSelf`). + pub fn critical_hit(&self, attacker: i32, target: i32) { + let body = C::Animate(play::Animate { + id: target, + action: 1, + }) + .encode(); + for g in self.guests.iter().filter(|g| { + self.here(g) && (g.entity_id == attacker || g.tracker.is_tracking(attacker)) + }) { + g.sender.send(body.clone()); + } + } + /// `ServerLevel.broadcastDamageEvent`: the clients around show the hurt /// entity's flash and hear its hurt sound. pub fn damage_event( diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 0ec7218d8..84e03fe03 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -6398,5 +6398,93 @@ CHECKS += ['sprint-fov'] CHECK_FNS['sprint-fov'] = check_sprint_fov +def check_critical_hits(host, guest, out): + """#1898: a real falling melee hit emits crits on the attacker and observer. + Grounded hits and refused falling hits emit none, against mobs and players. + """ + x, y, z = map(math.floor, pos_of(host)) + target = [x + 2.5, y, z + 0.5] + tag = 'critical_hit_particles' + seen = {} + host('command', command=f'fill {x - 3} {y - 1} {z - 3} {x + 6} {y - 1} {z + 6} minecraft:stone') + host('command', command=f'fill {x - 3} {y} {z - 3} {x + 6} {y + 5} {z + 6} minecraft:air') + host('command', command='time set midnight') + host('command', command='gamerule natural_health_regeneration false') + try: + for label, player, other in (('host', host, guest), ('guest', guest, host)): + for kind in ('zombie', 'player'): + for hit in ('grounded', 'critical', 'refused'): + case = f'{label}-{kind}-{hit}' + for game in (player, other): + game('command', command='gamemode survival') + game('command', command='clear @s') + game('command', command='effect clear @s') + game('command', command='effect give @s minecraft:instant_health 1 5 true') + player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + other_at = target if kind == 'player' else [x + 0.5, y, z + 4.5] + other('command', command=f'tp @s {other_at[0]} {other_at[1]} {other_at[2]}') + host('command', command=f'gamerule pvp {str(hit != "refused").lower()}') + mob_id = None + if kind == 'zombie': + host('command', command=f'summon minecraft:zombie {target[0]} {y} {target[2]} ' + f'{{NoAI:1b,PersistenceRequired:1b,Invulnerable:{int(hit == "refused")}b,Tags:["{tag}"]}}') + player.wait(20) # full attack charge and paired entities + if kind == 'zombie': + mob = next(m for m in player.raw('mobs', 16)['near'] + if m['kind'] == 'minecraft:zombie' and math.dist(m['pos'], target) < 0.1) + mob_id = mob['id'] + assert mob_seen(other, mob_id), f'{case}: observer has not paired the zombie' + health_before = mob_seen(player, mob_id)['health'] if mob_id is not None else hearts(other)[1] + sound = 'minecraft:entity.player.attack.crit' + sounds_before = {side: heard(g, sound) for side, g in (('own', player), ('other', other))} + + def strike(): + if hit != 'grounded': + player.raw('key', 'space', 'down') + player.wait(1) + player.raw('key', 'space', 'up') + body = None + for _ in range(15): + body = player('state')['player'] + # Let the server record the fall before the attack packet. + if not body['on_ground'] and body['velocity'][1] < -0.2: + break + player.wait(1) + assert body and not body['on_ground'] and body['velocity'][1] < -0.2, \ + f'{case}: jump never reached its falling phase: {body}' + player.raw('look-at', target[0], y + 1, target[2]) + player.raw('mouse', 'left', 'click') + + particles = sparked(player, other, ['crit'], strike) + player.shot(out, f'critical-hits-{kind}-{hit}-{label}') + player.wait(10) # finish the three-tick emitter and health replication + health_after = mob_seen(player, mob_id)['health'] if mob_id is not None else hearts(other)[1] + sounds = {side: heard(g, sound) - sounds_before[side] + for side, g in (('own', player), ('other', other))} + seen[case] = {'particles': particles, 'crit_sounds': sounds, + 'health': [health_before, health_after]} + host('command', command=f'kill @e[tag={tag}]') + assert (health_after == health_before) if hit == 'refused' else (health_after < health_before), \ + f'{case}: unexpected damage: {seen[case]}' + assert all(n == int(hit == 'critical') for n in sounds.values()), \ + f'{case}: the server did not recognize the expected crit: {seen[case]}' + wrong = {case: result for case, result in seen.items() + if any((n <= 0 if case.endswith('-critical') else n != 0) + for n in result['particles'].values())} + assert not wrong, f'critical-hit particles: {wrong}' + return seen + finally: + host('command', command=f'kill @e[tag={tag}]') + host('command', command='gamerule pvp true') + host('command', command='gamerule natural_health_regeneration true') + host('command', command='time set day') + for game in (host, guest): + game.raw('key', 'space', 'up') + + +CHECKS += ['critical-hits'] +CHECK_FNS['critical-hits'] = check_critical_hits + + if __name__ == '__main__': main() From 15d99a6856190bc6fe9447a7b5990a9a55a59192 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 02:11:48 +0000 Subject: [PATCH 08/62] Start bat animation clocks on server clients Fixes #2000. Co-Authored-By: OpenCode GPT-6.1 Sol --- .../examples/probe/entity_anim_fixture.rs | 26 ++++--- crates/horizon-client/src/game/lan.rs | 7 ++ crates/horizon-client/src/game/remote.rs | 3 + .../src/game/remote_mob_data.rs | 71 ++++++++++++++++++- crates/horizon-client/src/mobs/bat.rs | 4 ++ .../parity/VanillaEntityAnimOracle.java | 32 ++++++++- tools/test_entity_model_parity.py | 8 +++ 7 files changed, 140 insertions(+), 11 deletions(-) diff --git a/crates/horizon-client/examples/probe/entity_anim_fixture.rs b/crates/horizon-client/examples/probe/entity_anim_fixture.rs index 0a2e2951f..0a3df9e0d 100644 --- a/crates/horizon-client/examples/probe/entity_anim_fixture.rs +++ b/crates/horizon-client/examples/probe/entity_anim_fixture.rs @@ -9,7 +9,7 @@ use horizon_client::mesher::Vertex; use horizon_client::mobs::{ Mob, MobData, MobTypes, Part, Species, allay, anim::{self, Poses, State}, - aquatic, body_anim as b_anim, equine, guardian, + aquatic, bat, body_anim as b_anim, equine, guardian, keyframes::AnimationState, render, shulker, sniffer, species, tame, }; @@ -108,6 +108,22 @@ fn entity_state(mob: &mut Mob, species: Species, case: &Value) { let flag = |k: &str| case[k].as_bool().unwrap_or(false); let num = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32; match species { + Species::Bat => { + mob.extra.flag = flag("isResting"); + mob.anim.states[0].started = case["flyAnimationState"].as_f64().map(|v| v as f32); + mob.anim.states[1].started = case["restAnimationState"].as_f64().map(|v| v as f32); + if let Some(ticks) = case["@batTicks"].as_array() { + for (i, flags) in ticks.iter().enumerate() { + mob.age = i as u32 + 1; + bat::set_resting(mob, flags.as_i64().unwrap_or(0) & 1 != 0); + if flag("@batInFrame") { + bat::tick(mob); + } else { + bat::setup_animation_states(mob); + } + } + } + } Species::Sheep => mob.extra.anim_ticks = num("eatTick") as i32, Species::Guardian | Species::ElderGuardian => { mob.anim.v[guardian::TAIL] = num("tailAnimation"); @@ -456,14 +472,6 @@ pub fn main() -> horizon_client::Result<()> { roll_amount: num("rollAmount"), }, ), - Species::Bat => b_anim::bat( - p, - s, - flag("isResting"), - &started("flyAnimationState"), - &started("restAnimationState"), - &animations, - ), Species::Armadillo => b_anim::armadillo( p, s, diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 50fa222e6..7e66a1e35 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -194,6 +194,13 @@ fn mob_meta( let e = &m.extra; let id = |registry: &str, name: &str| hub.registry_id(registry, &format!("minecraft:{name}")); match kind { + // Bat.DATA_ID_FLAGS: resting in bit 0, flying by default. + "minecraft:bat" => { + if e.flag { + meta.push((16, serializer::BYTE, Value::Byte(1))); + } + defaults.push((16, serializer::BYTE, Value::Byte(0))); + } // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 when sheared. "minecraft:sheep" => { let value = (e.color & 15) | if e.sheared { 16 } else { 0 }; diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 2d5ee9dc1..7850df1f7 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3444,6 +3444,9 @@ impl Game<'_> { if m.species() == horizon_client::mobs::Species::Rabbit { horizon_client::mobs::rabbit::post_tick(m); } + if m.species() == horizon_client::mobs::Species::Bat { + horizon_client::mobs::bat::setup_animation_states(m); + } } for o in self.orbs.iter_mut().filter(|_| running) { o.previous = o.position; diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index da786c1b9..6fde27e52 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -4,7 +4,7 @@ //! own simulation, which a client of a server doesn't run. use super::Game; use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; -use horizon_client::mobs::{Mob, Species, tame}; +use horizon_client::mobs::{Mob, Species, bat, tame}; use horizon_protocol::entity_data::Value; use horizon_protocol::registry::Builtin; @@ -46,6 +46,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin) { _ => {} } match (species, *index, value) { + // Bat.DATA_ID_FLAGS: resting in bit 0. + (Species::Bat, 16, Value::Byte(flags)) => bat::set_resting(m, flags & 1 != 0), // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 sheared. (Species::Sheep, 18, Value::Byte(wool)) => { m.extra.color = (*wool & 15) as u8; @@ -121,6 +123,10 @@ pub(super) fn client_defaults(m: &mut Mob) { if matches!(m.species(), Species::Wolf | Species::Cat) { m.extra.color = tame::RED; } + if m.species() == Species::Bat { + // Bat's constructor sets resting only on the server; the data default is 0. + bat::set_resting(m, false); + } } #[cfg(test)] @@ -169,6 +175,69 @@ mod tests { assert!(!calf.is_baby()); } + #[test] + fn bat_flags_select_continuous_client_clocks_without_changing_motion() { + use horizon_client::mobs::{MobTypes, anim, keyframes::Animation}; + use horizon_core::geometry::Vec3; + use serde_json::json; + use std::{collections::HashMap, fs, sync::Arc}; + + // Original minimal resources keep this regression runnable without vanilla data. + let root = + std::env::temp_dir().join(format!("horizon-bat-animation-{}", std::process::id())); + fs::create_dir(&root).unwrap(); + fs::write(root.join("entity-types.json"), r#"{"minecraft:bat": {}}"#).unwrap(); + fs::write( + root.join("entity-models.json"), + r#"{"minecraft:bat#main": {"children": {"right_wing": {}, "head": {}}}}"#, + ) + .unwrap(); + let mut types = MobTypes::load(&root).unwrap(); + fs::remove_dir_all(root).unwrap(); + let position = Vec3::new(1.0, 2.25, 3.0); + let velocity = Vec3::new(0.2, 0.3, 0.4); + let mut m = Mob::new( + 1, + Arc::new(types.types.remove("minecraft:bat").unwrap()), + position, + 0.0, + ); + assert!(bat::resting(&m)); + client_defaults(&mut m); + assert!(!bat::resting(&m)); + m.velocity = velocity; + m.age = 1; + bat::setup_animation_states(&mut m); + m.age = 4; + apply(&mut m, &[(16, s::BYTE, Value::Byte(2))]); + bat::setup_animation_states(&mut m); + assert_eq!(m.anim.states[0].started, Some(1.0)); + + let curve = Animation::parse(&json!({"length": 1, "looping": true, + "bones": {"right_wing": [{"target": "rotation", "keyframes": + [[0,[0,0,0],[0,0,0],"linear"],[1,[0,1,0],[0,1,0],"linear"]]}]}})); + let animations = HashMap::from([("BatAnimation.BAT_FLYING".into(), curve)]); + let wing = |partial| { + let mut poses = anim::Poses::new(&m.kind.model); + anim::setup(&m, &anim::state(&m, partial), &mut poses, &animations); + poses.get("right_wing")[4] + }; + assert!(wing(0.5) > wing(0.0)); + + m.age = 5; + apply(&mut m, &[(16, s::BYTE, Value::Byte(3))]); + bat::setup_animation_states(&mut m); + assert!(bat::resting(&m)); + assert_eq!(m.anim.states[0].started, None); + assert_eq!(m.anim.states[1].started, Some(5.0)); + m.age = 7; + apply(&mut m, &[(16, s::BYTE, Value::Byte(0))]); + bat::setup_animation_states(&mut m); + assert_eq!(m.anim.states[0].started, Some(7.0)); + assert_eq!(m.anim.states[1].started, None); + assert_eq!((m.position, m.velocity), (position, velocity)); + } + #[test] fn a_wolf_takes_its_owner_flags_and_collar() { let Some(mut m) = mob("minecraft:wolf") else { diff --git a/crates/horizon-client/src/mobs/bat.rs b/crates/horizon-client/src/mobs/bat.rs index 9f38e9e60..ca5efa4a2 100644 --- a/crates/horizon-client/src/mobs/bat.rs +++ b/crates/horizon-client/src/mobs/bat.rs @@ -132,6 +132,10 @@ pub fn tick(m: &mut Mob) { } else { m.velocity.y *= 0.6; } + setup_animation_states(m); +} +/// `Bat.setupAnimationStates`: client visuals, without changing server motion. +pub fn setup_animation_states(m: &mut Mob) { let age = m.age as f32; if resting(m) { m.anim.states[0].stop(); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java index dc5f8c8df..9f7a63a67 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java @@ -223,7 +223,9 @@ public final class VanillaEntityAnimOracle { } /** Render-state values vanilla derives from entity state; the case gives the entity-side input. */ - private static void hooks(EntityRenderState state, JsonObject kase) { + private static void hooks(EntityRenderState state, JsonObject kase) throws Exception { + if (state instanceof net.minecraft.client.renderer.entity.state.BatRenderState bat && kase.has("@batTicks")) + batHistory(bat, kase.getAsJsonArray("@batTicks")); if (state instanceof net.minecraft.client.renderer.entity.state.SheepRenderState sheep && kase.has("eatTick")) { // Sheep.getHeadEatPositionScale / getHeadEatAngleScale at partial tick 0. int t = kase.get("eatTick").getAsInt(); @@ -242,6 +244,34 @@ public final class VanillaEntityAnimOracle { phantom.flapTime = kase.get("flapOffset").getAsFloat() + phantom.ageInTicks; } + /** Only the server's flags are supplied; the shipped Bat starts/stops its own clocks. */ + private static final class AnimationBat extends net.minecraft.world.entity.ambient.Bat { + int flags; + AnimationBat() { super(null, null); } + @Override public boolean isResting() { return (flags & 1) != 0; } + } + + private static void batHistory(net.minecraft.client.renderer.entity.state.BatRenderState state, JsonArray ticks) throws Exception { + // Allocate without a world, as the other controlled entity oracles do. + var allocator = Class.forName("sun.misc.Unsafe"); + var field = allocator.getDeclaredField("theUnsafe"); + field.setAccessible(true); + var bat = (AnimationBat) allocator.getMethod("allocateInstance", Class.class).invoke(field.get(null), AnimationBat.class); + var type = net.minecraft.world.entity.ambient.Bat.class; + type.getField("flyAnimationState").set(bat, new net.minecraft.world.entity.AnimationState()); + type.getField("restAnimationState").set(bat, new net.minecraft.world.entity.AnimationState()); + var setup = type.getDeclaredMethod("setupAnimationStates"); + setup.setAccessible(true); + for (var flags : ticks) { + bat.tickCount++; + bat.flags = flags.getAsInt(); + setup.invoke(bat); + } + state.isResting = bat.isResting(); + state.flyAnimationState.copyFrom(bat.flyAnimationState); + state.restAnimationState.copyFrom(bat.restAnimationState); + } + public static void main(String[] args) throws Exception { SharedConstants.tryDetectVersion(); Bootstrap.bootStrap(); diff --git a/tools/test_entity_model_parity.py b/tools/test_entity_model_parity.py index 0cfc509f3..11d3f7cbc 100644 --- a/tools/test_entity_model_parity.py +++ b/tools/test_entity_model_parity.py @@ -276,6 +276,14 @@ def species_cases(layer, base_cases): for extra in SPECIES.get(name, []): for index in (2, 3, 6): yield {**base_cases[index], **extra} + if name == 'bat': + # Entity clocks, rather than injected render clocks: flight, rest, transitions and + # unrelated flag bits. Exercise the in-frame tick and server-client visual update. + for flags in ([0] * 4, [1] * 4, [0, 0, 1, 1, 0, 0], [1, 1, 0, 0, 1, 1], [2, 3, 2, 2]): + for in_frame in (False, True): + for partial in (0.0, 0.5): + yield {**base_cases[0], 'ageInTicks': len(flags) + partial, + '@batTicks': flags, '@batInFrame': in_frame} def compare_vertices(v, r, args, stats): From 4cc134d08a52c94b88bcf4dbbdfee70b14ddde2f Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 02:13:12 +0000 Subject: [PATCH 09/62] Fix passenger walk animation in shared render state Zero passenger walk position and speed like vanilla LivingEntityRenderer, covering local and remote riders. Extend entity model parity with moving passenger and on-foot render-state cases. Fixes #1962 Co-Authored-By: Codex GPT-6.1 Sol --- .../examples/probe/entity_anim_fixture.rs | 22 +++++++++++++++++-- crates/horizon-client/src/mobs/anim.rs | 7 +++--- .../parity/VanillaEntityAnimOracle.java | 13 +++++++++++ tools/test_entity_model_parity.py | 13 +++++++++++ 4 files changed, 50 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/examples/probe/entity_anim_fixture.rs b/crates/horizon-client/examples/probe/entity_anim_fixture.rs index 0a2e2951f..124ddbe03 100644 --- a/crates/horizon-client/examples/probe/entity_anim_fixture.rs +++ b/crates/horizon-client/examples/probe/entity_anim_fixture.rs @@ -377,7 +377,7 @@ pub fn main() -> horizon_client::Result<()> { mob.extra.age = -24000; } mob.age = f("ageInTicks") as u32; - let state = State { + let mut state = State { pos: f("walkAnimationPos"), speed: f("walkAnimationSpeed"), age: f("ageInTicks"), @@ -389,6 +389,20 @@ pub fn main() -> horizon_client::Result<()> { }; let mut poses = Poses::new(&model); entity_state(&mut mob, def.species, case); + if let Some(ticks) = case["@walkTicks"].as_array() { + for speed in ticks { + mob.previous_limb_speed = mob.limb_speed; + mob.limb_speed += (speed.as_f64().unwrap() as f32 - mob.limb_speed) * 0.4; + mob.limb_position += mob.limb_speed; + } + if !case["@alive"].as_bool().unwrap() { + mob.health = 0.0; + } + let extracted = anim::state(&mob, f("@partial")); + state.pos = extracted.pos; + state.speed = extracted.speed; + } + let flag = |k: &str| case[k].as_bool().unwrap_or(false); let num = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32; let started = |k: &str| AnimationState { @@ -590,7 +604,11 @@ pub fn main() -> horizon_client::Result<()> { } _ => anim::setup(&mob, s, p, &animations), } - out.push_str(&format!("{}\n", emit(&model, &mut poses, case, layer))); + let mut result = emit(&model, &mut poses, case, layer); + if case["@walkTicks"].is_array() { + result["walk"] = json!([state.pos, state.speed]); + } + out.push_str(&format!("{result}\n")); } fs::write(&args[2], out)?; Ok(()) diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index b2158132b..8639c8a9b 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -189,14 +189,15 @@ pub fn state(m: &Mob, alpha: f32) -> State { swing += 1.0; } let swing = m.anim.attack_anim_o + swing * alpha; - let alive = m.alive(); + // LivingEntityRenderer.extractRenderState: riding motion is not walking. + let walking = m.alive() && !m.extra.passenger; State { - pos: if alive { + pos: if walking { m.limb_position - m.limb_speed * (1.0 - alpha) } else { 0.0 }, - speed: if alive { + speed: if walking { (m.previous_limb_speed + (m.limb_speed - m.previous_limb_speed) * alpha).min(1.0) } else { 0.0 diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java index dc5f8c8df..80bd0bf14 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java @@ -282,6 +282,19 @@ public final class VanillaEntityAnimOracle { state.getClass(); for (var entry : kase.entrySet()) if (!entry.getKey().startsWith("@")) set(state, entry.getKey(), entry.getValue()); + if (kase.has("@walkTicks")) { + var walk = new net.minecraft.world.entity.WalkAnimationState(); + for (var speed : kase.getAsJsonArray("@walkTicks")) + walk.update(speed.getAsFloat(), 0.4F, 1.0F); + // LivingEntity.calculateEntityAnimation stops passengers/dead entities; + // LivingEntityRenderer.extractRenderState also zeros both fields. + if (kase.get("isPassenger").getAsBoolean() || !kase.get("@alive").getAsBoolean()) + walk.stop(); + float partial = kase.get("@partial").getAsFloat(); + set(state, "walkAnimationPos", gson.toJsonTree(walk.position(partial))); + set(state, "walkAnimationSpeed", gson.toJsonTree(walk.speed(partial))); + result.add("walk", gson.toJsonTree(new float[]{walk.position(partial), walk.speed(partial)})); + } hooks(state, kase); if (state instanceof net.minecraft.client.renderer.entity.state.ArmedEntityRenderState armed && armed.swingAnimation > 0) armed.currentSwing = new net.minecraft.world.entity.LivingEntity.SwingDescription(net.minecraft.world.InteractionHand.MAIN_HAND, net.minecraft.world.item.component.SwingAnimation.DEFAULT, 6); diff --git a/tools/test_entity_model_parity.py b/tools/test_entity_model_parity.py index 0cfc509f3..ca0585bcf 100644 --- a/tools/test_entity_model_parity.py +++ b/tools/test_entity_model_parity.py @@ -164,6 +164,15 @@ def cases(layer, model=None): cases_out = [{**c, **DEFAULTS.get(name, {})} for c in cases_out] yield from cases_out yield from species_cases(layer, cases_out) + # Exercise render-state extraction with a live walk clock, including the + # first mounted frame. Existing setupAnim cases bypass anim::state. + if name == 'skeleton': + for passenger in [False, True]: + for alive in [False, True]: + for partial in [0.0, 0.5, 1.0]: + yield {**cases_out[2], 'isPassenger': passenger, + '@walkTicks': [0.5, 1.0, 0.75], + '@alive': alive, '@partial': partial} part = model and scaled_part(model) if part: for index, scale in enumerate(PART_SCALES): @@ -379,6 +388,10 @@ def main(): skipped.add(layer); continue checked += 1 bad = [] + if 'walk' in v: + for a, b in zip(v['walk'], r['walk']): + if abs(a - b) > args.tolerance * (1.0 + abs(a)): + bad.append(('@walk', f'{v["walk"]} != {r["walk"]}')) for path, expected in v['parts'].items(): got = r['parts'].get(path) if got is None: From 9572330ee4402a5cc68af36e59505a009fdfbfed Mon Sep 17 00:00:00 2001 From: vlesmentie <129341611+vlesmentie@users.noreply.github.com> Date: Sun, 25 Oct 2026 23:24:25 -0300 Subject: [PATCH 10/62] A villager's new profession rolls its trades Villager.setVillagerData sets offers to null when the profession changes, and getOffers rolls the new profession's trades on the next look. set_profession cleared the offers but left unset false, so ensure_offers never rolled new ones: a villager that took a placed workstation after losing its first wore the new profession but only shook its head. It now marks the offers unset, as vanilla's null. Fixes #1998. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/mobs/villager.rs | 68 +++++++++++++++++++++- 1 file changed, 67 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/mobs/villager.rs b/crates/horizon-client/src/mobs/villager.rs index 575fafaed..148034323 100644 --- a/crates/horizon-client/src/mobs/villager.rs +++ b/crates/horizon-client/src/mobs/villager.rs @@ -284,12 +284,14 @@ pub fn xp(m: &Mob) -> i32 { m.extra.trade.as_ref().map_or(0, |t| t.xp) } /// `Villager.setVillagerData(withProfession)`: a new profession forgets the -/// offers. +/// offers (`offers = null`), so the next `getOffers` rolls the new +/// profession's trades. pub fn set_profession(m: &mut Mob, profession: u8) { if m.extra.variant2 != profession { m.extra.variant2 = profession; if let Some(t) = m.extra.trade.as_mut() { t.offers.clear(); + t.unset = true; } } } @@ -846,6 +848,70 @@ pub fn read_nbt(m: &mut Mob, tag: &horizon_world::nbt::Tag) { mod tests { use super::*; + fn villager() -> Mob { + use crate::mobs::{Anim, Brain, Flags, MobType, Part, Species}; + use std::{collections::HashMap, sync::Arc}; + let kind = Arc::new(MobType { + id: "minecraft:villager".into(), + species: Species::Villager, + width: 0.6, + height: 1.95, + eye_height: 1.62, + category: "misc".into(), + max_health: 20.0, + speed: 0.5, + flying_speed: 0.02, + attack_damage: 0.0, + attack_knockback: 0.0, + follow_range: 48.0, + step_height: 0.6, + armor: 0.0, + armor_toughness: 0.0, + knockback_resistance: 0.0, + jump_strength: 0.42, + attributes: Arc::default(), + gravity: 0.08, + safe_fall_distance: 3.0, + fall_damage_multiplier: 1.0, + water_efficiency: 0.0, + water_slowdown: 0.8, + air_speed: 0.02, + baby_scale: 0.5, + head_rot_speed: 10.0, + max_head_x_rot: 40.0, + max_head_y_rot: 75.0, + ambient_interval: 80, + flags: Flags::default(), + model: Arc::new(Part::parse("root", &serde_json::json!({}))), + layers: HashMap::new(), + texture: String::new(), + brain: Brain::Passive, + anim: Anim::Villager, + sounds: [""; 3], + step_sound: None, + food: Arc::default(), + tempt: Arc::default(), + }); + Mob::new(1, kind, horizon_core::geometry::Vec3::ZERO, 0.0) + } + #[test] + fn a_new_profession_rolls_new_offers() { + let mut m = villager(); + set_profession(&mut m, 1); + // Offers made for the first profession. + m.extra.trade.get_or_insert_default().unset = false; + // The same profession keeps them. + set_profession(&mut m, 1); + assert!(!m.extra.trade.as_ref().unwrap().unset); + // A new one forgets them (offers = null), so the next getOffers + // (ensure_offers) rolls the new profession's trades. + set_profession(&mut m, 2); + let t = m.extra.trade.as_ref().unwrap(); + assert!(t.offers.is_empty()); + assert!(t.unset); + assert_eq!(m.extra.variant2, 2); + } + fn stack(item: &str, count: u32) -> ItemStack { ItemStack::new(item, count) } From 51911080f0ef023f347f6133e3a2dc8531c486a4 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 05:58:53 +0300 Subject: [PATCH 11/62] Mob models: one skip lookup per part, not one per polygon Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/mobs/render.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index cb21cec8c..4188c9c85 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -946,7 +946,11 @@ fn draw_normals( return; } let normals = normals.part(p); - for poly in part.polygons.iter().filter(|_| !poses.skips(part)) { + // `skips` is a name lookup: asking once per part, not once per polygon. + if poses.skips(part) { + return; + } + for poly in &part.polygons { let normal = poly.vertex_normal(normals); for v in poly.vertices { let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0); From dcc5899692842530d24647072c6208278bd4e932 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 06:00:36 +0300 Subject: [PATCH 12/62] Name tags: collect the ridden mobs once, not per tag Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/game/names.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index f249bd01f..9ede507e3 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -86,6 +86,10 @@ impl Game<'_> { .iter() .filter_map(|m| Some((m, m.custom_name.clone()?, false))); let players = players.into_iter().map(|(m, name)| (m, name, true)); + // Who is riding whom: asked once per tag below, and rescanning every mob + // for each tag made this quadratic in the number of loaded mobs. + let ridden: std::collections::HashSet = + self.mobs.iter().filter_map(|o| o.extra.mount).collect(); for (m, name, player) in named.chain(players) { if !m.alive() { continue; @@ -134,7 +138,7 @@ impl Game<'_> { invisible_to_viewer: invisible, hud_hidden: self.ui.hide_gui, is_camera: false, - is_vehicle: self.mobs.iter().any(|o| o.extra.mount == Some(m.id)), + is_vehicle: ridden.contains(&m.id), }; // MobRenderer.shouldShowName: a visible name, or the mob under the // crosshair; players (LivingEntityRenderer) need neither. From d41aa95dbd6cde12ed4d6bb78141e91f8c21b28d Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 06:04:06 +0300 Subject: [PATCH 13/62] Mob models: one Poses per mob per frame, not one per equipment layer Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/mobs/anim.rs | 21 ++++++++++++--------- crates/horizon-client/src/mobs/render.rs | 20 ++++++++++++++++---- 2 files changed, 28 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index b2158132b..81faa3a02 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -102,7 +102,7 @@ impl AnimState { pub fn end_tick(&mut self, _swinging: bool) {} } /// Part poses for one draw, keyed by part name. -#[derive(Clone)] +#[derive(Clone, Default)] pub struct Poses { map: HashMap, dummy: [f32; 9], @@ -113,20 +113,23 @@ pub struct Poses { } impl Poses { pub fn new(model: &Part) -> Self { - let mut map = HashMap::new(); + let mut poses = Self::default(); + poses.reset(model); + poses + } + /// Refills this for another model, keeping the map and the sets' capacity: + /// a mob draws its body and every equipment layer each frame. + pub fn reset(&mut self, model: &Part) { fn walk(p: &Part, map: &mut HashMap) { map.insert(p.name.clone(), p.pose); for c in &p.children { walk(c, map); } } - walk(model, &mut map); - Self { - map, - dummy: [0.0; 9], - skipped: Default::default(), - hidden: Default::default(), - } + self.map.clear(); + self.skipped.clear(); + self.hidden.clear(); + walk(model, &mut self.map); } pub fn get(&mut self, name: &str) -> &mut [f32; 9] { match self.map.get_mut(name) { diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index cb21cec8c..5c01f3f2f 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -1089,6 +1089,9 @@ fn render_visible( } } } + // One Poses for every layer: a humanoid with armour redraws five to seven + // models, and each used to allocate its own maps. + let mut layer_poses = Poses::default(); for layer in all_layers { let Some(part) = m.kind.layer(&layer.model).cloned() else { continue; @@ -1096,8 +1099,8 @@ fn render_visible( let Some(uv) = atlas(&layer.texture) else { continue; }; - let mut poses = Poses::new(&part); - anim::setup(m, &s, &mut poses, &data.animations); + layer_poses.reset(&part); + anim::setup(m, &s, &mut layer_poses, &data.animations); if matches!(m.species(), Species::Villager | Species::ZombieVillager) && let Some((folder, variant)) = layer .texture @@ -1108,7 +1111,7 @@ fn render_visible( data.villager_hats .read() .unwrap_or_else(std::sync::PoisonError::into_inner) - .apply(folder, variant, profession, &mut poses); + .apply(folder, variant, profession, &mut layer_poses); } let light = if layer.full_bright { 240 | 240 << 8 @@ -1123,7 +1126,16 @@ fn render_visible( None => overlay, }; let start = out.len(); - draw(&part, base, &poses, uv, layer.color, light, overlay, out); + draw( + &part, + base, + &layer_poses, + uv, + layer.color, + light, + overlay, + out, + ); if layer.full_bright && m.species() != Species::Warden { for vertex in &mut out[start..] { vertex.normal = [0; 4]; From 03a3c48a71bb472ae036561e72f5628b2788649d Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 04:18:54 +0000 Subject: [PATCH 14/62] Fix Peaceful removal of existing hostile mobs Apply the vanilla Mob.checkDespawn Peaceful gate before persistence and player distance checks. Extend the mob AI parity harness with difficulty, persistence, name-tag and NoAI regressions and allowed-type controls. Fixes #1942 Co-Authored-By: OpenAI Codex (GPT-6.1 Sol) --- .../examples/probe/mob_ai_probe.rs | 9 ++++++++- crates/horizon-client/src/mobs/ai.rs | 4 ++++ .../horizonlab/parity/VanillaMobAiOracle.java | 7 +++++++ tools/test_mob_ai_parity.py | 16 ++++++++++++++++ 4 files changed, 35 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index 49f56c250..ecdf02901 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -49,6 +49,7 @@ struct Scenario { name: String, ticks: i32, time: i64, + difficulty: u8, rain: bool, thunder: bool, origin: [i32; 2], @@ -85,11 +86,13 @@ fn parse(text: &str) -> Vec { "scenario" => { s.name = f[1].to_owned(); s.time = 6000; + s.difficulty = 2; for kv in &f[2..] { let (k, v) = kv.split_once('=').unwrap_or((kv, "")); match k { "ticks" => s.ticks = v.parse().unwrap(), "time" => s.time = v.parse().unwrap(), + "difficulty" => s.difficulty = v.parse().unwrap(), "rain" => s.rain = true, "thunder" => s.thunder = true, "levelseed" => {} @@ -954,6 +957,10 @@ pub fn main() -> horizon_client::Result<()> { for flag in &spec.flags { match flag.as_str() { "persistent" => m.persistent = true, + "named" => { + m.custom_name = Some("Peaceful regression".into()); + m.persistent = true; + } "ridden" => { m.extra.head = Some("minecraft:red_harness".into()); m.rider = Some(horizon_client::mobs::equine::Rider::default()); @@ -1090,7 +1097,7 @@ pub fn main() -> horizon_client::Result<()> { block_tags: &items.block_tags, biomes: &biomes, mob_griefing: true, - difficulty: LocalDifficulty::new(2, world.day_time, 0, 0.0), + difficulty: LocalDifficulty::new(s.difficulty, world.day_time, 0, 0.0), end: false, world_seed: 0, // FlatLevelSource.getSeaLevel. diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index c9bc15fda..8335cb745 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -1024,6 +1024,10 @@ fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool { if m.species() == Species::Mannequin { return true; } + // Mob.checkDespawn discards disallowed types even when persistent or NoAI. + if w.difficulty.effective == 0.0 && !super::spawn_rules::allowed_in_peaceful(m.species()) { + return false; + } let Some(p) = w.nearest_player else { return true; }; diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java index eb5235adf..0345a4bc6 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java @@ -159,6 +159,7 @@ public final class VanillaMobAiOracle { static final class Scenario { String name; int ticks; + int difficulty = 2; long time = 6000; boolean rain, thunder; int originX, originZ; @@ -204,6 +205,7 @@ public final class VanillaMobAiOracle { switch (kv[0]) { case "ticks" -> s.ticks = Integer.parseInt(kv[1]); case "time" -> s.time = Long.parseLong(kv[1]); + case "difficulty" -> s.difficulty = Integer.parseInt(kv[1]); case "rain" -> s.rain = true; case "thunder" -> s.thunder = true; case "levelseed" -> s.levelSeed = Long.parseLong(kv[1]); @@ -494,6 +496,7 @@ public final class VanillaMobAiOracle { } void run(Scenario s, ServerLevel level) throws Exception { + this.setDifficulty(net.minecraft.world.Difficulty.byId(s.difficulty), true); out.println("== " + s.name); var clock = level.registryAccess().lookupOrThrow(Registries.WORLD_CLOCK).getOrThrow(WorldClocks.OVERWORLD); this.clockManager().setTotalTicks(clock, s.time); @@ -553,6 +556,10 @@ public final class VanillaMobAiOracle { String v = kv.length > 1 ? kv[1] : ""; switch (kv[0]) { case "persistent" -> mob.setPersistenceRequired(); + case "named" -> { + mob.setCustomName(net.minecraft.network.chat.Component.literal("Peaceful regression")); + mob.setPersistenceRequired(); + } case "ridden" -> mob.setItemSlot(net.minecraft.world.entity.EquipmentSlot.BODY, new net.minecraft.world.item.ItemStack(BuiltInRegistries.ITEM.getValue( net.minecraft.resources.Identifier.parse("minecraft:red_harness")))); diff --git a/tools/test_mob_ai_parity.py b/tools/test_mob_ai_parity.py index 87a7a1403..7aaa597e1 100644 --- a/tools/test_mob_ai_parity.py +++ b/tools/test_mob_ai_parity.py @@ -311,6 +311,22 @@ def scenarios(): add('villager_golem_panic', 100, ['fill -2 -60 -3 4 -60 4 minecraft:oak_fence', 'fill -1 -60 -2 3 -60 3 minecraft:air', 'player 14.5 -60 0.5'] + golem_callers[:3] + ['mob minecraft:zombie 6.5 -60 0.5 90 86 persistent noai'], 'time=18000') + # Mob.checkDespawn removes disallowed types before persistence/NoAI checks. + # Keep the non-Peaceful controls and the allowed hostile/neutral exceptions. + for difficulty in range(4): + for flags in ('', 'persistent', 'named', 'noai', 'persistent noai'): + suffix = flags.replace(' ', '_') or 'ordinary' + add(f'peaceful_zombie_{difficulty}_{suffix}', 1, [ + 'player 6.5 -60 0.5', + f'mob minecraft:zombie 0.5 -60 0.5 0 1 {flags}', + ], f'difficulty={difficulty} time=18000') + for species in ('skeleton', 'creeper', 'slime', 'warden', 'wither', + 'piglin', 'shulker', 'bee', 'wolf', 'iron_golem', 'cow'): + add(f'peaceful_type_{species}', 1, [ + 'player 6.5 -60 0.5', + f'mob minecraft:{species} 0.5 -60 0.5 0 1 persistent noai', + ], 'difficulty=0 time=18000') + return s From bf2961834be7c29a8fe46861d55c82e42d2f82ff Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Mon, 26 Oct 2026 09:52:00 +0500 Subject: [PATCH 15/62] Item cooldowns: tick them on the server client's path too MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review of #1933 (rdbtCVS): `Game::tick` returns through `tick_remote` whenever `remote` is set — every multiplayer session and the default single player — so the `tick_world` call that advanced the entries never ran there. A thrown pearl's slot stayed at full shade until the server's duration-0 packet arrived instead of fading over the second. `tick_remote_level` advances them now (Player.tick's ItemCooldowns.tick); the groups that end are dropped silently, as the client's plain ItemCooldowns does. Co-Authored-By: [CC] --- crates/horizon-client/src/game/remote.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3a2dd1d69..8b3799426 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3170,6 +3170,12 @@ impl Game<'_> { fn tick_remote_level(&mut self) -> Result<()> { self.ticks += 1; self.track_experience_display(); + // Player.tick's ItemCooldowns.tick: this path replaces `tick_world`'s + // for a server's client (multiplayer and the default single player), + // so the entries advance here or the slot stays shaded until the + // server says the entry ended. `onCooldownEnded` is the plain + // ItemCooldowns' no-op on a client. + self.cooldowns.tick(); // Options.broadcastOptions: a changed render distance or Chat option // is sent again. let view = client_view_distance(self.settings.render_distance); From 276f8d49c133df03f05c0670c55b2e59a2aa844a Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Mon, 26 Oct 2026 09:45:40 +0500 Subject: [PATCH 16/62] Chat: a LAN guest's line follows the host's Chat option MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review of #1932 (rdbtCVS): with `--in-frame`, opening a world to LAN and setting Commands Only still showed a guest's ordinary chat on the host. The hub's `HostEvent::Chat` went through `system_message`, which asks for `receive_system_messages` — true at Commands Only — so the line passed. `Game::player_message` shows a chat line as `ChatSource::Player`, which is the permission `ChatListener` checks for player chat; `lan_log_event` routes `HostEvent::Chat` there. `/say` and `/me` arrive as chat messages too (say_command, emote_command), so they follow the same permission as they do for the guests' own packets; command feedback such as `/list` is a system message and keeps the system-message permission. Reproduced on the pre-fix build: host at Commands Only, guest sends `baseline-visible` → the host shows ` baseline-visible`. With this change the same line stays hidden at Commands Only and shows at Shown. Co-Authored-By: [CC] --- crates/horizon-client/src/chat_tests.rs | 30 +++++++++++++++++++++++ crates/horizon-client/src/game/chat.rs | 32 +++++++++++++++++++++++++ crates/horizon-client/src/game/lan.rs | 6 ++++- 3 files changed, 67 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/chat_tests.rs b/crates/horizon-client/src/chat_tests.rs index 6b058c0fb..fa065766c 100644 --- a/crates/horizon-client/src/chat_tests.rs +++ b/crates/horizon-client/src/chat_tests.rs @@ -436,3 +436,33 @@ fn the_chat_option_filters_the_lines_both_ways() { chat.set_abilities(&font, ChatAbilities::new(ChatVisibility::Full)); assert_eq!(shown(&chat), ["client", "server", "player"]); } + +/// The in-frame LAN host's chat: a guest's line is a player message, so the +/// Chat option's player-message permission hides it at Commands Only and +/// Hidden; command feedback (`/say`, `/me`) is a system message and stays. +#[test] +fn a_guests_line_follows_the_player_message_permission() { + let font = font(); + let shown = |visibility, source| { + let mut chat = Chat::default(); + chat.abilities = ChatAbilities::new(visibility); + chat.add_message(&font, Text::literal("line"), None, source, 0, false); + chat.messages.len() + }; + for (visibility, player, system) in [ + (ChatVisibility::Full, 1, 1), + (ChatVisibility::System, 0, 1), + (ChatVisibility::Hidden, 0, 0), + ] { + assert_eq!( + shown(visibility, ChatSource::Player), + player, + "{visibility:?}" + ); + assert_eq!( + shown(visibility, ChatSource::Server), + system, + "{visibility:?}" + ); + } +} diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index 5d3919c8b..be2a318a0 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -481,6 +481,38 @@ impl Game<'_> { self.mods_chat(&line); } } + /// A player's chat line on the window's own chat: a LAN guest's message + /// while the host runs in-frame (`HostEvent::Chat`). `ChatListener` + /// checks `canReceivePlayerMessages` for these, so Commands Only and + /// Hidden drop them; command feedback (`/list`, `/tp`) is a system + /// message and takes the system-message permission instead. + pub(super) fn player_message(&mut self, text: Text) { + if let Some(capture) = self.chat_capture.as_mut() { + capture.push(text); + return; + } + // A server's client receives the line as a packet (PlayerChat or + // DisguisedChat) and filters it there. + if self.remote.is_some() { + return; + } + if !self.ui.chat.shows(ChatSource::Player) { + return; + } + let focused = self.screen == Screen::Chat; + let heard = self.mods.running().then(|| text.plain()); + self.ui.chat.add( + &self.gui.atlas, + text, + None, + ChatSource::Player, + self.ticks, + focused, + ); + if let Some(line) = heard { + self.mods_chat(&line); + } + } /// Keys while the chat screen is open. pub(super) fn chat_key(&mut self, event: &KeyEvent) { if let Some(shortcut) = self.edit_shortcut(event) { diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 50fa222e6..99727b53f 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1403,7 +1403,11 @@ impl Game<'_> { let tag = if secure { "" } else { "[Not Secure] " }; super::dedicated::log("INFO", &format!("{tag}{line}")); } - HostEvent::Chat { line, .. } => self.system_message(Text::literal(line)), + // Player chat (and `/say`'s or `/me`'s, which are chat messages + // too): the host's Chat option decides, as `ChatListener` does + // for the guests' packets. Command feedback is a system message + // and takes the system-message permission instead. + HostEvent::Chat { line, .. } => self.player_message(Text::literal(line)), HostEvent::Warn(line) if dedicated => super::dedicated::log("WARN", &line), HostEvent::Warn(line) => log::warn!("{line}"), HostEvent::Error(line) if dedicated => super::dedicated::log("ERROR", &line), From c68e55438f4daf6f0c744f980eae3a335f820c99 Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Mon, 26 Oct 2026 10:34:21 +0500 Subject: [PATCH 17/62] Loot: the enchantment functions reach every table that rolls MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `/loot give @s loot minecraft:chests/end_city_treasure` handed out bare gear: the loot dispatcher in `items.rs` (the path `/loot`, bartering, raids, dispenser tables, advancements and mob drops use) knew no `minecraft:enchant_with_levels` or `minecraft:enchant_randomly`, so both fell through its arm untouched. Only the chunk-generation path, which uses `horizon_world::loot`, enchanted anything — which is why #1911 and #1437 looked fixed. The dispatcher now runs both, as vanilla does: `EnchantWithLevelsFunction` picks from `EnchantmentHelper.enchantItem`'s results (a book becomes one enchanted book), `EnchantRandomlyFunction` picks one compatible enchantment at a level between its min and max, and both resolve `options` as a tag, a list or one id, else the whole registry. `Items` carries that registry now (`Items::enchantments`), and `StationData` shares the same copy instead of loading a second one. Verified in game: six `/loot give … end_city_treasure` rolls gave 10 pieces of gear, all 10 enchanted (unbreaking 3, mending 1 + protection 4, …), where all 10 were bare before. Refs #1660 --- crates/horizon-client/src/items.rs | 127 +++++++++++++++++++++++++- crates/horizon-client/src/stations.rs | 5 +- 2 files changed, 129 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs index 8ac450bcb..8c72dfc71 100644 --- a/crates/horizon-client/src/items.rs +++ b/crates/horizon-client/src/items.rs @@ -251,6 +251,10 @@ pub struct Items { loot: HashMap, /// The `jukebox_song` registry. pub songs: HashMap, + /// The enchantment registry: loot functions enchant the items they roll + /// (`EnchantWithLevelsFunction`, `EnchantRandomlyFunction`), and the + /// station menus share this copy. + pub enchantments: Arc, } /// A `JukeboxSong`. #[derive(Clone, Debug)] @@ -701,12 +705,15 @@ impl Items { item_tag_order: load_tag_lists(root, "item")?, loot, songs: load_songs(root), + enchantments: Arc::new(crate::enchant::Enchantments::load(root)), }) } pub fn get(&self, id: &str) -> Option<&ItemInfo> { self.items.get(id) } - /// Only the block and item tags, for tools that need tag membership. + /// Only the block and item tags (and the enchantment registry, which the + /// station rules and loot functions are built from), for tools that need + /// tag membership. pub fn tags_only(root: &Path) -> Result { Ok(Self { items: HashMap::new(), @@ -717,6 +724,7 @@ impl Items { item_tag_order: load_tag_lists(root, "item")?, loot: HashMap::new(), songs: HashMap::new(), + enchantments: Arc::new(crate::enchant::Enchantments::load(root)), }) } /// An item table with only tags, for unit tests of item rules. @@ -734,6 +742,7 @@ impl Items { item_tags, loot: HashMap::new(), songs: HashMap::new(), + enchantments: Arc::new(crate::enchant::Enchantments::default()), } } /// Whether `block` is in the block tag `tag` (`minecraft:fire`, no `#`). @@ -1371,6 +1380,16 @@ impl LootContext<'_> { self.modifiers(&modifiers, &mut stack, random); produced.push(stack); } + /// An enchantment function's `options` (`HolderSet`): a tag, a list or + /// one id; every enchantment when absent (`registryAccess().listElements`). + fn enchant_pool(e: &crate::enchant::Enchantments, options: &Value) -> Vec> { + match options { + Value::String(s) if s.starts_with('#') => e.tag(s).to_vec(), + Value::String(s) => vec![Arc::from(s.as_str())], + Value::Array(a) => a.iter().filter_map(|x| x.as_str().map(Arc::from)).collect(), + _ => e.list.iter().map(|x| Arc::clone(&x.id)).collect(), + } + } fn modifiers(&self, m: &Value, stack: &mut ItemStack, random: &mut R) { let list: Vec<&Value> = match m { Value::Array(a) => a.iter().collect(), @@ -1449,6 +1468,47 @@ impl LootContext<'_> { .with_potion(id); } } + // EnchantWithLevelsFunction: EnchantmentHelper.enchantItem on + // the context's random (the End cities' gear). + "minecraft:enchant_with_levels" => { + let cost = Self::int_number(&f["levels"], random); + let e = &self.items.enchantments; + let pool = Self::enchant_pool(e, &f["options"]); + let chosen = e.select(self.items, random, &stack.item, cost, &pool); + // EnchantmentHelper.enchantItem: a book becomes one + // enchanted book (the fresh stack's count). + if &*stack.item == "minecraft:book" { + *stack = ItemStack::new("minecraft:enchanted_book", 1); + } + for (id, level) in chosen { + stack.enchant(&id, level); + } + } + // EnchantRandomlyFunction: one enchantment the item accepts, + // at a level between its min and max. + "minecraft:enchant_randomly" => { + let e = &self.items.enchantments; + let book = &*stack.item == "minecraft:book"; + let only_compatible = f["only_compatible"].as_bool().unwrap_or(true); + let options: Vec> = Self::enchant_pool(e, &f["options"]) + .into_iter() + .filter(|id| { + book || !only_compatible || e.can_enchant(self.items, id, &stack.item) + }) + .collect(); + if options.is_empty() { + continue; + } + let id = options + [random.next_int_bound(options.len() as i32).unwrap_or(0) as usize] + .clone(); + let max = e.get(&id).map_or(1, |d| d.max_level).max(1); + let level = 1 + random.next_int_bound(max as i32).unwrap_or(0) as u32; + if book { + *stack = ItemStack::new("minecraft:enchanted_book", 1); + } + stack.enchant(&id, level); + } "minecraft:limit_count" => { let limit = &f["limit"]; if let Some(min) = limit["min"].as_i64() { @@ -1658,6 +1718,71 @@ mod tests { assert_eq!(drops[0].potion(), Some("minecraft:fire_resistance")); } + /// `/loot give` and every other table this dispatcher rolls: the two + /// enchantment functions (`EnchantWithLevelsFunction`, + /// `EnchantRandomlyFunction`) put their enchantments on the stack. + #[test] + fn loot_enchant_functions_enchant_the_rolled_item() { + let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client/26.3"); + if !root.join("items.json").exists() { + return; + } + let assets = crate::assets::Assets::load(&root).unwrap(); + let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap(); + let items = Items::load(&root, assets.registry, &facts).unwrap(); + let props = BTreeMap::new(); + let mut random = LegacyRandom::new(11); + // A sword at levels 20..39 comes out enchanted, as in an End city. + let levels = json!({"pools":[{"rolls":1,"entries":[{"type":"minecraft:item", + "name":"minecraft:diamond_sword","modifier":[ + {"type":"minecraft:enchant_with_levels","levels":{"type":"minecraft:uniform","min":20.0,"max":39.0}}]}]}]}); + let mut enchanted = 0; + for _ in 0..40 { + let drops = ctx(&items, None, &props, "").evaluate(&levels, &mut random); + if drops[0].enchantments().is_empty() { + continue; + } + enchanted += 1; + assert_eq!(&*drops[0].item, "minecraft:diamond_sword"); + // Levels stay within the enchantment's range. + for (id, level) in drops[0].enchantments() { + let max = items + .enchantments + .get(id) + .expect("a known enchantment") + .max_level; + assert!((1..=max).contains(level), "{id} at {level}"); + } + } + assert!( + enchanted > 30, + "only {enchanted} of 40 rolls were enchanted" + ); + // `enchant_randomly` on a book makes one enchanted book, its levels + // stored; the pool is the enchantment tag it names. + let book = json!({"pools":[{"rolls":1,"entries":[{"type":"minecraft:item", + "name":"minecraft:book","modifier":[ + {"type":"minecraft:enchant_randomly","options":"#minecraft:on_random_loot"}]}]}]}); + let drops = ctx(&items, None, &props, "").evaluate(&book, &mut random); + assert_eq!(&*drops[0].item, "minecraft:enchanted_book"); + assert_eq!(drops[0].count, 1); + assert!(drops[0].enchantments().is_empty()); + let stored = drops[0].stored_enchantments(); + assert_eq!(stored.len(), 1, "{stored:?}"); + assert!( + items + .enchantments + .in_tag("minecraft:on_random_loot", &stored[0].0) + ); + // An item no enchantment accepts keeps none of them. + let dirt = json!({"pools":[{"rolls":1,"entries":[{"type":"minecraft:item", + "name":"minecraft:dirt","modifier":[ + {"type":"minecraft:enchant_with_levels","levels":{"type":"minecraft:constant","value":30.0}}]}]}]}); + let drops = ctx(&items, None, &props, "").evaluate(&dirt, &mut random); + assert!(drops[0].enchantments().is_empty()); + } + #[test] fn always_edible_and_consume_effects_loaded() { let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs index 715c2663e..c24d8b39f 100644 --- a/crates/horizon-client/src/stations.rs +++ b/crates/horizon-client/src/stations.rs @@ -14,7 +14,8 @@ use std::{fs, path::Path, sync::Arc}; /// Everything the workstation menus read, loaded once with the resources. pub struct StationData { - pub enchantments: Enchantments, + /// The same registry `Items` carries (`Items::enchantments`). + pub enchantments: std::sync::Arc, pub recipes: StationRecipes, pub brewing: crate::brewing::Brewing, pub trades: crate::merchant::Trades, @@ -25,7 +26,7 @@ pub struct StationData { impl StationData { pub fn load(root: &Path, items: &Items) -> Self { Self { - enchantments: Enchantments::load(root), + enchantments: std::sync::Arc::clone(&items.enchantments), recipes: StationRecipes::load(root, items), brewing: crate::brewing::Brewing::load(root, items), trades: crate::merchant::Trades::load(root), From 77def1f2dd13fe5c7d3f96d6c745c74312409501 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 08:40:00 +0300 Subject: [PATCH 18/62] Mob models: a skipped part still draws its children The early return skipped the child loop as well, while skipDraw only hides the part's own cubes. A rolled armadillo skips its body and still renders the parts below it. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/mobs/render.rs | 38 ++++++++++++------------ 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 4188c9c85..ef18536d3 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -946,25 +946,25 @@ fn draw_normals( return; } let normals = normals.part(p); - // `skips` is a name lookup: asking once per part, not once per polygon. - if poses.skips(part) { - return; - } - for poly in &part.polygons { - let normal = poly.vertex_normal(normals); - for v in poly.vertices { - let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0); - out.push(Vertex { - normal, - pos: pos.to_array(), - uv: [ - uv[0] + (uv[2] - uv[0]) * v[3], - uv[1] + (uv[3] - uv[1]) * v[4], - ], - layer: overlay, - color, - light, - }); + // `skips` is a name lookup: ask once per part, not once per polygon. A part + // hidden this way still draws its children, so only the polygons are gated. + if !poses.skips(part) { + for poly in &part.polygons { + let normal = poly.vertex_normal(normals); + for v in poly.vertices { + let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0); + out.push(Vertex { + normal, + pos: pos.to_array(), + uv: [ + uv[0] + (uv[2] - uv[0]) * v[3], + uv[1] + (uv[3] - uv[1]) * v[4], + ], + layer: overlay, + color, + light, + }); + } } } for c in &part.children { From 1e9644cc1577d2382965fa8733f2190e2cebad58 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 08:51:52 +0300 Subject: [PATCH 19/62] Signs: cut the first line on byte offsets, not through a char copy first_line collected the whole line into a Vec and then re-collected a prefix of it, eight times per sign per frame, front and back. Every cut point it needs is already a byte offset in the input. Co-Authored-By: Hermes Agent (Nous Research) --- .../horizon-client/src/block_entity_render.rs | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 10c5e2509..28a876d80 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -558,12 +558,11 @@ fn frac(x: f32) -> f32 { /// `StringSplitter.splitLines(...).get(0)` for plain text: the first line, /// wrapped at the last space that fits or mid-word when none does. fn first_line(line: &str, max_width: f32, advance: &dyn Fn(char) -> f32) -> String { - let chars: Vec = line.chars().collect(); let mut width = 0.0; let mut last_space = None; - for (i, &c) in chars.iter().enumerate() { + for (i, c) in line.char_indices() { if c == '\n' { - return chars[..i].iter().collect(); + return line[..i].to_owned(); } if c == ' ' { last_space = Some(i); @@ -572,9 +571,11 @@ fn first_line(line: &str, max_width: f32, advance: &dyn Fn(char) -> f32) -> Stri if width > max_width { let end = match last_space { Some(s) if s > 0 => s, - _ => i.max(1), + _ if i > 0 => i, + // The first char alone is too wide: take that one char. + _ => c.len_utf8(), }; - return chars[..end].iter().collect(); + return line[..end].to_owned(); } } line.to_owned() @@ -2098,4 +2099,13 @@ mod tests { assert_eq!(out[1].pos, [2.0, 0.0, 0.0]); assert_eq!(out[2].uv, [0.5, 0.5]); } + + #[test] + fn first_line_wraps_on_bytes_without_splitting_a_char() { + let advance = |c: char| if c == ' ' { 4.0 } else { 6.0 }; + assert_eq!(first_line("ab cd ef", 13.0, &advance), "ab"); + assert_eq!(first_line("abcdef", 13.0, &advance), "ab"); + assert_eq!(first_line("\u{6771}", 3.0, &advance), "\u{6771}"); + assert_eq!(first_line("ab\ncd", 100.0, &advance), "ab"); + } } From 9dc72bf3ac6f7eed7c2667953f0ddd84e12c0cad Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 08:58:50 +0300 Subject: [PATCH 20/62] Subtitles: measure each line once per frame The max-width pass built a Text for every audible subtitle and dropped the width it measured, then the draw loop built the same Text again to measure it a second time. The row loop uses the number the first pass already had. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/hud_overlays.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs index ecc23a5ee..ebd860e08 100644 --- a/crates/horizon-client/src/hud_overlays.rs +++ b/crates/horizon-client/src/hud_overlays.rs @@ -1111,8 +1111,9 @@ impl SubtitleOverlay { s.purge_old_instances(3000.0 * frame.multiplier, now); } if s.audible_from(position) && !s.played.is_empty() { - width = width.max(width_of(&Text::translate(&s.key, &[]))); - audible.push(i); + let text_width = width_of(&Text::translate(&s.key, &[])); + width = width.max(text_width); + audible.push((i, text_width)); } } if audible.is_empty() { @@ -1121,7 +1122,7 @@ impl SubtitleOverlay { let w = |s: &str| font.width(s) as i32; width += w("<") + w(" ") + w(">") + w(" "); let mut row = 0; - for i in audible { + for (i, text_width) in audible { let s = &self.subtitles[i]; let text_value = Text::translate(&s.key, &[]); let Some(closest) = s.best_candidate(position) else { @@ -1145,7 +1146,6 @@ impl SubtitleOverlay { let half_width = width / 2; let height = 9; let half_height = height / 2; - let text_width = width_of(&text_value); let brightness = s.brightness(closest, frame.multiplier, now); out.push(GuiDraw::Push(vec![ PoseOp::Translate( From dd45bf7740c50f09e6882a4c284d52edbf9a675b Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 09:08:18 +0300 Subject: [PATCH 21/62] F3: measure each line once per frame The overlay measured every line to place it and measured it again for its background box, about thirty extra glyph walks per frame on a full screen. The width that placed the line is carried to the background pass. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/debug_overlay.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/debug_overlay.rs b/crates/horizon-client/src/debug_overlay.rs index 3448ea411..fa969512c 100644 --- a/crates/horizon-client/src/debug_overlay.rs +++ b/crates/horizon-client/src/debug_overlay.rs @@ -194,18 +194,17 @@ pub fn scale( pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec { let mut out = vec![GuiDraw::Push(vec![PoseOp::Scale(scale, scale)])]; for (lines, align_left) in [(columns[0], true), (columns[1], false)] { - let placed: Vec<(&String, i32, i32)> = lines + let placed: Vec<(&String, i32, i32, i32)> = lines .iter() .enumerate() .filter(|(_, l)| !l.is_empty()) .map(|(i, l)| { let w = font.width(l) as i32; let left = if align_left { 2 } else { width - 2 - w }; - (l, left, 2 + LINE_HEIGHT * i as i32) + (l, left, 2 + LINE_HEIGHT * i as i32, w) }) .collect(); - for (line, left, top) in &placed { - let w = font.width(line) as i32; + for (_, left, top, w) in &placed { out.push(fill( left - 1, top - 1, @@ -214,7 +213,7 @@ pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec BACKGROUND, )); } - for (line, left, top) in placed { + for (line, left, top, _) in placed { out.push(GuiDraw::Text { text: Text::literal(line.clone()), x: left, From b59d9ada27ef08208ce4ca182f5da0d9ff112ff4 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 09:49:41 +0300 Subject: [PATCH 22/62] Shaders: the frame uniforms keep their buffer between frames update rebuilt the values vector every frame for a fixed-length list: one allocation and one free per frame for nothing. eval_custom already treats the same vector as a buffer to truncate and extend. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/gfx/pack_uniforms.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/gfx/pack_uniforms.rs b/crates/horizon-client/src/gfx/pack_uniforms.rs index c4df4377b..8f5f1a2de 100644 --- a/crates/horizon-client/src/gfx/pack_uniforms.rs +++ b/crates/horizon-client/src/gfx/pack_uniforms.rs @@ -399,7 +399,8 @@ impl FrameUniforms { _ => Value::i(&[0]), } }; - self.values = NAMES.iter().map(|n| value(n)).collect(); + self.values.clear(); + self.values.extend(NAMES.iter().map(|n| value(n))); self.frame = (self.frame + 1) % 720_720; } From 73bbbd3ee8ead8624788812f9818e3ae7a1259f0 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 09:55:58 +0300 Subject: [PATCH 23/62] Tooltips: compare the hidden component id without a UTF-16 copy TooltipDisplay.shows built a JavaString from the id on every call just to test membership in the NBT list. A hovered tooltip asks this a dozen times per frame, so the hover allocated a dozen short vectors per frame for a read. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/item_tooltip.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs index 6e51de391..cb52965a0 100644 --- a/crates/horizon-client/src/item_tooltip.rs +++ b/crates/horizon-client/src/item_tooltip.rs @@ -56,10 +56,9 @@ impl<'a> TooltipDisplay<'a> { else { return true; }; - let component = horizon_world::nbt::JavaString::from(component); - !hidden - .iter() - .any(|tag| matches!(tag, Tag::String(id) if id == &component)) + !hidden.iter().any(|tag| { + matches!(tag, Tag::String(id) if id.0.iter().copied().eq(component.encode_utf16())) + }) } } From 4a7173918b643ccf957a34c8dfb61fcdf102b9d5 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 10:12:08 +0300 Subject: [PATCH 24/62] Roadmap: finished help-wanted items link the pull requests that did them check still found five Help wanted items whose only links were closed issues. Each was finished by a merged pull request, so the item now links that pull request and waits in Now until a release carries it. Co-Authored-By: Hermes Agent (Nous Research) --- ROADMAP.md | 110 +++++++++++++++++++++----------------- roadmap/roadmap.toml | 20 +++---- website/data/roadmap.json | 27 ++++++---- 3 files changed, 87 insertions(+), 70 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index a04eca2ce..4a2b90643 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -160,6 +160,66 @@ Translatable components resolved through the selected language for items, contai +#### Cooldowns drawn on items + +After you throw an ender pearl, its slot should show the cooldown sweeping away, as in vanilla. + +
Technical + +Vanilla draws `ItemCooldowns`' percent as a white overlay over the slot (`GuiGraphicsExtractor.itemDecorations` and `itemCooldown`) in the hotbar and in inventories. Issue [#1763](https://github.com/ludovic111/horizon/issues/1763). + +More: [#1933](https://github.com/ludovic111/horizon/issues/1933) + +
+ +#### Chat settings and team prefixes + +The Hidden and Commands Only chat settings should hide chat, and team prefixes should appear before names in chat. + +
Technical + +Vanilla checks `ChatVisiblity` before it delivers chat and system messages ([#1376](https://github.com/ludovic111/horizon/issues/1376)), and chat uses the team-formatted display name ([#1378](https://github.com/ludovic111/horizon/issues/1378)). Both issues have exact steps to reproduce. + +More: [#1932](https://github.com/ludovic111/horizon/issues/1932) · [#1841](https://github.com/ludovic111/horizon/issues/1841) + +
+ +#### A pointing hand over buttons + +The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3. + +
Technical + +26.3's `AbstractWidget` asks for a cursor from `CursorTypes` when it is hovered; winit's `CursorIcon::Pointer` gives the same shape. Issue [#1347](https://github.com/ludovic111/horizon/issues/1347). + +More: [#1897](https://github.com/ludovic111/horizon/issues/1897) + +
+ +#### Ctrl+Backspace and scroll bars in menus + +Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be draggable. + +
Technical + +`EditBox` deletes by word with Ctrl ([#1764](https://github.com/ludovic111/horizon/issues/1764)); the Game Rules and Statistics lists' scroll bars can't be dragged ([#1782](https://github.com/ludovic111/horizon/issues/1782), after [#978](https://github.com/ludovic111/horizon/issues/978)). + +More: [#1884](https://github.com/ludovic111/horizon/issues/1884) · [#1931](https://github.com/ludovic111/horizon/issues/1931) + +
+ +#### Chickens flap while they fall + +Chickens should flap their wings while they fall, not stand still in the air. + +
Technical + +Vanilla's `Chicken.aiStep` updates `flap` and `flapSpeed` when the chicken isn't on the ground, and the model's wings follow them. Issue [#1706](https://github.com/ludovic111/horizon/issues/1706). + +More: [#1892](https://github.com/ludovic111/horizon/issues/1892) + +
+ ### Rendering #### Shader packs, written again from scratch @@ -902,56 +962,6 @@ Armour and tools in End city chests should come enchanted, as in vanilla. -#### Cooldowns drawn on items - -After you throw an ender pearl, its slot should show the cooldown sweeping away, as in vanilla. - -
Technical - -Vanilla draws `ItemCooldowns`' percent as a white overlay over the slot (`GuiGraphicsExtractor.itemDecorations` and `itemCooldown`) in the hotbar and in inventories. Issue [#1763](https://github.com/ludovic111/horizon/issues/1763). - -
- -#### Chat settings and team prefixes - -The Hidden and Commands Only chat settings should hide chat, and team prefixes should appear before names in chat. - -
Technical - -Vanilla checks `ChatVisiblity` before it delivers chat and system messages ([#1376](https://github.com/ludovic111/horizon/issues/1376)), and chat uses the team-formatted display name ([#1378](https://github.com/ludovic111/horizon/issues/1378)). Both issues have exact steps to reproduce. - -
- -#### A pointing hand over buttons - -The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3. - -
Technical - -26.3's `AbstractWidget` asks for a cursor from `CursorTypes` when it is hovered; winit's `CursorIcon::Pointer` gives the same shape. Issue [#1347](https://github.com/ludovic111/horizon/issues/1347). - -
- -#### Ctrl+Backspace and scroll bars in menus - -Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be draggable. - -
Technical - -`EditBox` deletes by word with Ctrl ([#1764](https://github.com/ludovic111/horizon/issues/1764)); the Game Rules and Statistics lists' scroll bars can't be dragged ([#1782](https://github.com/ludovic111/horizon/issues/1782), after [#978](https://github.com/ludovic111/horizon/issues/978)). - -
- -#### Chickens flap while they fall - -Chickens should flap their wings while they fall, not stand still in the air. - -
Technical - -Vanilla's `Chicken.aiStep` updates `flap` and `flapSpeed` when the chicken isn't on the ground, and the model's wings follow them. Issue [#1706](https://github.com/ludovic111/horizon/issues/1706). - -
- ## Recently shipped - **OpenGL for old computers** (v0.2.63): Horizon now starts on old PCs whose graphics card has no Vulkan or DirectX 12 driver: it switches to OpenGL by itself, and Options > Graphics can pick OpenGL by hand. [#1917](https://github.com/ludovic111/horizon/issues/1917) · [#1920](https://github.com/ludovic111/horizon/issues/1920) · [#1936](https://github.com/ludovic111/horizon/issues/1936) diff --git a/roadmap/roadmap.toml b/roadmap/roadmap.toml index 669596fba..1dbed9c37 100644 --- a/roadmap/roadmap.toml +++ b/roadmap/roadmap.toml @@ -1039,54 +1039,54 @@ links = ["#1437", "#1660"] [[item]] id = "item-cooldowns" title = "Cooldowns drawn on items" -status = "help-wanted" +status = "now" area = "gameplay" plain = """After you throw an ender pearl, its slot should show the cooldown sweeping away, as in vanilla.""" dev = """Vanilla draws `ItemCooldowns`' percent as a white overlay over the slot \ (`GuiGraphicsExtractor.itemDecorations` and `itemCooldown`) in the hotbar and in inventories. Issue #1763.""" -links = ["#1763"] +links = ["#1763", "#1933"] [[item]] id = "chat-settings" title = "Chat settings and team prefixes" -status = "help-wanted" +status = "now" area = "gameplay" plain = """The Hidden and Commands Only chat settings should hide chat, and team prefixes should appear before \ names in chat.""" dev = """Vanilla checks `ChatVisiblity` before it delivers chat and system messages (#1376), and chat uses the \ team-formatted display name (#1378). Both issues have exact steps to reproduce.""" -links = ["#1376", "#1378"] +links = ["#1376", "#1378", "#1932", "#1841"] [[item]] id = "pointer-hand" title = "A pointing hand over buttons" -status = "help-wanted" +status = "now" area = "gameplay" plain = """The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3.""" dev = """26.3's `AbstractWidget` asks for a cursor from `CursorTypes` when it is hovered; winit's \ `CursorIcon::Pointer` gives the same shape. Issue #1347.""" -links = ["#1347"] +links = ["#1347", "#1897"] [[item]] id = "text-field-keys" title = "Ctrl+Backspace and scroll bars in menus" -status = "help-wanted" +status = "now" area = "gameplay" plain = """Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be \ draggable.""" dev = """`EditBox` deletes by word with Ctrl (#1764); the Game Rules and Statistics lists' scroll bars can't be \ dragged (#1782, after #978).""" -links = ["#1764", "#1782"] +links = ["#1764", "#1782", "#1884", "#1931"] [[item]] id = "chicken-flap" title = "Chickens flap while they fall" -status = "help-wanted" +status = "now" area = "gameplay" plain = """Chickens should flap their wings while they fall, not stand still in the air.""" dev = """Vanilla's `Chicken.aiStep` updates `flap` and `flapSpeed` when the chicken isn't on the ground, and the \ model's wings follow them. Issue #1706.""" -links = ["#1706"] +links = ["#1706", "#1892"] # ---------------------------------------------------------------------------------------------------- Shipped # Newest first: `tools/roadmap.py sync` adds each newly shipped item on top. diff --git a/website/data/roadmap.json b/website/data/roadmap.json index 58d697257..050b89394 100644 --- a/website/data/roadmap.json +++ b/website/data/roadmap.json @@ -1034,58 +1034,65 @@ { "id": "item-cooldowns", "title": "Cooldowns drawn on items", - "status": "help-wanted", + "status": "now", "area": "gameplay", "plain": "After you throw an ender pearl, its slot should show the cooldown sweeping away, as in vanilla.", "dev": "Vanilla draws `ItemCooldowns`' percent as a white overlay over the slot (`GuiGraphicsExtractor.itemDecorations` and `itemCooldown`) in the hotbar and in inventories. Issue #1763.", "links": [ - "#1763" + "#1763", + "#1933" ] }, { "id": "chat-settings", "title": "Chat settings and team prefixes", - "status": "help-wanted", + "status": "now", "area": "gameplay", "plain": "The Hidden and Commands Only chat settings should hide chat, and team prefixes should appear before names in chat.", "dev": "Vanilla checks `ChatVisiblity` before it delivers chat and system messages (#1376), and chat uses the team-formatted display name (#1378). Both issues have exact steps to reproduce.", "links": [ "#1376", - "#1378" + "#1378", + "#1932", + "#1841" ] }, { "id": "pointer-hand", "title": "A pointing hand over buttons", - "status": "help-wanted", + "status": "now", "area": "gameplay", "plain": "The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3.", "dev": "26.3's `AbstractWidget` asks for a cursor from `CursorTypes` when it is hovered; winit's `CursorIcon::Pointer` gives the same shape. Issue #1347.", "links": [ - "#1347" + "#1347", + "#1897" ] }, { "id": "text-field-keys", "title": "Ctrl+Backspace and scroll bars in menus", - "status": "help-wanted", + "status": "now", "area": "gameplay", "plain": "Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be draggable.", "dev": "`EditBox` deletes by word with Ctrl (#1764); the Game Rules and Statistics lists' scroll bars can't be dragged (#1782, after #978).", "links": [ "#1764", - "#1782" + "#1782", + "#1884", + "#1931" ] }, { "id": "chicken-flap", "title": "Chickens flap while they fall", - "status": "help-wanted", + "status": "now", "area": "gameplay", "plain": "Chickens should flap their wings while they fall, not stand still in the air.", "dev": "Vanilla's `Chicken.aiStep` updates `flap` and `flapSpeed` when the chicken isn't on the ground, and the model's wings follow them. Issue #1706.", "links": [ - "#1706" + "#1706", + "#1892" ] }, { From b6af2584659fd487757a67084883073058b334b7 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 07:29:40 +0000 Subject: [PATCH 25/62] Fix warden sonic boom particle delivery to connected players Send each sonic ray point through the existing particle packet path with vanilla recipient filtering. Cover nearby and distant clients, damage, and local rendering in the LAN harness. Fixes #1490. Co-Authored-By: Codex (GPT-6.1 Sol) --- crates/horizon-client/src/game/creatures.rs | 3 ++ .../horizon-client/src/game/lan_particles.rs | 28 ++++++++++ tools/lan_e2e.py | 51 +++++++++++++++++++ 3 files changed, 82 insertions(+) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index be7923037..fb4844bfc 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1057,6 +1057,9 @@ impl Game<'_> { self.ensure_item_particle_sprites(); } let options = horizon_client::particles::ParticleOptions::simple(ty); + if ty == horizon_client::particles::ParticleType::SonicBoom { + self.lan_sonic_boom(&options, at); + } // Count 0: one particle exactly there, at rest. if count == 0 { self.particles.add(&options, at, [0.0; 3]); diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs index 0e35392bf..f92e8cf61 100644 --- a/crates/horizon-client/src/game/lan_particles.rs +++ b/crates/horizon-client/src/game/lan_particles.rs @@ -25,6 +25,34 @@ fn rgb(c: [f32; 4]) -> [f32; 3] { } impl Game<'_> { + /// `SonicBoom.tick` uses `ServerLevel.sendParticles` for each ray point. + /// Keep the local event's rendering; connected players receive one at rest. + pub(super) fn lan_sonic_boom(&self, options: &ParticleOptions, at: [f64; 3]) { + let Some(particle) = self.network_particle(options, None) else { + return; + }; + let packet = C::LevelParticles(play::LevelParticles { + particle, + override_limiter: false, + always_show: false, + pos: at, + dist: [0.0; 3], + max_speed: [0.0; 3], + count: 0, + randomization: 0, + }); + let host = self.lan.as_ref().unwrap(); + for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) { + // ServerLevel compares the player's block centre, strictly within 32. + let distance: f64 = (0..3) + .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2)) + .sum(); + if distance < 32.0 * 32.0 { + g.send(&packet); + } + } + } + /// `ParticleTypes.STREAM_CODEC`'s value for `options`: the type's /// network id and the data it carries (`state` for the block particles). /// None while not serving, or for a particle whose data isn't sent from diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 804add98a..4acae0963 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -6591,5 +6591,56 @@ CHECKS += ['replant'] CHECK_FNS['replant'] = check_replant +def check_sonic(host, guest, out): + """A real warden's ray reaches connected clients once, with normal damage. + + Run with and without --server-thread to cover the window's local renderer too. + The creative observer sees the same ray nearby and none outside sendParticles' range. + """ + x, y, z = (int(v // 1) for v in pos_of(host)) + result = {} + guest('command', command='gamemode creative') + host('command', command='difficulty normal') + host('command', command='gamerule natural_health_regeneration false') + try: + host('command', command=f'fill {x - 3} {y - 1} {z - 3} {x + 85} {y - 1} {z + 14} minecraft:stone') + host('command', command=f'fill {x - 3} {y} {z - 3} {x + 15} {y + 4} {z + 14} minecraft:air') + host('command', command=f'fill {x - 2} {y} {z + 4} {x + 2} {y + 3} {z + 4} minecraft:stone') + for near in (True, False): + guest('command', command=f'tp @s {x + (3 if near else 80) + 0.5} {y} {z + 0.5}') + host('command', command=f'tp @s {x + 0.5} {y} {z + 0.5} 0 0') + host('command', command='gamemode survival') + host('command', command='effect give @s minecraft:instant_health 1 5') + host.wait(4) + host('command', command=f'summon minecraft:warden {x + 0.5} {y} {z + 9.5} {{NoAI:1b,Tags:["sonic_test"]}}') + host('command', command='attribute @e[tag=sonic_test,limit=1] minecraft:knockback_resistance base set 1') + before = {side: made(g, 'sonic_boom') for side, g in (('host', host), ('guest', guest))} + health = host('status')['player']['health'] + host('command', command='data merge entity @e[tag=sonic_test,limit=1] {NoAI:0b}') + host('command', command='attribute @e[tag=sonic_test,limit=1] minecraft:movement_speed base set 0') + host('command', command='damage @e[tag=sonic_test,limit=1] 1 minecraft:player_attack by @s') + for _ in range(400): + host.wait(2) + if host('status')['player']['health'] < health: + break + host.wait(2) # let the observer process the same packet batch + seen = {side: made(g, 'sonic_boom') - before[side] for side, g in (('host', host), ('guest', guest))} + after = host('status')['player']['health'] + result['near' if near else 'far'] = {'particles': seen, 'health': [health, after]} + host.shot(out, f'sonic-{"near" if near else "far"}') + host('command', command='kill @e[tag=sonic_test]') + assert after == health - 10, result + assert seen['host'] == 15, result + assert seen['guest'] == (15 if near else 0), result + finally: + host('command', command='kill @e[tag=sonic_test]') + host('command', command='gamerule natural_health_regeneration true') + return result + + +CHECKS += ['sonic'] +CHECK_FNS['sonic'] = check_sonic + + if __name__ == '__main__': main() From cd7b6e025e49f19ea8085e8d7734079962e919fe Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 07:49:37 +0000 Subject: [PATCH 26/62] Fix recipe book overlays surviving remote screen changes Co-Authored-By: Codex GPT-6.1 Sol --- crates/horizon-client/src/game/remote.rs | 5 +++ tools/lan_e2e.py | 47 ++++++++++++++++++++++++ 2 files changed, 52 insertions(+) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3a2dd1d69..bdaa8a5f4 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -4600,6 +4600,7 @@ impl Game<'_> { } KeyCode::KeyE => { // The inventory opens without telling the server. + self.recipe_ui.reset_screen(); self.screen = if self.creative { Screen::Creative } else { @@ -4838,6 +4839,7 @@ impl Game<'_> { self.remote_close_local(); } fn remote_close_local(&mut self) { + self.recipe_ui.reset_screen(); if let Some(r) = self.remote.as_mut() { r.menu = None; r.menu_title = None; @@ -4908,6 +4910,9 @@ impl Game<'_> { } /// ClientboundOpenScreenPacket for the menus Horizon draws. fn remote_open_screen(&mut self, p: play::OpenScreen) { + // A new RecipeBookComponent owns fresh ghost slots and an overlay, + // even when the server replaces a menu without a close packet. + self.recipe_ui.reset_screen(); let menu = self .remote .as_ref() diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 804add98a..2eb9d9843 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -2075,6 +2075,53 @@ def check_recipes(host, guest, out): guest.raw('key', 'esc', 'tap') guest.wait(5) assert any('oak_log' in str(item) for item in grid.values()), f'nothing placed in the grid: {grid}' + # #2019: the alternatives popup belongs to one screen. Check both the + # in-frame host (or --server-thread host) and the remote guest, with both + # inventory-close keys and a different recipe-book type on reopening. + for game in (host, guest): + game('command', command='recipe give @s minecraft:oak_planks') + game('command', command='recipe give @s minecraft:birch_planks') + game.wait(10) + for close_key, reopen in (('e', 'inventory'), ('esc', 'furnace')): + game.raw('key', 'e', 'tap') + game.wait(5) + book = game('screen')['recipe_book'] + if len(book['targets']) == 1: + game.raw('click-at', *centre(book['targets'][0])) + game.wait(5) + book = game('screen')['recipe_book'] + for rect in book['targets']: + if rect[2:] != [25.0, 25.0]: + continue + game.raw('click-at', *centre(rect), 'right') + game.wait(2) + targets = game('screen')['recipe_book']['targets'] + if targets and all(r[2:] == [24.0, 24.0] for r in targets): + break + else: + raise AssertionError(f'{game.name}: no alternatives popup opened: {book}') + game.shot(out, f'recipe-overlay-{close_key}-before') + game.raw('key', close_key, 'tap') + game.wait(5) + if reopen == 'inventory': + game.raw('key', 'e', 'tap') + else: + x, y, z = (int(v // 1) for v in pos_of(game)) + game('command', command=f'setblock {x} {y} {z - 2} minecraft:furnace') + game.wait(5) + game.raw('interact', x, y, z - 2) + game.wait(5) + targets = game('screen')['recipe_book']['targets'] + if reopen == 'furnace' and len(targets) == 1 and targets[0][2:] == [20.0, 18.0]: + game.raw('click-at', *centre(targets[0])) + game.wait(5) + targets = game('screen')['recipe_book']['targets'] + game.shot(out, f'recipe-overlay-{close_key}-after') + assert any(r[2:] == [20.0, 18.0] for r in targets), f'{game.name}: stale popup: {targets}' + if reopen == 'inventory': + assert len(targets) > 1, f'{game.name}: the book forgot its open setting' + game.raw('key', 'esc', 'tap') + game.wait(5) return {'known': known, 'grid': grid} From 87e3df5331fe0825545cdb9d141935382ce3ef10 Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:52:16 +0500 Subject: [PATCH 27/62] Container clicks: a closed screen drops its press state MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it belongs to on the screen. Horizon keeps both on `Game` (`inv_clicks`, `inv_drag`, `last_inv_click`), and nothing cleared them when a screen closed: a press whose release never reached the screen — the pointer left the window, or the screen closed between the press and the release — left a quick-craft drag running, and `Clicks::press` answers `None` for every later press, so clicks went dead on every screen after it. `Game::reset_inventory_clicks` now runs when a container closes and when the pointer is grabbed again (the inventory's screens are behind us), which is the lifetime vanilla gives that state. Refs #1737 Co-Authored-By: [CC] --- crates/horizon-client/src/container_screen.rs | 31 +++++++++++++++++++ crates/horizon-client/src/game.rs | 15 +++++++++ 2 files changed, 46 insertions(+) diff --git a/crates/horizon-client/src/container_screen.rs b/crates/horizon-client/src/container_screen.rs index 2c490861a..4b0bb3861 100644 --- a/crates/horizon-client/src/container_screen.rs +++ b/crates/horizon-client/src/container_screen.rs @@ -276,3 +276,34 @@ mod tests { ); } } + +#[cfg(test)] +mod stuck_tests { + use super::*; + + /// A press whose release never arrives (the pointer left the window, or + /// the screen closed first) leaves `isQuickCrafting` set; the next screen + /// starts with its own state, as `AbstractContainerScreen` does, so the + /// reset the game runs on open/close makes clicks work again. + #[test] + fn a_lost_release_does_not_wedge_the_next_screen() { + let mut clicks = Clicks::default(); + let slot = Target::::Slot(3); + // Pressed with a stack carried: a quick craft drag starts, and its + // release is lost. + assert_eq!(clicks.press(&slot, Button::Left, false, false, false), None); + assert!(clicks.quick_crafting().is_some()); + assert_eq!( + clicks.press(&slot, Button::Left, true, false, false), + None, + "the stuck drag swallows the next press" + ); + // A new screen: fresh state, so the press is a normal click again. + clicks = Clicks::default(); + assert!(clicks.quick_crafting().is_none()); + assert_eq!( + clicks.press(&slot, Button::Left, true, false, false), + Some(Input::Pickup) + ); + } +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 9a3503666..a4149f808 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4731,6 +4731,10 @@ impl Game<'_> { if capture && !self.focused { return; } + if capture { + // The inventory's screens are behind us: no drag survives them. + self.reset_inventory_clicks(); + } if !capture { self.stop_mining(); } @@ -5570,7 +5574,18 @@ impl Game<'_> { self.draw_inventory_effects(batch, (ox, oy), 176); } } + /// `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it + /// belongs to on the screen; Horizon keeps them on the game, so they are + /// dropped when a screen closes. A press whose release never reaches the + /// screen (the pointer left the window, or the screen closed first) would + /// otherwise leave every later press on every later screen swallowed. + pub(super) fn reset_inventory_clicks(&mut self) { + self.inv_clicks = Default::default(); + self.inv_drag = None; + self.last_inv_click = None; + } pub(super) fn close_container(&mut self) { + self.reset_inventory_clicks(); self.close_station(); self.mount_closed(); self.recipe_ui.reset_screen(); From c6753292083086c303e8697ea0ae520987f50906 Mon Sep 17 00:00:00 2001 From: lazy-importer Date: Mon, 26 Oct 2026 09:42:35 +0100 Subject: [PATCH 28/62] Reset boss overlay on server reconfiguration When switching sub-servers on a proxy network (Velocity/BungeeCord), the network thread enters configuration mode and emits Event::Reconfigured. Vanilla's ClientPacketListener.handleConfigurationStart clears the client level, which calls Hud.onDisconnected() and resets BossHealthOverlay. Without this reset, bossbars from previous servers remained visible on screen. Fixes #2034. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/remote.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3a2dd1d69..321b7c39a 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -791,7 +791,10 @@ impl Game<'_> { remote.brand = brand; } } - Event::Reconfigured(registries) => self.set_registries(registries), + Event::Reconfigured(registries) => { + self.boss_overlay.reset(); + self.set_registries(registries); + } // handleTransfer: "Cannot transfer to server from // singleplayer" (no ServerData), so the world just closes. Event::Transfer { host, port } => { From 941f1489578c5e33ce8e38a18688c82e52f0020e Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Mon, 26 Oct 2026 14:26:24 +0500 Subject: [PATCH 29/62] Loot: a single-level enchantment draws no level Review of #2037 (rdbtCVS): `EnchantRandomlyFunction.enchantItem` calls `Mth.nextInt(random, minLevel, maxLevel)`, which returns `min` without drawing when `min >= max`. The arm here drew unconditionally, so choosing Mending (or any one-level enchantment) shifted every roll after it. `horizon_world::loot`'s copy and `merchant.rs`'s already guard this; only the loot dispatcher in `items.rs` did not. Vanilla with `LegacyRandom(11)`: a Mending book followed by `set_count` uniform 1..64 is 46; the extra draw made it 28. `a_single_level_enchantment_draws_no_level` pins that (and the stored Mending level). Co-Authored-By: [CC] --- crates/horizon-client/src/items.rs | 40 +++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs index 8c72dfc71..db39f67b8 100644 --- a/crates/horizon-client/src/items.rs +++ b/crates/horizon-client/src/items.rs @@ -1503,7 +1503,14 @@ impl LootContext<'_> { [random.next_int_bound(options.len() as i32).unwrap_or(0) as usize] .clone(); let max = e.get(&id).map_or(1, |d| d.max_level).max(1); - let level = 1 + random.next_int_bound(max as i32).unwrap_or(0) as u32; + // `Mth.nextInt(random, 1, max)`: a single-level + // enchantment (Mending) returns 1 without drawing, so the + // rolls after this one keep vanilla's sequence. + let level = if max <= 1 { + 1 + } else { + 1 + random.next_int_bound(max as i32).unwrap_or(0) as u32 + }; if book { *stack = ItemStack::new("minecraft:enchanted_book", 1); } @@ -1783,6 +1790,37 @@ mod tests { assert!(drops[0].enchantments().is_empty()); } + /// `Mth.nextInt(random, 1, max)` returns `1` without drawing when the + /// enchantment has one level (`EnchantRandomlyFunction.enchantItem`), so + /// the rolls after it must not shift. Vanilla with `LegacyRandom(11)`: a + /// Mending book, then `set_count` uniform 1..64, is 46. + #[test] + fn a_single_level_enchantment_draws_no_level() { + let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client/26.3"); + if !root.join("items.json").exists() { + return; + } + let assets = crate::assets::Assets::load(&root).unwrap(); + let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap(); + let items = Items::load(&root, assets.registry, &facts).unwrap(); + let props = BTreeMap::new(); + let table = json!({"pools":[{"rolls":1,"entries":[{"type":"minecraft:item", + "name":"minecraft:book","modifier":[ + {"type":"minecraft:enchant_randomly","options":"minecraft:mending"}, + {"type":"minecraft:set_count","count":{"type":"minecraft:uniform","min":1.0,"max":64.0}}]}]}]}); + let drops = ctx(&items, None, &props, "").evaluate(&table, &mut LegacyRandom::new(11)); + assert_eq!(drops.len(), 1); + assert_eq!(&*drops[0].item, "minecraft:enchanted_book"); + assert_eq!( + drops[0].stored_enchantments(), + [("minecraft:mending".to_owned().into(), 1)], + "the book keeps its single-level enchantment" + ); + // 46 is vanilla's count for this seed; an extra level draw gives 28. + assert_eq!(drops[0].count, 46); + } + #[test] fn always_edible_and_consume_effects_loaded() { let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) From 290e2e1ac7cb49bd9ec8a531ace9cbe1a165d092 Mon Sep 17 00:00:00 2001 From: Niraj Khetre Date: Mon, 26 Oct 2026 15:11:21 +0530 Subject: [PATCH 30/62] The ender dragon's hits and breath name it in the death message The dragon's wing and head hits and its breath clouds hurt the player without recording the dragon as the causing entity, and the dragon is not one of the mobs note_attacker looks up. death.attack.mob and death.attack.indirectMagic then got only the victim's name, so the template showed through: "%1$s was killed by %2$s using magic". Record the dragon before its damage lands (EnderDragon.hurt and knockBack use mobAttack(dragon); its breath clouds apply indirectMagic(cloud, dragon)). Fixes #2062 Assisted-by: Claude Opus 5.5 --- crates/horizon-client/src/game/combat.rs | 11 ++++++++--- crates/horizon-client/src/game/dragon.rs | 17 ++++++++++++++--- 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index 227aa0332..106e0e1a1 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -52,11 +52,16 @@ impl Game<'_> { /// Remember who deals the next `damage_type` damage to the player. pub(super) fn note_attacker(&mut self, damage_type: &str, mob: u32) { if let Some(name) = self.mob_display_name(mob) { - self.combat - .pending - .push((damage_type.to_owned(), (mob, name))); + self.note_named_attacker(damage_type, mob, name); } } + /// `note_attacker` for an entity that is not one of `self.mobs` (the + /// ender dragon). + pub(super) fn note_named_attacker(&mut self, damage_type: &str, id: u32, name: Text) { + self.combat + .pending + .push((damage_type.to_owned(), (id, name))); + } /// `LivingEntity.handleDamageEvent` for the player: the hurt sound of the /// source's `DamageEffects` (`Player.getHurtSound`). pub(super) fn player_hurt_sound(&mut self, sound: &str, at: [f64; 3]) { diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 8c316deeb..f28049fd5 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -12,6 +12,7 @@ use horizon_client::{ hud_layout, hud_overlays, mesher::Vertex, particles::{ParticleOptions, ParticleType}, + text::Text, }; use horizon_core::{ geometry::{Aabb, Vec3}, @@ -1870,7 +1871,7 @@ impl Game<'_> { pl.velocity.z += zd / dd * 4.0; } if !sitting { - g.hurt_player_by("minecraft:mob_attack", 5.0); + g.dragon_hurts_player("minecraft:mob_attack", 5.0); } }); } @@ -1879,7 +1880,7 @@ impl Game<'_> { for h in heads { if h.inflate(Vec3::new(1.0, 1.0, 1.0)).intersects(p.bounds) { self.as_fight_player(p.who, |g| { - g.hurt_player_by("minecraft:mob_attack", 10.0); + g.dragon_hurts_player("minecraft:mob_attack", 10.0); }); } } @@ -2161,10 +2162,20 @@ impl Game<'_> { self.breath_clouds.append(&mut clouds); for (who, amount) in harmed { self.as_fight_player(who, |g| { - g.hurt_player_by("minecraft:indirect_magic", amount); + g.dragon_hurts_player("minecraft:indirect_magic", amount); }); } } + /// Damage from the dragon, which is its causing entity + /// (`DamageSources.mobAttack(dragon)`, `indirectMagic(cloud, dragon)`): the + /// death message names it. + fn dragon_hurts_player(&mut self, damage_type: &str, amount: f32) { + if let Some(id) = self.dragon.as_ref().map(|d| d.id) { + let name = Text::translate("entity.minecraft.ender_dragon", &[]); + self.note_named_attacker(damage_type, id, name); + } + self.hurt_player_by(damage_type, amount); + } /// `BossHealthOverlay.extractRenderState`: whatever `publish_boss_bars` /// (or a server's packets) put on this client's overlay. pub(super) fn draw_boss_bars(&self, batch: &mut HudBatch) { From e7f41e7d13e7d4216908982a3b11c4e7f7194e8f Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 10:51:26 +0100 Subject: [PATCH 31/62] Performance preset: keep animated textures on The preset turned them off, which froze fire, water, lava and portals. Players reported fire with no animation (#2064). The option stays in Advanced Graphics for anyone who wants it off. --- crates/horizon-client/src/graphics.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs index b51a586ab..b34b55288 100644 --- a/crates/horizon-client/src/graphics.rs +++ b/crates/horizon-client/src/graphics.rs @@ -444,7 +444,7 @@ pub fn apply_preset(preset: Preset, s: &mut crate::settings::Settings) { let g = &mut s.horizon; g.preset = preset; g.cave_culling = true; - g.animated_textures = preset != Preset::Performance; + g.animated_textures = true; g.chunk_updates = 0; g.upload_budget_kib = 0; g.sky = true; From c80b3b4950363386a52fb3ddaaa9241f535f869a Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 10:58:41 +0100 Subject: [PATCH 32/62] Multiplayer: no break particles or sound when a player puts out fire The predicted break played the block's break sound (wool for fire) and its destroy particles. BaseFireBlock skips both (spawnDestroyByEntityParticles does nothing); players only hear the server's extinguish sound. --- crates/horizon-client/src/game/remote.rs | 32 ++++++++++++++---------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 07ab0c80d..87e06d586 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3813,19 +3813,25 @@ impl Game<'_> { .and_modify(|p| p.0 = sequence) .or_insert((sequence, state.0 as i32)); } - let s = self.res.facts().get(state).sounds.clone(); - let at = [ - f64::from(pos[0]) + 0.5, - f64::from(pos[1]) + 0.5, - f64::from(pos[2]) + 0.5, - ]; - self.audio.play( - &s.break_sound, - Some(at), - (s.volume + 1.0) / 2.0, - s.pitch * 0.8, - ); - self.destroy_particles(pos, state); + // Block.playerWillDestroy's destroy event (particles and the break + // sound), which BaseFireBlock skips: the server's extinguish sound + // is all a player hears. + let facts = self.res.facts().get(state); + if !self.res.items().block_in_tag("minecraft:fire", &facts.name) { + let s = facts.sounds.clone(); + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]) + 0.5, + f64::from(pos[2]) + 0.5, + ]; + self.audio.play( + &s.break_sound, + Some(at), + (s.volume + 1.0) / 2.0, + s.pitch * 0.8, + ); + self.destroy_particles(pos, state); + } // The server's block update follows (waterlogged blocks leave water). let air = self.world.air; if self.world.set(pos[0], pos[1], pos[2], air).is_ok() { From 83f0d5bf582166a3114495eb20cf662f21078040 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:04:49 +0100 Subject: [PATCH 33/62] Worldgen data loads its three biggest parts in parallel GeneratorData::load read everything on the server thread while the chunk workers waited: the block tables, the structure templates and the block behaviours now load on threads of their own, and BlockBehavior::load reads its cached-support table beside the other two. The behaviour exports (gameplay-facts.json is 55 MB) parse from bytes in memory instead of through a reader. ThinkPad (2 cores), 3 alternated runs: 0.63 -> 0.45 s with the behaviour snapshot cached, 2.40 -> 2.07 s on a first start. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/vanillagen.rs | 2 + crates/horizon-world/src/level/data.rs | 6 +- .../horizon-world/src/worldgen/generator.rs | 112 +++++++++++------- .../src/worldgen/generator_blocks.rs | 29 +++-- 4 files changed, 94 insertions(+), 55 deletions(-) diff --git a/crates/horizon-client/src/vanillagen.rs b/crates/horizon-client/src/vanillagen.rs index c890213c5..517b14f44 100644 --- a/crates/horizon-client/src/vanillagen.rs +++ b/crates/horizon-client/src/vanillagen.rs @@ -339,7 +339,9 @@ pub fn shared_data( if let Some((_, data)) = cache.iter().find(|(path, _)| path == dir) { return Ok(data.clone()); } + let started = std::time::Instant::now(); let data = GeneratorData::load(dir, registry)?; + log::info!("Horizon: worldgen data loaded in {:?}", started.elapsed()); cache.push((dir.to_owned(), data.clone())); Ok(data) } diff --git a/crates/horizon-world/src/level/data.rs b/crates/horizon-world/src/level/data.rs index e0ef0dca1..4635e8b05 100644 --- a/crates/horizon-world/src/level/data.rs +++ b/crates/horizon-world/src/level/data.rs @@ -16,7 +16,7 @@ use serde_json::Value; use std::{ collections::HashMap, fs::{self, File}, - io::{self, BufReader}, + io, path::Path, sync::Arc, }; @@ -582,8 +582,10 @@ fn fail(message: &str) -> io::Error { invalid(message) } +/// From the file's bytes in memory: several times faster than through a +/// reader on gameplay-facts.json (55 MB), which a first start parses. fn read_json(path: &Path) -> io::Result { - serde_json::from_reader(BufReader::new(File::open(path)?)).map_err(|e| invalid(e.to_string())) + serde_json::from_slice(&fs::read(path)?).map_err(|e| invalid(e.to_string())) } fn interned(cache: &mut HashMap>, text: &str) -> Arc { diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs index 316bd837c..b554da9e3 100644 --- a/crates/horizon-world/src/worldgen/generator.rs +++ b/crates/horizon-world/src/worldgen/generator.rs @@ -269,6 +269,20 @@ fn quantize_parameter_report(json: &str) -> Result { } Ok(Value::Array(entries).to_string()) } +/// `load` on a thread of its own ("Worldgen loader"). +fn loading( + load: impl FnOnce() -> T + Send + 'static, +) -> io::Result> { + std::thread::Builder::new() + .name("Worldgen loader".into()) + .spawn(load) +} +/// A loading thread's result; its panic goes on in this thread. +fn joined(thread: std::thread::JoinHandle) -> T { + thread + .join() + .unwrap_or_else(|panic| std::panic::resume_unwind(panic)) +} impl GeneratorData { /// Load a worldgen bundle directory. Required files are JSON objects mapping /// resource identifiers to the resource's JSON text: `noises`, `densities`, @@ -290,6 +304,50 @@ impl GeneratorData { let block_tags = build_tags(&read_bundle(dir, "block_tags")?, |id| { registry.default_state(id).is_some() })?; + let fluid_tags = match read_optional_bundle(dir, "fluid_tags")? { + Some(raw) => build_tags(&raw, |id| { + matches!( + id, + "minecraft:water" + | "minecraft:flowing_water" + | "minecraft:lava" + | "minecraft:flowing_lava" + | "minecraft:empty" + ) + })?, + None => BTreeMap::new(), + }; + // The three biggest reads (the block tables, the structure templates + // and the block behaviours) need only the tags: they run on threads of + // their own while this one reads the rest. A new world's first chunks + // wait for all of it, with the chunk workers idle. + let blocks = loading({ + let (dir, tags, fluids) = (dir.join("blocks"), block_tags.clone(), fluid_tags.clone()); + move || super::generator_blocks::BlockBehavior::load(&dir, registry, &tags, &fluids) + })?; + let structures = loading({ + let (dir, tags) = (dir.to_owned(), block_tags.clone()); + move || -> Result<_, GeneratorError> { + let Ok(json) = fs::read_to_string(dir.join("blocks/structure-blocks.json")) else { + return Ok(None); + }; + Ok(Some(Arc::new(super::structure::StructureResources::new( + registry, + super::structure::StateTransforms::from_json(&json, registry.len())?, + &dir.join("structure"), + read_optional_bundle(&dir, "processor_lists")?.unwrap_or_default(), + &tags, + )))) + } + })?; + let behaviours = loading({ + let root = dir.parent().map(Path::to_owned); + move || { + root.filter(|root| root.join("block-behaviours.json").exists()) + .and_then(|root| crate::level::Behaviours::load(registry, &root).ok()) + .map(Arc::new) + } + })?; let tag_set = |name: &str| -> Result, GeneratorError> { Ok(block_tags .get(name) @@ -382,47 +440,17 @@ impl GeneratorData { read_optional_bundle(dir, "features")?, read_optional_bundle(dir, "placed_features")?, ) { - (Some(features), Some(placed)) => { - let fluid_tags = match read_optional_bundle(dir, "fluid_tags")? { - Some(raw) => build_tags(&raw, |id| { - matches!( - id, - "minecraft:water" - | "minecraft:flowing_water" - | "minecraft:lava" - | "minecraft:flowing_lava" - | "minecraft:empty" - ) - })?, - None => BTreeMap::new(), - }; - Some(FeatureResources { - features, - placed, - feature_tags: read_optional_bundle(dir, "feature_tags")?.unwrap_or_default(), - blocks: super::generator_blocks::BlockBehavior::load( - &dir.join("blocks"), - registry, - &block_tags, - &fluid_tags, - )?, - fluid_tags, - state_providers: read_optional_bundle(dir, "state_providers")? - .unwrap_or_default(), - }) - } + (Some(features), Some(placed)) => Some(FeatureResources { + features, + placed, + feature_tags: read_optional_bundle(dir, "feature_tags")?.unwrap_or_default(), + blocks: joined(blocks)?, + fluid_tags, + state_providers: read_optional_bundle(dir, "state_providers")?.unwrap_or_default(), + }), _ => None, }; - let structures = match fs::read_to_string(dir.join("blocks/structure-blocks.json")) { - Ok(json) => Some(Arc::new(super::structure::StructureResources::new( - registry, - super::structure::StateTransforms::from_json(&json, registry.len())?, - &dir.join("structure"), - read_optional_bundle(dir, "processor_lists")?.unwrap_or_default(), - &block_tags, - ))), - Err(_) => None, - }; + let structures = joined(structures)?; let structure_resources = match ( read_optional_bundle(dir, "structures")?, read_optional_bundle(dir, "structure_sets")?, @@ -435,11 +463,7 @@ impl GeneratorData { }), _ => None, }; - let behaviours = dir - .parent() - .filter(|root| root.join("block-behaviours.json").exists()) - .and_then(|root| crate::level::Behaviours::load(registry, root).ok()) - .map(Arc::new); + let behaviours = joined(behaviours); Ok(Arc::new(Self { behaviours, structure_resources, diff --git a/crates/horizon-world/src/worldgen/generator_blocks.rs b/crates/horizon-world/src/worldgen/generator_blocks.rs index ed1182f36..7498b9e66 100644 --- a/crates/horizon-world/src/worldgen/generator_blocks.rs +++ b/crates/horizon-world/src/worldgen/generator_blocks.rs @@ -108,15 +108,26 @@ impl BlockBehavior { let json = |name: &str| -> Result { Ok(serde_json::from_str(&fs::read_to_string(dir.join(name))?)?) }; - let collisions = - CachedCollisionRegistry::from_table(read("cached-collision.nbt")?.table("collision")?)?; - let properties = BlockPropertiesRegistry::from_table( - read("block-properties.nbt")?.table("block property")?, - &collisions, - )?; - let support = Arc::new(BlockSupportRegistry::from_table( - read("cached-support.nbt")?.table("support")?, - )?); + // The support table reads on its own thread while the collision and + // property tables (which need the collisions) read on this one. + let (collisions, properties, support) = std::thread::scope(|scope| { + let support = scope.spawn(|| -> Result<_, GeneratorError> { + Ok(BlockSupportRegistry::from_table( + read("cached-support.nbt")?.table("support")?, + )?) + }); + let collisions = CachedCollisionRegistry::from_table( + read("cached-collision.nbt")?.table("collision")?, + )?; + let properties = BlockPropertiesRegistry::from_table( + read("block-properties.nbt")?.table("block property")?, + &collisions, + )?; + let support = support + .join() + .unwrap_or_else(|panic| std::panic::resume_unwind(panic))?; + Ok::<_, GeneratorError>((collisions, properties, Arc::new(support))) + })?; let collision = Arc::new(BlockCollisionRegistry::new(Arc::new(collisions))?); let rules = json("survival-rules.json")? .as_object() From 311c0f7392d45ebf72ed637367d14c98978a614d Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 11:05:49 +0100 Subject: [PATCH 34/62] Stop endermen teleporting nonstop in the End The End has a fixed time and no precipitation, so endermen there must not flee daylight or take rain damage. --- crates/horizon-client/src/mobs/ai.rs | 2 +- crates/horizon-client/src/mobs/enderman.rs | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index c9bc15fda..e2043772a 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -521,7 +521,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } if m.kind.flags.water_sensitive - && (m.fluids.in_water || w.raining && w.can_see_sky(ex, ey, ez)) + && (m.fluids.in_water || w.raining && !w.end && w.can_see_sky(ex, ey, ez)) { m.damage(1.0, Damage::of(DamageKind::Drown)); } diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs index fcfba832e..85967e96e 100644 --- a/crates/horizon-client/src/mobs/enderman.rs +++ b/crates/horizon-client/src/mobs/enderman.rs @@ -138,9 +138,10 @@ fn teleport_towards( let z = m.position.z + (m.random.next_double() - 0.5) * 8.0 - d[2] * 16.0; teleport_to(m, w, x, y, z, events) } -/// Enderman.customServerAiStep: in daylight, flee by teleporting. +/// Enderman.customServerAiStep: in daylight, flee by teleporting. The End has a +/// fixed time, so `Level.isBrightOutside` is never true there. pub fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { - if cx.w.daylight && m.age as i32 >= m.extra.counter + 600 { + if cx.w.daylight && !cx.w.end && m.age as i32 >= m.extra.counter + 600 { let br = super::hostile::mob_brightness(m, cx.w); let (x, y, z) = ( m.position.x.floor() as i32, @@ -185,6 +186,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } if (m.fluids.in_water || w.raining + && !w.end && w.can_see_sky( m.position.x.floor() as i32, m.eye_y().floor() as i32, From 34d8d94022e0deaa84f27f4c6108804434f601da Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:06:02 +0100 Subject: [PATCH 35/62] parity: server harnesses wait on the server's clock and replies, not on sleeps server_knockback, locator_bar, server_dimension_players and their one-player users now end a step by the server's game clock (a sync round trip, N ticks, a last sync) the way server_player_targets does, so a server that stalls under load still gets all its ticks inside the step. server_knockback's frozen section waits for the stepped tick, the stopped clock and the landed hit; dedicated_server waits for the player's leaving before /list. Co-Authored-By: Claude Sonnet 5.5 --- .../horizonlab/parity/KnockbackClient.java | 41 ++++++- tools/test_dedicated_server_parity.py | 15 ++- tools/test_locator_bar_parity.py | 102 +++++++++++------ tools/test_server_dimension_players_parity.py | 48 ++++---- tools/test_server_knockback_parity.py | 105 ++++++++++++++---- 5 files changed, 225 insertions(+), 86 deletions(-) diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java index d8c0483b6..0c02fa9aa 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java @@ -5,9 +5,12 @@ import io.netty.buffer.Unpooled; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.DataInputStream; +import java.io.FileDescriptor; +import java.io.FileOutputStream; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; +import java.io.PrintStream; import java.io.PrintWriter; import java.net.InetSocketAddress; import java.net.Socket; @@ -76,7 +79,8 @@ import net.minecraft.world.phys.Vec3; * {@code step LABEL}, {@code join NAME}, {@code cmd NAME COMMAND...} (waits * for its feedback), {@code pos NAME X Y Z YAW PITCH GROUND} (one client tick * at that place, on the ground or not), {@code sprint NAME on|off}, {@code - * attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a + * sync NAME} (a round trip through the server thread; "synced NAME" on stdout when + * it is back), {@code attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a * player's name or an entity type's path, the last one added), {@code use * NAME} (ServerboundUseItemPacket, main hand) and {@code end}. Each player * records the ClientboundSetEntityMotionPacket it receives, its own sprint @@ -88,6 +92,8 @@ public final class KnockbackClient { private static final Map NAMES = new LinkedHashMap<>(); public static void main(String[] args) throws Exception { + // Bootstrap sends System.out to the logger: `synced` lines go to the real stdout. + PrintStream stdout = new PrintStream(new FileOutputStream(FileDescriptor.out), true, StandardCharsets.UTF_8); ParityData.init(); String host = args[0]; int port = Integer.parseInt(args[1]); @@ -116,6 +122,13 @@ public final class KnockbackClient { case "attack" -> players.get(w[1]).attack(w[2]); case "use" -> players.get(w[1]).send(new ServerboundUseItemPacket(InteractionHand.MAIN_HAND, 0, 0, 0)); case "punch" -> players.get(w[1]).send(net.minecraft.network.protocol.game.ServerboundPunchPacket.INSTANCE); + case "sync" -> { + try { + players.get(w[1]).sync(); + } finally { + stdout.println("synced " + w[1]); + } + } case "mark" -> players.get(w[1]).mark(); case "await" -> players.get(w[1]).await(); case "end" -> { @@ -157,6 +170,7 @@ public final class KnockbackClient { private final Map last = new java.util.concurrent.ConcurrentHashMap<>(); private final Object replyLock = new Object(); private int replies; + private int syncs; /** The motion packets about this player it was sent, and how many there were at the last `mark`. */ private int pushes; private int marked; @@ -181,6 +195,24 @@ public final class KnockbackClient { } } + /** A round trip through the server thread, its reply left out of the transcript: every packet this player + * was sent before the reply has been recorded when it returns. */ + void sync() throws Exception { + synchronized (replyLock) { + int before = syncs; + send(new ServerboundChatCommandPacket("time query gametime")); + long until = System.nanoTime() + 30_000_000_000L; + while (syncs == before) { + long left = (until - System.nanoTime()) / 1_000_000L; + if (left <= 0) { + record("error no reply to sync"); + return; + } + replyLock.wait(left); + } + } + } + void mark() { synchronized (replyLock) { marked = pushes; @@ -327,6 +359,13 @@ public final class KnockbackClient { for (var value : d.packedItems()) { if (value.id() == 0) record("sprinting " + ((((Byte) value.value()) & 8) != 0)); } + } else if (p instanceof ClientboundSystemChatPacket c + && c.content().getContents() instanceof net.minecraft.network.chat.contents.TranslatableContents t + && t.getKey().equals("commands.time.query.gametime")) { + synchronized (replyLock) { + syncs++; + replyLock.notifyAll(); + } } else if (p instanceof ClientboundSystemChatPacket c) { record("chat " + c.content().getString()); synchronized (replyLock) { diff --git a/tools/test_dedicated_server_parity.py b/tools/test_dedicated_server_parity.py index 49a934987..1f3870681 100644 --- a/tools/test_dedicated_server_parity.py +++ b/tools/test_dedicated_server_parity.py @@ -200,6 +200,17 @@ def game_time(server, timeout=300): raise AssertionError(f'{server.log_path.name}: no game time in {timeout:.0f} s') +def wait_ticks(server, count, timeout=300): + """Waits until the server's game clock has advanced `count` ticks: a server that stalls under load still gets + as many ticks as an idle one, where a sleep gives it fewer. (Not while ticking is frozen.)""" + deadline = time.time() + timeout + until = game_time(server, timeout) + count + while game_time(server, max(1.0, deadline - time.time())) < until: + if time.time() > deadline: + raise AssertionError(f'{server.log_path.name}: the game clock did not advance {count} ticks in {timeout} s') + time.sleep(0.2) + + def legacy_ping(port): """The reply to a 1.6 client's 0xFE 0x01 0xFA MC|PingHost query (LegacyQueryHandler).""" host = 'localhost' @@ -327,7 +338,9 @@ def run_side(label, command, directory, client): joined.join() if failure: raise failure[0] - time.sleep(1) + # The client has gone; `list` must find no one, once the server has handled its leaving (a busy machine + # took longer than a second). + server.wait_for(rf'{PLAYER} left the game', timeout=60) server.console('list') server.console('say console says hi') server.wait_for(r'\[Server\] console says hi', timeout=30) diff --git a/tools/test_locator_bar_parity.py b/tools/test_locator_bar_parity.py index 985b87a35..6574af76e 100644 --- a/tools/test_locator_bar_parity.py +++ b/tools/test_locator_bar_parity.py @@ -23,15 +23,14 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server, free_port + from .test_dedicated_server_parity import Server, free_port, wait_ticks except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server, free_port + from test_dedicated_server_parity import Server, free_port, wait_ticks NAME = 'locator-bar-parity' PROPERTIES = { @@ -82,7 +81,7 @@ SCRIPT = [ ('creative', [], ['cmd Bob gamemode creative', 'cmd Bob tp @s 6.5 100 0.5']), ('bob-leaves', [], ['quit Bob']), ] -STEP_SECONDS = 2.0 +STEP_TICKS = 40 # Vanilla's server moves a player who just joined on their own first ticks (a tiny step and back), which tracks # them where they spawned; Horizon does not simulate its guests. These steps compare what the bar shows at # their end (Bob has moved by then) rather than every packet. @@ -147,6 +146,47 @@ def server_dir(directory, world=None): return port +class Client: + """A LocatorBarClient process driven by a script on its stdin. A step ends by the server's clock, not the wall's: + every script line has run (`sync`), the server has ticked `ticks` more times, and each client holds what the + server sent until then (a last `sync`). A server that stalls under load still gets all its ticks in the step, + where a fixed sleep filed a stalled server's packets under the next step.""" + + def __init__(self, command, port, out, log): + self.log = log + self.process = subprocess.Popen([*map(str, command), '127.0.0.1', str(port), str(out)], cwd=lab.ROOT, + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True) + + def tell(self, line): + self.process.stdin.write(line + '\n') + self.process.stdin.flush() + + def sync(self, names): + """Every line told so far has run for these joined players, and they have received what the server sent + before.""" + for name in names: + self.tell(f'sync {name}') + for name in names: + while (line := self.process.stdout.readline()) != f'synced {name}\n': + if not line: + raise AssertionError(f'the client exited (see {self.log.name})') + self.log.write(line) + + def wait(self, server, names, ticks): + self.sync(names) + wait_ticks(server, ticks) + self.sync(names) + + def end(self): + self.tell('end') + self.log.write(self.process.communicate(timeout=60)[0]) + + def kill(self): + if self.process.poll() is None: + self.process.kill() + + def generate_world(server_command, build): """The flat world both servers load, made once by vanilla: players appear at its spawn itself (respawn_radius 0), on the ground at 0 -60 0, and the chunks around it are saved.""" @@ -176,28 +216,26 @@ def run_side(label, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + client = Client(client_command, port, out, log) + joined = [] try: for step, console, actions in SCRIPT: - client.stdin.write(f'step {step}\n') - client.stdin.flush() + client.tell(f'step {step}') for command in console: server.console(command) for action in actions: - client.stdin.write(action + '\n') - client.stdin.flush() - if action.startswith('join'): + client.tell(action) + verb, *rest = action.split() + if verb == 'join': # Joining takes the world's first chunks: wait for the server to place the player. - server.wait_for(rf'{action.split()[1]} joined the game', timeout=120) - time.sleep(STEP_SECONDS) - client.stdin.write('end\n') - client.stdin.flush() - client.wait(timeout=60) + server.wait_for(rf'{rest[0]} joined the game', timeout=120) + joined.append(rest[0]) + elif verb == 'quit': + joined.remove(rest[0]) + client.wait(server, joined, STEP_TICKS) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): @@ -234,10 +272,11 @@ def sides(name): def one_player(name, script, shown, check, scope, step_seconds=4.0): """A harness of one player, Alice: on each server she joins, then runs `script`, a list of (step, client - actions) `step_seconds` apart. The lines `shown(transcript)` keeps must match vanilla's exactly, and + actions) that each last `step_seconds` of the server's time (20 ticks a second). The lines `shown(transcript)` keeps must match vanilla's exactly, and `check(vanilla's shown lines, vanilla's transcript)` returns why vanilla's run is no proof (the script did not run), or None.""" lock, build, vanilla_server, horizon_server, client = sides(name) + ticks = round(step_seconds * 20) def run(label, server_command, world): directory = build / label @@ -248,27 +287,20 @@ def one_player(name, script, shown, check, scope, step_seconds=4.0): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - process = subprocess.Popen([*map(str, client), '127.0.0.1', str(port), str(out)], cwd=lab.ROOT, - stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, text=True) - - def tell(line): - process.stdin.write(line + '\n') - process.stdin.flush() + session = Client(client, port, out, log) try: for line in ['players on', 'state on', 'step joins', 'join Alice']: - tell(line) + session.tell(line) server.wait_for(r'Alice joined the game', timeout=120) - time.sleep(step_seconds) + session.wait(server, ['Alice'], ticks) for step, actions in script: - tell(f'step {step}') + session.tell(f'step {step}') for action in actions: - tell(action) - time.sleep(step_seconds) - tell('end') - process.wait(timeout=60) + session.tell(action) + session.wait(server, ['Alice'], ticks) + session.end() finally: - if process.poll() is None: - process.kill() + session.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_server_dimension_players_parity.py b/tools/test_server_dimension_players_parity.py index b1efc4378..82fb2817f 100644 --- a/tools/test_server_dimension_players_parity.py +++ b/tools/test_server_dimension_players_parity.py @@ -16,17 +16,16 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base from .test_dedicated_server_parity import Server - from .test_locator_bar_parity import generate_world, server_dir + from .test_locator_bar_parity import Client, generate_world, server_dir except ImportError: import lab import test_rust_parity as base from test_dedicated_server_parity import Server - from test_locator_bar_parity import generate_world, server_dir + from test_locator_bar_parity import Client, generate_world, server_dir NAME = 'server-dimension-players-parity' NETHER, END, OVERWORLD = 'minecraft:the_nether', 'minecraft:the_end', 'minecraft:overworld' @@ -42,7 +41,8 @@ SCRIPT = [ ('bob-portal', ['cmd Bob setblock 2 101 3 minecraft:end_portal', 'cmd Bob tp @s 2.5 101 3.5']), ('bob-portal-back', [f'cmd Bob execute in {OVERWORLD} run tp @s 2.5 100 0.5']), ] -STEP_SECONDS = 5.0 +PLAYERS = ('Alice', 'Bob') +STEP_TICKS = 100 def run_side(label, server_command, client_command, build, world): @@ -54,38 +54,30 @@ def run_side(label, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) - - def tell(line): - client.stdin.write(line + '\n') - client.stdin.flush() + client = Client(client_command, port, out, log) try: - tell('players on') - tell('step joins') - for name, x in (('Alice', 0.5), ('Bob', 2.5)): - tell(f'join {name}') + client.tell('players on') + client.tell('step joins') + for name, x in zip(PLAYERS, (0.5, 2.5)): + client.tell(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - tell(f'fly {name} on') - tell(f'cmd {name} tp @s {x} 100 0.5') - time.sleep(STEP_SECONDS) + client.tell(f'fly {name} on') + client.tell(f'cmd {name} tp @s {x} 100 0.5') + client.wait(server, PLAYERS, STEP_TICKS) for step, actions in SCRIPT: - tell(f'step {step}') + client.tell(f'step {step}') for action in actions: - tell(action) + client.tell(action) # Standing still, a client still sends its position every 20 ticks # (LocalPlayer.sendPosition): the server then tracks to it what it has sent the # chunks of since (ChunkMap.move). - time.sleep(STEP_SECONDS / 2) - tell('still Alice') - tell('still Bob') - time.sleep(STEP_SECONDS / 2) - tell('end') - client.wait(timeout=60) + client.wait(server, PLAYERS, STEP_TICKS // 2) + for name in PLAYERS: + client.tell(f'still {name}') + client.wait(server, PLAYERS, STEP_TICKS // 2) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_server_knockback_parity.py b/tools/test_server_knockback_parity.py index d7fbaeba1..66b75946e 100644 --- a/tools/test_server_knockback_parity.py +++ b/tools/test_server_knockback_parity.py @@ -18,6 +18,11 @@ players made of vanilla's protocol code, joins them both and runs one script on travelled a tick (the mob's hit, then ServerPlayer's travel, then ServerEntity.sendChanges). It is night, so that no zombie burns (a burning mob is in its hurt cooldown). +The script waits on the server, not on the wall: `ticks N` is N ticks of its game clock (with a `sync` round trip +before and after, so each client holds what the server sent), `tickstep` is one `/tick step` that has run, `frozen` +a frozen game that has stopped, and `hit` a hit that has landed (a frozen server still ticks its players, so a hit +lands in Alice's next tick). A server that stalls under load gets the same ticks as an idle one. + Each case is compared on its own. KNOWN lists the cases Horizon still gets wrong and why; one that matches again is reported, and should leave the list. """ @@ -32,15 +37,16 @@ import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server, free_port + from .test_dedicated_server_parity import Server, free_port, game_time, wait_ticks from .test_locator_bar_parity import generate_world, ops_json except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server, free_port + from test_dedicated_server_parity import Server, free_port, game_time, wait_ticks from test_locator_bar_parity import generate_world, ops_json NAME = 'server-knockback-parity' +PLAYERS = ('Alice', 'Bob') PROPERTIES = { 'online-mode': 'false', 'white-list': 'false', @@ -82,18 +88,17 @@ def mob_case(kind, weapon=SWORD, sprint=False, crit=False, air=False): f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true'] lines = ['cmd Alice kill @e[type=!player]', 'cmd Alice gamemode creative', 'cmd Bob gamemode creative', f'cmd Alice item replace entity @s weapon.mainhand with {weapon}', 'cmd Alice tp Bob 2.5 -60 12.5', - *stand('Alice', A, -90), 'sleep 1.2'] + *stand('Alice', A, -90), 'ticks 24'] # In the air: frozen before its first tick, so it has not landed. - lines += ['cmd Alice tick freeze', *summon] if air else [*summon, 'sleep 1.5', 'cmd Alice tick freeze'] - lines += ['sleep 0.3', f'cmd Alice data get entity {mob} Pos'] + lines += ['cmd Alice tick freeze', 'frozen', *summon] if air else [*summon, 'ticks 30', 'cmd Alice tick freeze', 'frozen'] + lines += [f'cmd Alice data get entity {mob} Pos'] if sprint: lines.append('sprint Alice on') if crit: lines += falling(0.8) - lines += ['sleep 0.2', f'attack Alice {kind}', 'sleep 0.2', f'cmd Alice data get entity {mob} Motion'] + lines += [f'hit {kind}', f'cmd Alice data get entity {mob} Motion'] for _ in range(20): - lines += ['cmd Alice tick step 1', 'sleep 0.25', f'cmd Alice data get entity {mob} Pos', - f'cmd Alice data get entity {mob} Motion'] + lines += ['tickstep', f'cmd Alice data get entity {mob} Pos', f'cmd Alice data get entity {mob} Motion'] lines += ['cmd Alice tick unfreeze', 'cmd Alice kill @e[type=!player]'] if sprint: lines.append('sprint Alice off') @@ -114,7 +119,7 @@ def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, if shield: # A shield blocks from five ticks after it is raised. lines += ['cmd Bob item replace entity @s weapon.mainhand with minecraft:shield', 'use Bob'] - lines += ['sleep 1.5', *stand('Bob', V, 90, ticks=1)] + lines += ['ticks 30', *stand('Bob', V, 90, ticks=1)] if sprint: lines.append('sprint Alice on') if crit: @@ -124,10 +129,12 @@ def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, if cooldown: # A swing at the air first: the hit is weak, and the stronger one four ticks later lands inside Bob's hurt # cooldown (LivingEntity.hurtServer: it hurts by the difference, with no knockback and no motion packet). - lines += ['sleep 0.2', 'punch Alice', 'attack Alice Bob'] - lines += ['sleep 0.2', 'attack Alice Bob', 'sleep 0.3'] + lines += ['ticks 4', 'punch Alice', 'attack Alice Bob'] + # The gap between those two hits is an upper bound on the server's ticks, so a stalled server (which gets + # fewer in a wall's 0.2 s) still lands the second inside the cooldown; the rest is to have the server's ticks. + lines += ['sleep 0.2' if cooldown else 'ticks 4', 'attack Alice Bob', 'ticks 6'] if twice: - lines += [*stand('Bob', V, 90, ticks=20), 'sleep 1.5', 'attack Alice Bob', 'sleep 0.3'] + lines += [*stand('Bob', V, 90, ticks=20), 'ticks 30', 'attack Alice Bob', 'ticks 6'] if sprint: lines.append('sprint Alice off') lines += stand('Alice', A, -90) @@ -144,7 +151,7 @@ def mob_hits_case(kind): hit = ['mark Bob', f'cmd Alice summon minecraft:{kind} {V[0] + 1} {V[1]} {V[2]} {{Rotation:[90f,0f]}}', f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true', 'await Bob', f'cmd Alice kill {mob}'] return ['cmd Bob clear @s', 'cmd Bob effect give @s minecraft:resistance 1000 4 true', 'cmd Alice gamemode creative', - *stand('Bob', V, 90), *hit, 'sleep 2', *stand('Bob', V, 90), *hit, 'sleep 1', + *stand('Bob', V, 90), *hit, 'ticks 40', *stand('Bob', V, 90), *hit, 'ticks 20', 'cmd Alice kill @e[type=!player]', 'cmd Alice gamemode survival'] @@ -173,7 +180,20 @@ CASES = { } SETUP = ['cmd Alice gamerule spawn_mobs false', 'cmd Alice gamerule spawn_monsters false', 'cmd Alice kill @e[type=!player]', 'cmd Alice gamerule advance_time false', 'cmd Alice time set midnight', - f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'sleep 2'] + f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'ticks 40'] + + +def server_data(server, selector, path, timeout=120): + """An entity's data, asked from the console (its reply stays in the server's log, out of the clients').""" + deadline = time.time() + timeout + start = len(server.lines) + server.console(f'data get entity {selector} {path}') + while time.time() < deadline: + for line in server.lines[start:]: + if 'has the following entity data' in line: + return line.split('data: ', 1)[-1] + time.sleep(0.02) + raise AssertionError(f'{server.log_path.name}: no entity data in {timeout} s') def server_dir(directory, world): @@ -201,29 +221,72 @@ def run_side(label, server_command, client_command, build, world): server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True) + + def sync(): + """Every script line sent so far has run, and each client holds what its server sent before.""" + for name in PLAYERS: + client.stdin.write(f'sync {name}\n') + client.stdin.flush() + for name in PLAYERS: + while (reply := client.stdout.readline()) != f'synced {name}\n': + if not reply: + raise AssertionError(f'{label}: the client exited (see {build}/{label}-client.log)') + log.write(reply) def send(line): - if line.startswith('sleep '): + """A script line for the client, or one of ours: the waits are on the server's game clock, not the + wall's, so a server that stalls under load still gets the ticks each case needs.""" + word = line.split()[0] + if word == 'sleep': time.sleep(float(line.split()[1])) + elif word == 'ticks': + sync() + wait_ticks(server, int(line.split()[1])) + sync() + elif word == 'frozen': + # The tick in flight when ticking was frozen has finished: the clock reads the same twice. + sync() + while game_time(server) != game_time(server): + pass + elif word == 'hit': + # Alice hits the mob. A frozen server still ticks its players, and the hit lands in Alice's + # next tick, not when the packet arrives: the mob's motion says when it has. + sync() + mob = f'@e[type=minecraft:{line.split()[1]},limit=1]' + before = server_data(server, mob, 'Motion') + client.stdin.write(f'attack Alice {line.split()[1]}\n') + client.stdin.flush() + while server_data(server, mob, 'Motion') == before: + time.sleep(0.05) + sync() + elif word == 'tickstep': + # `/tick step 1` answers at once and the tick runs after: the clock says when it has. + sync() + before = game_time(server) + client.stdin.write('cmd Alice tick step 1\n') + client.stdin.flush() + while game_time(server) == before: + time.sleep(0.05) + sync() else: client.stdin.write(line + '\n') client.stdin.flush() try: - for name in ('Alice', 'Bob'): + for name in PLAYERS: send(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - time.sleep(2) + wait_ticks(server, 40) for line in SETUP: send(line) for case, lines in CASES.items(): send(f'step {case}') for line in lines: send(line) - time.sleep(0.5) + send('ticks 10') send('end') - client.wait(timeout=60) + log.write(client.communicate(timeout=60)[0]) finally: if client.poll() is None: client.kill() From 08f4fd5c8eafe7de5b27faf4d368dbe342d75831 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:10:18 +0100 Subject: [PATCH 36/62] Teleports free their dropped columns off the frame and in batches A teleport far away (or a storage that moves by more than its size) drops every column in one frame: 3,725 at RD 32. That frame freed every column's sections, then removed each section from the renderer one at a time, with a few hash lookups per section and a free-list tree update per mesh range. - The dropped columns, and a left dimension's whole chunk map, are freed on a short-lived thread of their own ("Chunk freeing"). - Renderer::remove_columns removes whole columns: one lookup per column for the tables kept by column, and the meshes' ranges go back to the arena in one sorted merge per page (FreeList::give_all) instead of a tree update each. Per-section Renderer::remove and Occlusion::remove had no other callers and are gone. - The renderer's block-entity and detail-column tables use FxHashMap. Mac mini (M4 Pro), RD 32, explored world, server thread, 3 alternated runs, two long teleports each: the drop took 26.1-39.7 ms, now 6.9-8.5 ms. Entering the Nether: 9.7-13.4 ms, now 4.0 ms or under 6 ms. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/chunk.rs | 14 ++++ crates/horizon-client/src/game.rs | 6 +- crates/horizon-client/src/game/remote.rs | 21 +++--- crates/horizon-client/src/gfx.rs | 55 ++++++++++---- crates/horizon-client/src/gfx/arena.rs | 87 ++++++++++++++++++++++ crates/horizon-client/src/gfx/occlusion.rs | 27 +++++-- 6 files changed, 174 insertions(+), 36 deletions(-) diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs index 41330df5f..c0bec476b 100644 --- a/crates/horizon-client/src/chunk.rs +++ b/crates/horizon-client/src/chunk.rs @@ -24,6 +24,20 @@ pub fn block_strategy() -> Strategy { Strategy::blocks(BLOCK_BITS.load(std::sync::atomic::Ordering::Relaxed)) } +/// Frees `columns` (`count` of them) on a short-lived thread of its own +/// when there are many: a teleport or a dimension change drops a few +/// thousand columns at once, and freeing their sections took the frame +/// 15-20 ms. A few are freed here. +pub fn free_columns(columns: T, count: usize) { + if count < 64 { + return; + } + // Should the thread not start, the closure drops `columns` here. + let _ = std::thread::Builder::new() + .name("Chunk freeing".into()) + .spawn(move || drop(columns)); +} + /// Sizes the block states' global palette for a registry of `states`. pub fn set_block_states(states: usize) { let bits = horizon_core::paletted::ceil_log2(states).max(16); diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 8591c721f..17d8586ec 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -11011,11 +11011,7 @@ impl Game<'_> { bytes += size; } } - for c in unloaded { - for sy in 0..(HEIGHT / 16) { - renderer.remove((c.x, sy, c.z)); - } - } + renderer.remove_columns(unloaded.iter().map(|c| (c.x, c.z))); if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) { let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info); lod.set_near_loading(self.streaming.busy()); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 07ab0c80d..b8153ff0a 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -11,7 +11,7 @@ use super::{Dim, Game, Mining, Screen}; use horizon_client::first_person::{Hand, SwingAnimation}; use horizon_client::{ Result, - chunk::{Chunk, SECTIONS}, + chunk::Chunk, containers::{BlockEntity, Furnace, FurnaceKind}, entities::{Experience, ExperienceOrb, ItemEntity}, hud::{HudBatch, rgba}, @@ -998,6 +998,9 @@ impl Game<'_> { self.world.day_time, self.world.weather, ); + let old = std::mem::take(&mut self.world.chunks); + let count = old.len(); + horizon_client::chunk::free_columns(old, count); self.world = World::new(self.res.facts().air, spawn.seed); self.world.game_time = time; self.world.day_time = day; @@ -1059,14 +1062,14 @@ impl Game<'_> { if gone.is_empty() { return; } + let mut freed = Vec::with_capacity(gone.len()); for &(x, z) in &gone { - self.streaming.forget(&mut self.world, x, z); - if let Some(renderer) = self.renderer.as_mut() { - for sy in 0..SECTIONS as i32 { - renderer.remove((x, sy, z)); - } - } + freed.extend(self.streaming.forget(&mut self.world, x, z)); } + if let Some(renderer) = self.renderer.as_mut() { + renderer.remove_columns(gone.iter().copied()); + } + horizon_client::chunk::free_columns(freed, gone.len()); // One pass for all of them. self.world .block_entities @@ -1631,9 +1634,7 @@ impl Game<'_> { .block_entities .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); if let Some(renderer) = self.renderer.as_mut() { - for sy in 0..SECTIONS as i32 { - renderer.remove((x, sy, z)); - } + renderer.remove_columns([(x, z)]); } } C::ChunkBatchFinished(_) => { diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 78f73bc8b..a9ae26cf2 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -459,7 +459,7 @@ pub struct Renderer { lod_retiring: crate::fast_hash::FxHashSet, /// Finished tile meshes `upload_lods` has yet to upload. lod_pending: Option, - detail_columns: HashMap<(i32, i32), u32>, + detail_columns: crate::fast_hash::FxHashMap<(i32, i32), u32>, /// Bumped whenever a column becomes or stops being complete. detail_revision: u64, arena: arena::Arena, @@ -493,7 +493,7 @@ pub struct Renderer { /// The shadow camera's draws by page, in bands of distance from the light. shadow_runs: page_runs::PageRuns, /// Block-entity blocks per meshed section (world position, state id). - block_entities: HashMap>, + block_entities: crate::fast_hash::FxHashMap>, /// Changes whenever `block_entities` does (unique across renderers). block_entity_revision: u64, /// VisGraph face connectivity per meshed section (cave culling). @@ -2390,7 +2390,7 @@ impl Renderer { lod_cutout: Default::default(), lod_retiring: Default::default(), lod_pending: None, - detail_columns: HashMap::new(), + detail_columns: Default::default(), detail_revision: 0, arena, sorted_indices, @@ -2411,7 +2411,7 @@ impl Renderer { solid_runs: page_runs::PageRuns::default(), phase2_runs: page_runs::PageRuns::default(), shadow_runs: page_runs::PageRuns::default(), - block_entities: HashMap::new(), + block_entities: Default::default(), block_entity_revision: next_block_entity_revision(), occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16), world_post, @@ -2847,18 +2847,47 @@ impl Renderer { self.detail_columns.insert(column, next); } } - pub fn remove(&mut self, key: SectionKey) { - self.set_detail(key, false); - if self.block_entities.remove(&key).is_some() { + /// Every section of these columns goes: one lookup per column where the + /// tables are by column, and the meshes' ranges freed in one batch. A + /// teleport removes a few thousand columns in one frame. + pub fn remove_columns(&mut self, columns: impl IntoIterator) { + let mut released = Vec::new(); + let mut block_entities = false; + for (x, z) in columns { + if self.detail_columns.remove(&(x, z)) == Some(COMPLETE_COLUMN) { + self.detail_revision += 1; + } + self.occlusion.remove_column(x, z); + let retiring = !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(x, z)); + for sy in 0..crate::chunk::SECTIONS as i32 { + let key = (x, sy, z); + block_entities |= self.block_entities.remove(&key).is_some(); + if retiring { + // Distant tiles still leave its column out: drawn until they don't. + self.lod_retiring.insert(key); + } else if let Some(section) = self.sections.remove(key) { + released.push(section); + } + } + } + if block_entities { self.block_entity_revision = next_block_entity_revision(); } - self.occlusion.remove(key); - if !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(key.0, key.2)) { - // Distant tiles still leave its column out: drawn until they don't. - self.lod_retiring.insert(key); - } else { - self.release_section(key); + if let Some(flat) = &mut self.flat { + for id in released.iter().filter_map(|s| s.flat_id) { + flat.remove(id); + } } + self.sorted_indices + .release_all(released.iter().filter_map(|s| { + let (page, start) = s.sorted_indices?; + Some((page, start, u64::from(s.translucent) * 6)) + })); + self.arena.release_all( + released + .iter() + .map(|s| (s.page, s.start, u64::from(s.solid + s.translucent) * 4)), + ); } /// Horizon's resolution scale (world pixels per window pixel) and FXAA. pub fn set_world_post(&mut self, scale: f32, antialias: bool) { diff --git a/crates/horizon-client/src/gfx/arena.rs b/crates/horizon-client/src/gfx/arena.rs index 34b4d332d..8f320a408 100644 --- a/crates/horizon-client/src/gfx/arena.rs +++ b/crates/horizon-client/src/gfx/arena.rs @@ -39,6 +39,35 @@ impl FreeList { } self.0.insert(start, len); } + /// `give` for many ranges: one merge of the sorted ranges into the list, + /// where giving them one by one costs a few tree lookups each. + fn give_all(&mut self, mut ranges: Vec<(u64, u64)>) { + if ranges.len() < 64 { + for (start, len) in ranges { + self.give(start, len); + } + return; + } + ranges.sort_unstable(); + let mut free = std::mem::take(&mut self.0).into_iter().peekable(); + let mut given = ranges.into_iter().peekable(); + let mut merged: Vec<(u64, u64)> = Vec::new(); + loop { + let next = match (free.peek(), given.peek()) { + (Some(a), Some(b)) if a.0 <= b.0 => free.next(), + (_, Some(_)) => given.next(), + (Some(_), None) => free.next(), + (None, None) => break, + }; + let (start, len) = next.expect("peeked"); + match merged.last_mut() { + Some(last) if last.0 + last.1 == start => last.1 += len, + _ => merged.push((start, len)), + } + } + // Sorted: the tree is built in one pass. + self.0 = merged.into_iter().collect(); + } } /// One vertex buffer of the arena; only the newest page grows. @@ -237,6 +266,26 @@ impl Arena { .free .give(start, len); } + /// `release` for many ranges (page, start, vertices) at once. + pub fn release_all(&mut self, ranges: impl IntoIterator) { + let mut by_page: Vec> = Vec::new(); + for (page, start, vertices) in ranges { + let page = page as usize; + if by_page.len() <= page { + by_page.resize_with(page + 1, Vec::new); + } + by_page[page].push((start, Self::span(vertices).min(self.page_limit))); + } + for (page, ranges) in by_page.into_iter().enumerate() { + if !ranges.is_empty() { + self.pages[page] + .as_mut() + .expect("live arena page") + .free + .give_all(ranges); + } + } + } /// Moves a page into a larger buffer; false (the page unchanged) when /// there is no memory for it. fn grow( @@ -435,6 +484,44 @@ mod tests { assert_eq!(free, FreeList::new(4 * GRAIN)); } + #[test] + fn many_ranges_given_at_once_coalesce_as_one_by_one() { + let fill = || { + let mut free = FreeList::new(1 << 30); + let taken: Vec<(u64, u64)> = (0..500u64) + .map(|i| { + let len = GRAIN * (1 + i * 7 % 5); + (free.take(len).unwrap(), len) + }) + .collect(); + for &(start, len) in taken.iter().step_by(3) { + free.give(start, len); + } + (free, taken) + }; + // Every other range of those still taken, in a scattered order. + let (mut one_by_one, taken) = fill(); + let (mut at_once, _) = fill(); + let mut given: Vec<(u64, u64)> = (0..taken.len()) + .filter(|i| i % 3 != 0 && i % 2 == 0) + .map(|i| taken[i]) + .collect(); + given.sort_by_key(|&(start, _)| start.wrapping_mul(0x9E37_79B9_7F4A_7C15)); + assert!(given.len() >= 64); + for &(start, len) in &given { + one_by_one.give(start, len); + } + at_once.give_all(given); + assert_eq!(at_once, one_by_one); + // The rest too: everything is free again, in one range. + let rest: Vec<(u64, u64)> = (0..taken.len()) + .filter(|i| i % 3 != 0 && i % 2 != 0) + .map(|i| taken[i]) + .collect(); + at_once.give_all(rest); + assert_eq!(at_once, FreeList::new(1 << 30)); + } + #[test] fn first_fit_reuses_the_lowest_hole() { let mut free = FreeList::new(8 * GRAIN); diff --git a/crates/horizon-client/src/gfx/occlusion.rs b/crates/horizon-client/src/gfx/occlusion.rs index e17ba87d1..22e2f3c81 100644 --- a/crates/horizon-client/src/gfx/occlusion.rs +++ b/crates/horizon-client/src/gfx/occlusion.rs @@ -522,16 +522,27 @@ impl Occlusion { } pub fn set(&mut self, key: SectionKey, vis: u64) { if self.columns.set(key, vis) { - self.edits.push(Edit::Set(key, vis)); - self.dirty = true; - self.changed.push(key); - if self.running.is_some() { - self.changed_late.push(key); - } + self.changed(key, vis); } } - pub fn remove(&mut self, key: SectionKey) { - self.set(key, ALL_VISIBLE); + fn changed(&mut self, key: SectionKey, vis: u64) { + self.edits.push(Edit::Set(key, vis)); + self.dirty = true; + self.changed.push(key); + if self.running.is_some() { + self.changed_late.push(key); + } + } + /// Every section of the column `x`, `z` goes (sees through every face). + pub fn remove_column(&mut self, x: i32, z: i32) { + let Some(column) = self.columns.map.remove(&(x, z)) else { + return; + }; + for (y, &vis) in column.iter().enumerate() { + if vis != ALL_VISIBLE { + self.changed((x, y as i32, z), ALL_VISIBLE); + } + } } pub fn clear(&mut self) { self.columns.map.clear(); From 6b8fde092ff6bc41b0b5fd84fff03498161fcc8c Mon Sep 17 00:00:00 2001 From: socksprox Date: Mon, 26 Oct 2026 11:20:21 +0100 Subject: [PATCH 37/62] Keep 26.3's name-tag and text-display values Review caught three regressions against the pinned client jar: submitInner lines stay lineHeight+1 (10 px), submitNameTag fades discrete and see-through names with the same 0x7F, and lightCoordsWithEmission floors both light channels at 2. Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- crates/horizon-client/src/game/names.rs | 22 +++++-------------- .../horizon-client/src/game/text_displays.rs | 4 ++-- 2 files changed, 8 insertions(+), 18 deletions(-) diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index d62e064f7..f49550f77 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -252,27 +252,17 @@ impl Game<'_> { out: &mut Vec, see_through: &mut Vec, ) { - // renderNameTag's text colours: a discrete name's faded 0x20FFFFFF, - // the see-through copy's 0x80FFFFFF. - const DISCRETE: u32 = 0x20; - const FADED: u32 = 0x80; + // The text alpha that goes with getBackgroundOpacity(0.25): + // max((0.25 + 0.75) / 2, 0.5), as ARGB.color (the floor of 255 times it). + const FADED: u32 = 0x7F; for tag in self.name_tags(camera, alpha) { let o = tag.at - camera; if tag.discrete { - self.name_tag_quads( - o, - &tag.lines, - DISCRETE, - true, - 0, - vertex_light(tag.light), - out, - ); + self.name_tag_quads(o, &tag.lines, FADED, true, 0, vertex_light(tag.light), out); continue; } - // LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2): the block - // channel at least 2, the sky channel unchanged. - let lit = (tag.light & 0xF0) | (tag.light & 15).max(2); + // LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2). + let lit = (tag.light >> 4).max(2) << 4 | (tag.light & 15).max(2); self.name_tag_quads(o, &tag.lines, 0xFF, false, 0, vertex_light(lit), out); // RenderPipelines.TEXT_SEE_THROUGH: no depth test, no lightmap. self.name_tag_quads(o, &tag.lines, FADED, true, 2, 0, see_through); diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs index 45191e15e..b669c8357 100644 --- a/crates/horizon-client/src/game/text_displays.rs +++ b/crates/horizon-client/src/game/text_displays.rs @@ -198,7 +198,7 @@ impl Game<'_> { Lines { lines, width } }); let width = *width; - let height = lines.len() as f32 * 9.0 - 1.0; + let height = lines.len() as f32 * 10.0 - 1.0; matrix *= glam::Mat4::from_translation(glam::Vec3::new(1.0 - width / 2.0, -height, 0.0)); let mut batch = HudBatch::new([1, 1]); @@ -233,7 +233,7 @@ impl Game<'_> { atlas, line, x, - i as f32 * 9.0, + i as f32 * 10.0, rgba(255, 255, 255, d.opacity as u8), d.flags & 1 != 0, ); From c8132615742b62170412feae5aab463ca46f7168 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:35:15 +0100 Subject: [PATCH 38/62] Horizon shader packs: the material stage runs in the game A pack's `fn material(input: MaterialInput) -> Surface` now gives the lit colour of every terrain surface: sections and distant tiles, solid, cutout and translucent, in both the instanced and the flat draws. Terrain keeps Horizon's meshes, culling and draw lists; only its pipelines change. Their shader is the pack's stage, a prefixed copy of terrain.wgsl's terrain section, and entries that hand the pack the texture, the vertex tint, the light levels and the lightmap's colour apart, then apply the alpha test and fog as `fs_solid` and `fs_translucent` do. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 56 ++- .../horizon-client/src/gfx/native_material.rs | 328 ++++++++++++++++++ crates/horizon-client/src/gfx/native_pack.rs | 24 +- docs/api/shaders.md | 5 +- docs/shaders.md | 15 +- 5 files changed, 397 insertions(+), 31 deletions(-) create mode 100644 crates/horizon-client/src/gfx/native_material.rs diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 5ff14003c..6270135c5 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -67,6 +67,7 @@ mod end_sky; mod flat; pub mod lightning; mod lod; +mod native_material; mod native_pack; mod native_post; mod native_sky; @@ -429,6 +430,8 @@ pub struct Renderer { /// The mipmap levels sampled (the Mipmap Levels option), at most `mip_levels - 1`. mipmaps: u32, terrain_layout: wgpu::BindGroupLayout, + /// terrain.wgsl's `SPRITE_ARRAYS` and `SPRITE_SPLIT`, for a shader pack's terrain. + terrain_sprites: [f64; 2], sprite_sampler: wgpu::Sampler, lightmap_view: wgpu::TextureView, lightmap_sampler: wgpu::Sampler, @@ -2370,6 +2373,7 @@ impl Renderer { mip_levels, mipmaps: mip_levels - 1, terrain_layout: bindings, + terrain_sprites: sprite_constants.map(|(_, v)| v), sprite_sampler, lightmap_view, lightmap_sampler, @@ -2937,9 +2941,9 @@ impl Renderer { self.native = None; self.pack_atlas = None; } - /// Runs the sky and post stages of one of Horizon's own shader packs from now on (`None`: - /// no pack), with its options' values; replaces a `shaders/` pack. Returns the stages' - /// labels; on an error the pack that ran keeps running. + /// Runs the sky, material and post stages of one of Horizon's own shader packs from now + /// on (`None`: no pack), with its options' values; replaces a `shaders/` pack. Returns the + /// stages' labels; on an error the pack that ran keeps running. pub fn set_native_shader_pack( &mut self, pack: Option<(horizon_shader_api::Report, Vec<(String, f64)>)>, @@ -2948,14 +2952,14 @@ impl Renderer { self.native = None; return Ok(Vec::new()); }; - let format = self.config.format.remove_srgb_suffix(); - let (pack, labels) = native_pack::NativePack::new( - &self.device, - &self.terrain_layout, - report, - &constants, - format, - )?; + let terrain = native_material::TerrainShape { + globals: &self.terrain_layout, + flat: self.flat.as_ref().map(|f| &f.draw_layout), + sprites: self.terrain_sprites, + format: self.config.format.remove_srgb_suffix(), + }; + let (pack, labels) = + native_pack::NativePack::new(&self.device, &terrain, report, &constants)?; self.native = pack.draws().then_some(pack); if self.native.is_some() { self.pack_post = None; @@ -4179,6 +4183,21 @@ impl Renderer { pass.set_bind_group(0, &self.group, &[]); sky.draw(&mut pass, &native.frame); } + // One of Horizon's own packs with a material stage: terrain draws with its pipelines, + // which read the pack's frame at group 3. + let material = self + .native + .as_ref() + .filter(|_| !frame.title) + .and_then(|n| Some((n.material.as_ref()?, &n.frame.group))); + let solid_pipeline = material.map_or(&self.solid, |(m, _)| &m.solid); + let translucent_pipeline = material.map_or(&self.translucent, |(m, _)| &m.translucent); + let pack_flat = material.and_then(|(m, _)| m.flat.as_ref()); + let pack_frame = |pass: &mut wgpu::RenderPass<'_>| { + if let Some((_, group)) = material { + pass.set_bind_group(horizon_shader_api::stages::GROUP, group, &[]); + } + }; { let attachments = [Some(wgpu::RenderPassColorAttachment { view: world_view, @@ -4212,6 +4231,7 @@ impl Renderer { ..Default::default() }); pass.set_bind_group(0, &self.group, &[]); + pack_frame(&mut pass); if frame.title || (sky_visible && (frame.skybox || frame.end_sky)) { if !frame.title && frame.skybox && !pack_draws_sky && !native_sky_pass { match self @@ -4260,7 +4280,7 @@ impl Renderer { pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); } Some(flat) => { - pass.set_pipeline(&flat.solid); + pass.set_pipeline(pack_flat.map_or(&flat.solid, |p| &p.0)); let vertices = |p| self.arena.buffer(p); match cull { // As below: phase 1, the test, then phase 2's draws @@ -4278,7 +4298,8 @@ impl Renderer { pack_reads_world, ); pass.set_bind_group(0, &self.group, &[]); - pass.set_pipeline(&flat.solid); + pack_frame(&mut pass); + pass.set_pipeline(pack_flat.map_or(&flat.solid, |p| &p.0)); flat.draw_phase2(&mut pass, vertices); } None => flat.draw(&mut pass, &flat.calls[..flat.solid_calls], vertices), @@ -4287,7 +4308,7 @@ impl Renderer { pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); } None => { - pass.set_pipeline(&self.solid); + pass.set_pipeline(solid_pipeline); pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); pass.set_vertex_buffer(1, self.instances.slice(..)); match cull { @@ -4307,7 +4328,8 @@ impl Renderer { pack_reads_world, ); pass.set_bind_group(0, &self.group, &[]); - pass.set_pipeline(&self.solid); + pack_frame(&mut pass); + pass.set_pipeline(solid_pipeline); pass.set_index_buffer( self.indices.slice(..), wgpu::IndexFormat::Uint32, @@ -4399,7 +4421,7 @@ impl Renderer { // The pack draws translucent terrain after its deferred programs. _ if pack_draws_water => {} Some(flat) => { - pass.set_pipeline(&flat.translucent); + pass.set_pipeline(pack_flat.map_or(&flat.translucent, |p| &p.1)); flat.draw(&mut pass, flat.translucent_calls(), |p| { self.arena.buffer(p) }); @@ -4407,7 +4429,7 @@ impl Renderer { pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); } None => { - pass.set_pipeline(&self.translucent); + pass.set_pipeline(translucent_pipeline); pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); pass.set_vertex_buffer(1, self.instances.slice(..)); self.draw_sections( diff --git a/crates/horizon-client/src/gfx/native_material.rs b/crates/horizon-client/src/gfx/native_material.rs new file mode 100644 index 000000000..8e54caf12 --- /dev/null +++ b/crates/horizon-client/src/gfx/native_material.rs @@ -0,0 +1,328 @@ +//! The material stage of Horizon's own shader packs (docs/shaders.md): the pack's `material` +//! function gives the lit colour of each point of a block's surface, before the alpha test and +//! fog. Terrain still draws with Horizon's meshes, culling and draw lists; only its pipelines +//! change. Their shader is the pack's stage (`CheckedStage::source`), then a copy of +//! terrain.wgsl's terrain section whose names all take a `horizon_terrain_` prefix +//! (`wgsl_prefix.rs`), then entries that hand the pack what vanilla's `fs_solid` and +//! `fs_translucent` combine: the texture, the vertex tint, the light levels and the lightmap's +//! colour. They read the terrain's group 0, the flat draws' group 1 where those run, and the +//! pack's frame at group 3. + +use horizon_shader_api::{check::CheckedStage, stages::GROUP}; + +use super::native_post::{NativeFrame, present_constants}; +use super::wgsl_prefix::{TERRAIN, prefixed, section}; + +const PREFIX: &str = "horizon_terrain_"; + +/// The entries around the pack's `material`: vanilla's vertex work without the lightmap +/// product, then the material, the alpha test and fog as `fs_solid` and `fs_translucent` do. +const ENTRIES: &str = " +struct HorizonMaterialOut { + @builtin(position) clip: vec4, + @location(0) uv: vec2, + @location(1) @interpolate(flat) layer: u32, + @location(2) tint: vec4, + @location(3) light: vec2, + @location(4) lightmap: vec3, + @location(5) position: vec3, + @location(6) spherical: f32, + @location(7) cylindrical: f32, +} +fn horizon_material_vertex(position: vec3, uv: vec2, layer: u32, color: vec4, + light: vec2, origin: vec3) -> HorizonMaterialOut { + let pos = position + origin; + var out: HorizonMaterialOut; + out.clip = horizon_terrain_globals.view_proj * vec4(pos, 1.0); + out.uv = uv; + out.layer = layer; + out.tint = color; + let block = max(f32(light.y), horizon_terrain_dynamic_block_light(pos)); + let sky = f32(light.x); + // 16 per level, 15 levels. + out.light = min(vec2(block, sky) / 240.0, vec2(1.0)); + out.lightmap = horizon_terrain_sample_lightmap(sky / 16.0, block / 16.0).rgb; + out.position = pos; + out.spherical = length(pos); + out.cylindrical = max(length(pos.xz), abs(pos.y)); + return out; +} +@vertex fn horizon_material_vs( + @location(0) position: vec3, @location(1) uv: vec2, + @location(2) layer: u32, @location(3) color: vec4, @location(4) light: vec2, + @location(5) origin: vec4) -> HorizonMaterialOut { + return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer, + color, light, origin.xyz); +} +@vertex fn horizon_material_vs_flat( + @builtin(vertex_index) vertex: u32, + @location(0) position: vec3, @location(1) uv: vec2, + @location(2) layer: u32, @location(3) color: vec4, @location(4) light: vec2 +) -> HorizonMaterialOut { + let origin = horizon_terrain_slot_origins[horizon_terrain_block_slots[vertex >> 8u]]; + return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer, + color, light, origin.xyz); +} +fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4 { + let albedo = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu); + return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv, + translucent)).color; +} +@fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> @location(0) vec4 { + let color = horizon_material_color(in, false); + // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout. + if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; } + return horizon_terrain_apply_fog(vec4(color.rgb, 1.0), in.spherical, in.cylindrical); +} +@fragment fn horizon_material_fs_translucent(in: HorizonMaterialOut) -> @location(0) vec4 { + let color = horizon_material_color(in, true); + if color.a < 0.01 { discard; } + return horizon_terrain_apply_fog(color, in.spherical, in.cylindrical); +} +"; + +/// What terrain pipelines are built against: the renderer's layouts and constants. +pub struct TerrainShape<'a> { + /// The terrain's group 0. + pub globals: &'a wgpu::BindGroupLayout, + /// The flat draws' group 1, where they run (`flat.rs`). + pub flat: Option<&'a wgpu::BindGroupLayout>, + /// terrain.wgsl's `SPRITE_ARRAYS` and `SPRITE_SPLIT`. + pub sprites: [f64; 2], + /// The world target's colour format. + pub format: wgpu::TextureFormat, +} + +/// The pack's terrain pipelines: solid (with the cutout test) and translucent, for the +/// renderer's instanced draws and, where they run, its flat ones. +pub struct NativeMaterial { + pub solid: wgpu::RenderPipeline, + pub translucent: wgpu::RenderPipeline, + pub flat: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>, +} + +/// terrain.wgsl's terrain section (its globals, bindings, sampling, lighting and fog), with +/// every name it declares prefixed. +fn vanilla_terrain() -> String { + prefixed( + section(TERRAIN, "struct Globals {", "// Sky (SkyRenderer)"), + PREFIX, + ) +} + +/// The terrain shader for the pack's material stage `source`. +fn shader_source(source: &str) -> String { + format!( + "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{ENTRIES}", + vanilla_terrain() + ) +} + +/// The material's naga module, its errors in the stage's file. +fn module(stage: &CheckedStage) -> Result { + let text = shader_source(&stage.source); + naga::front::wgsl::parse_str(&text) + .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text))) +} + +impl NativeMaterial { + /// The pipelines of the pack's material `stage` with the option values `constants`. + pub fn new( + device: &wgpu::Device, + shape: &TerrainShape<'_>, + frame: &NativeFrame, + stage: &CheckedStage, + constants: &[(String, f64)], + ) -> Result { + let module = module(stage)?; + let mut constants = present_constants(&module, constants); + let sprite_names = [ + "horizon_terrain_SPRITE_ARRAYS", + "horizon_terrain_SPRITE_SPLIT", + ]; + constants.extend(sprite_names.into_iter().zip(shape.sprites)); + let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); + let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some(&stage.label), + source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)), + }); + let layout = |flat: Option<&wgpu::BindGroupLayout>| { + let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = + Default::default(); + groups[0] = Some(shape.globals); + groups[1] = flat; + groups[GROUP as usize] = Some(&frame.layout); + device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Native shader pack terrain"), + bind_group_layouts: &groups, + ..Default::default() + }) + }; + let instance_attributes = wgpu::vertex_attr_array![5=>Float32x4]; + let vertices = wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::() as u64, + step_mode: wgpu::VertexStepMode::Vertex, + attributes: &super::TERRAIN_ATTRIBUTES, + }; + let instances = wgpu::VertexBufferLayout { + array_stride: 16, + step_mode: wgpu::VertexStepMode::Instance, + attributes: &instance_attributes, + }; + // As the renderer's terrain pipelines (gfx.rs): back faces culled, reversed depth. + let pipeline = |layout: &wgpu::PipelineLayout, + vertex: &str, + buffers: &[Option>], + fragment: &str, + blend: Option| { + let options = wgpu::PipelineCompilationOptions { + constants: &constants, + ..Default::default() + }; + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some(&stage.label), + layout: Some(layout), + vertex: wgpu::VertexState { + module: &module, + entry_point: Some(vertex), + compilation_options: options.clone(), + buffers, + }, + primitive: wgpu::PrimitiveState { + cull_mode: Some(wgpu::Face::Back), + ..Default::default() + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(true), + depth_compare: Some(wgpu::CompareFunction::GreaterEqual), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &module, + entry_point: Some(fragment), + compilation_options: options, + targets: &[Some(wgpu::ColorTargetState { + format: shape.format, + blend, + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }) + }; + let blend = Some(wgpu::BlendState::ALPHA_BLENDING); + let instanced = layout(None); + let buffers = [Some(vertices.clone()), Some(instances)]; + let solid = pipeline( + &instanced, + "horizon_material_vs", + &buffers, + "horizon_material_fs_solid", + None, + ); + let translucent = pipeline( + &instanced, + "horizon_material_vs", + &buffers, + "horizon_material_fs_translucent", + blend, + ); + let flat = shape.flat.map(|group| { + let layout = layout(Some(group)); + let buffers = [Some(vertices.clone())]; + let vs = "horizon_material_vs_flat"; + ( + pipeline(&layout, vs, &buffers, "horizon_material_fs_solid", None), + pipeline( + &layout, + vs, + &buffers, + "horizon_material_fs_translucent", + blend, + ), + ) + }); + if let Some(e) = pollster::block_on(scope.pop()) { + return Err(format!("{}: {e}", stage.file)); + } + Ok(Self { + solid, + translucent, + flat, + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use horizon_shader_api::{MANIFEST, Pack, StageKind, check}; + + fn stage(material: &str) -> CheckedStage { + let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\ + [material]\nfile = \"material.wgsl\"\n\ + [[options]]\nid = \"gain\"\nname = \"Gain\"\ntype = \"float\"\n\ + default = 1.0\nmin = 0.0\nmax = 2.0\n"; + let files = [(MANIFEST, manifest), ("material.wgsl", material)] + .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec())) + .into(); + let mut report = check(&Pack::from_files(files).unwrap()).unwrap(); + assert_eq!(report.stages[0].kind, StageKind::Material); + report.stages.remove(0) + } + + #[test] + fn the_terrain_takes_a_prefix_and_validates_with_a_pack() { + let terrain = vanilla_terrain(); + for name in [ + "Globals", + "globals", + "sprites_7", + "sprite", + "SPRITE_SPLIT", + "block_slots", + "sample_lightmap", + "apply_fog", + ] { + assert!(terrain.contains(&format!("{PREFIX}{name}")), "{name}"); + } + assert!(!terrain.contains("fs_sky"), "the sky stays out"); + // A pack may use any name Horizon's terrain uses unprefixed. + let own = "override gain: f32;\nconst PI: f32 = 3.0;\n\ + fn sprite(c: vec4) -> vec4 { return c * PI; }\n\ + fn apply_fog(c: vec4) -> vec4 { return c * gain; }\n\ + fn material(input: MaterialInput) -> Surface {\n \ + let lit = input.albedo * input.tint * vec4(input.lightmap, 1.0);\n \ + return Surface(apply_fog(sprite(lit)));\n}\n"; + let stage = stage(own); + let module = module(&stage).unwrap(); + let info = naga::valid::Validator::new( + naga::valid::ValidationFlags::all(), + naga::valid::Capabilities::all(), + ) + .validate(&module) + .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&shader_source(&stage.source)))); + let entries: Vec<&str> = module + .entry_points + .iter() + .map(|e| e.name.as_str()) + .collect(); + for entry in [ + "horizon_material_vs", + "horizon_material_vs_flat", + "horizon_material_fs_solid", + "horizon_material_fs_translucent", + ] { + assert!(entries.contains(&entry), "{entry}"); + } + drop(info); + assert_eq!( + present_constants(&module, &[("gain".into(), 1.5), ("other".into(), 1.0)]), + [("gain", 1.5)] + ); + } +} diff --git a/crates/horizon-client/src/gfx/native_pack.rs b/crates/horizon-client/src/gfx/native_pack.rs index 3f9206e11..4fb5cdc59 100644 --- a/crates/horizon-client/src/gfx/native_pack.rs +++ b/crates/horizon-client/src/gfx/native_pack.rs @@ -1,8 +1,9 @@ //! One of Horizon's own shader packs while it runs (docs/shaders.md): the frame its stages -//! read, its sky and post stages, and the timer of their passes. +//! read, its sky, material and post stages, and the timer of their passes. use horizon_shader_api::{Report, StageKind}; +use super::native_material::{NativeMaterial, TerrainShape}; use super::native_post::{NativeFrame, NativePost}; use super::native_sky::NativeSky; use super::pack_timing::PassTiming; @@ -10,6 +11,7 @@ use super::pack_timing::PassTiming; pub struct NativePack { pub frame: NativeFrame, pub sky: Option, + pub material: Option, pub post: Option, /// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`). pub timing: Option, @@ -17,16 +19,16 @@ pub struct NativePack { impl NativePack { /// The pack of the checked stages `report` with the option values `constants`, drawing - /// onto targets of `format`; `globals` is the terrain's group 0, which the sky reads. + /// onto the world's targets as `terrain` describes; the sky reads the terrain's group 0. /// Also returns its stages' labels, in the order they draw. Errors name the stage wgpu /// refused. pub fn new( device: &wgpu::Device, - globals: &wgpu::BindGroupLayout, + terrain: &TerrainShape<'_>, report: Report, constants: &[(String, f64)], - format: wgpu::TextureFormat, ) -> Result<(Self, Vec), String> { + let (globals, format) = (terrain.globals, terrain.format); let frame = NativeFrame::new(device); let (post, others): (Vec<_>, Vec<_>) = report .stages @@ -37,16 +39,28 @@ impl NativePack { .find(|s| s.kind == StageKind::Sky) .map(|stage| NativeSky::new(device, globals, &frame, stage, constants, format)) .transpose()?; + let material = others + .iter() + .find(|s| s.kind == StageKind::Material) + .map(|stage| NativeMaterial::new(device, terrain, &frame, stage, constants)) + .transpose()?; let post = (!post.is_empty()) .then(|| NativePost::new(device, post, constants, format, &frame)) .transpose()?; let mut labels: Vec = sky.iter().map(|s| s.label.clone()).collect(); + labels.extend( + others + .iter() + .filter(|s| material.is_some() && s.kind == StageKind::Material) + .map(|s| s.label.clone()), + ); if let Some(post) = &post { labels.extend(post.labels().into_iter().map(str::to_owned)); } let pack = Self { frame, sky, + material, post, timing: None, }; @@ -55,6 +69,6 @@ impl NativePack { /// Whether the pack draws anything the game runs today. pub fn draws(&self) -> bool { - self.sky.is_some() || self.post.is_some() + self.sky.is_some() || self.material.is_some() || self.post.is_some() } } diff --git a/docs/api/shaders.md b/docs/api/shaders.md index 7461332e4..faf662b0e 100644 --- a/docs/api/shaders.md +++ b/docs/api/shaders.md @@ -91,11 +91,12 @@ pack exist ([stability.md](stability.md)). ## Not there yet -The material stage in the game (the sky and post stages run, with hot reload), option values other than the defaults, -then the overlay, lighting and shadow stages. +Option values other than the defaults (the three stages run, with hot reload), then the overlay, lighting and shadow +stages. ## Changelog +- 2026-10-26: the material stage in the game: terrain's surfaces through the pack's `material`. - 2026-10-26: the sky stage in the game: the pack's `sky` gets vanilla's colour along each ray. - 2026-10-26: the post stage in the game (`HORIZON_SHADER_PACK`, hot reload with the last good pack kept). - 2026-10-25: `horizon-shader` (`new`, `check`, `pack`), three templates, the example pack and the guide. diff --git a/docs/shaders.md b/docs/shaders.md index fec45b078..127105610 100644 --- a/docs/shaders.md +++ b/docs/shaders.md @@ -13,8 +13,8 @@ Horizon's own format. | Authoring tool | `horizon-shader` (same crate) | `new`, `check`, `pack` | | Templates | `crates/horizon-shader-api/templates/` | post, sky, material | | Example pack | `crates/horizon-shader-api/packs/golden_hour` | a warm sky and two post passes | -| In the game: the sky and post stages | Options > Horizon Settings > Shader Packs | sky, post passes, hot reload | -| In the game: the material stage; the launcher and the registry | | not yet | +| In the game: every stage | Options > Horizon Settings > Shader Packs | sky, material, post passes, hot reload | +| The launcher and the registry | | not yet | ## Quick start @@ -52,8 +52,7 @@ it on Options > Horizon Settings > Shader Packs, which lists Horizon's packs, ma name>` runs a pack whatever the page says, for development. The game checks the pack first, and refuses one that fails, with its problems in the chat. While it runs, the game looks at the pack twice a second: save a file and the pack is checked and rebuilt in place ("Shader pack ... reloaded"); if the new version fails, the chat says -where and the last good version keeps drawing. The sky and post stages run today; the material stage is checked but -not drawn yet. +where and the last good version keeps drawing. All three stages run. ## A pack @@ -89,7 +88,7 @@ by Horizon: a pack changes how things look, not how they are drawn. | Stage | Your function | What it does | | --- | --- | --- | | `[sky]` | `fn sky(input: SkyInput) -> vec4` | the sky's colour along each view ray, opaque (alpha is ignored), drawn where vanilla draws its sky dome (the Overworld's sky; not the Nether's or the End's); the sun, moon, stars and clouds are drawn over it | -| `[material]` | `fn material(input: MaterialInput) -> Surface` | the lit colour of each point of a block's surface, before the alpha test and fog | +| `[material]` | `fn material(input: MaterialInput) -> Surface` | the lit colour of each point of a block's surface, before the alpha test and fog: every terrain section and distant tile, solid, cutout and translucent (not entities, block entities or particles) | | `[[post]]` | `fn post(input: PostInput) -> vec4` | a full-screen pass over the world's picture (up to 8, in order), under the hand and HUD | A pack has at least one stage; a stage it leaves out keeps vanilla's look. Each input says what vanilla would draw @@ -132,8 +131,10 @@ one keeps drawing), the launcher before it installs one, and the registry's CI b `[budget] gpu_ms` is the GPU time your pack aims to add to a frame. To compare, open F3 in the game: while it is open, each pass is timed on the GPU and the overlay shows the pack's total and its costliest passes, by their `name` (the median of the last 15 timed frames). Timing waits for nothing, so it does not slow the game. In a timed frame the sky -stage draws in a pass of its own (it shares the world's pass otherwise), so its time includes clearing the picture. +stage draws in a pass of its own (it shares the world's pass otherwise), so its time includes clearing the picture. The +material stage runs inside terrain's own draws, so it has no time of its own: compare the frame's GPU time with and +without the pack. ## Next -The material stage in the game, and the registry's `shader` kind with installs from the launcher. +The registry's `shader` kind with installs from the launcher, then the overlay, lighting and shadow stages. From 2918f3181182d92165a73035c0564486992a9b41 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:36:50 +0100 Subject: [PATCH 39/62] Poses::reset clears the scratch pose too A missing part's writes land in `dummy`; a fresh Poses started it at zero, so a reused one must too. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/mobs/anim.rs | 1 + crates/horizon-client/src/mobs/render.rs | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index 81faa3a02..3e7ca0339 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -127,6 +127,7 @@ impl Poses { } } self.map.clear(); + self.dummy = [0.0; 9]; self.skipped.clear(); self.hidden.clear(); walk(model, &mut self.map); diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 5c01f3f2f..6c780823d 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -1089,8 +1089,8 @@ fn render_visible( } } } - // One Poses for every layer: a humanoid with armour redraws five to seven - // models, and each used to allocate its own maps. + // One Poses refilled for every layer (armour draws up to seven): it keeps + // its maps' capacity. let mut layer_poses = Poses::default(); for layer in all_layers { let Some(part) = m.kind.layer(&layer.model).cloned() else { From bde76794eed1b4902a4d13039395a848d819634c Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:37:30 +0100 Subject: [PATCH 40/62] Mobs: no rain or thunder outside the overworld Level.canHaveWeather is false in the Nether and the End, so their rain and thunder levels stay at 0. Set that once in the mob world instead of checking the End at two of the rain sites: bees, dolphins, wolves and happy ghasts read the same flag. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/creatures.rs | 7 +++++-- crates/horizon-client/src/mobs/ai.rs | 2 +- crates/horizon-client/src/mobs/enderman.rs | 1 - 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index be7923037..a4be9e484 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -388,6 +388,9 @@ impl Game<'_> { } pub(super) fn mob_world_base<'s>(&'s self, others: &'s [Seen]) -> MobWorld<'s> { let (rain, thunder) = self.world.weather.levels(1.0); + // Level.canHaveWeather: only the overworld's rain and thunder levels + // ever rise, so nothing rains or thunders in the Nether or the End. + let weather = self.dim == Dim::Overworld; let player = self.player_view(); MobWorld { world: &self.world, @@ -404,8 +407,8 @@ impl Game<'_> { daylight: self.dim != Dim::Nether && self.sky_darken() < 4, game_time: self.world.game_time, day_time: self.world.day_time, - raining: rain > 0.2, - thundering: thunder > 0.9, + raining: weather && rain > 0.2, + thundering: weather && thunder > 0.9, nether: self.dim == Dim::Nether, block_tags: &self.res.items().block_tags, biomes: self.res.biomes(), diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index e2043772a..c9bc15fda 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -521,7 +521,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } if m.kind.flags.water_sensitive - && (m.fluids.in_water || w.raining && !w.end && w.can_see_sky(ex, ey, ez)) + && (m.fluids.in_water || w.raining && w.can_see_sky(ex, ey, ez)) { m.damage(1.0, Damage::of(DamageKind::Drown)); } diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs index 85967e96e..c5ed01680 100644 --- a/crates/horizon-client/src/mobs/enderman.rs +++ b/crates/horizon-client/src/mobs/enderman.rs @@ -186,7 +186,6 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } if (m.fluids.in_water || w.raining - && !w.end && w.can_see_sky( m.position.x.floor() as i32, m.eye_y().floor() as i32, From fb74b6038f026f5b09ddf1a85b2c64fe636648f9 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:38:17 +0100 Subject: [PATCH 41/62] Chat: system and player lines share the window's chat code Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/chat_tests.rs | 3 ++- crates/horizon-client/src/game/chat.rs | 31 ++++++++----------------- 2 files changed, 12 insertions(+), 22 deletions(-) diff --git a/crates/horizon-client/src/chat_tests.rs b/crates/horizon-client/src/chat_tests.rs index fa065766c..071cd8839 100644 --- a/crates/horizon-client/src/chat_tests.rs +++ b/crates/horizon-client/src/chat_tests.rs @@ -439,7 +439,8 @@ fn the_chat_option_filters_the_lines_both_ways() { /// The in-frame LAN host's chat: a guest's line is a player message, so the /// Chat option's player-message permission hides it at Commands Only and -/// Hidden; command feedback (`/say`, `/me`) is a system message and stays. +/// Hidden; command feedback (`/list`, `/tp`) is a system message and stays +/// at Commands Only. #[test] fn a_guests_line_follows_the_player_message_permission() { let font = font(); diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index be2a318a0..de5bbf116 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -464,22 +464,7 @@ impl Game<'_> { return; } // The Chat option's Hidden level takes the server's messages too. - if !self.ui.chat.shows(ChatSource::Server) { - return; - } - let focused = self.screen == Screen::Chat; - let heard = self.mods.running().then(|| text.plain()); - self.ui.chat.add( - &self.gui.atlas, - text, - Some(SYSTEM_INDICATOR), - ChatSource::Server, - self.ticks, - focused, - ); - if let Some(line) = heard { - self.mods_chat(&line); - } + self.local_chat_line(text, Some(SYSTEM_INDICATOR), ChatSource::Server); } /// A player's chat line on the window's own chat: a LAN guest's message /// while the host runs in-frame (`HostEvent::Chat`). `ChatListener` @@ -493,10 +478,14 @@ impl Game<'_> { } // A server's client receives the line as a packet (PlayerChat or // DisguisedChat) and filters it there. - if self.remote.is_some() { - return; + if self.remote.is_none() { + self.local_chat_line(text, None, ChatSource::Player); } - if !self.ui.chat.shows(ChatSource::Player) { + } + /// A line on the window's own chat when the Chat option lets `source` + /// through; running mods hear it. + fn local_chat_line(&mut self, text: Text, indicator: Option, source: ChatSource) { + if !self.ui.chat.shows(source) { return; } let focused = self.screen == Screen::Chat; @@ -504,8 +493,8 @@ impl Game<'_> { self.ui.chat.add( &self.gui.atlas, text, - None, - ChatSource::Player, + indicator, + source, self.ticks, focused, ); From 78bfe7446512fcbf12820b47d168f66d6a4a847d Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:38:39 +0100 Subject: [PATCH 42/62] Container clicks: the stuck-drag test joins the module's tests Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/container_screen.rs | 5 ----- crates/horizon-client/src/game.rs | 3 +-- 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/crates/horizon-client/src/container_screen.rs b/crates/horizon-client/src/container_screen.rs index 4b0bb3861..77c7ad8aa 100644 --- a/crates/horizon-client/src/container_screen.rs +++ b/crates/horizon-client/src/container_screen.rs @@ -275,11 +275,6 @@ mod tests { Release::Click(Input::QuickMove) ); } -} - -#[cfg(test)] -mod stuck_tests { - use super::*; /// A press whose release never arrives (the pointer left the window, or /// the screen closed first) leaves `isQuickCrafting` set; the next screen diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index a4149f808..3c675b342 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4734,8 +4734,7 @@ impl Game<'_> { if capture { // The inventory's screens are behind us: no drag survives them. self.reset_inventory_clicks(); - } - if !capture { + } else { self.stop_mining(); } // The real pointer takes over from an agent's. From f19390bae1a1d5461e117e3b3c0bb6752dcf7d20 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:39:07 +0100 Subject: [PATCH 43/62] Sonic boom: take the LAN host in the same let-else as the particle Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/lan_particles.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs index f92e8cf61..719fe79ab 100644 --- a/crates/horizon-client/src/game/lan_particles.rs +++ b/crates/horizon-client/src/game/lan_particles.rs @@ -28,7 +28,7 @@ impl Game<'_> { /// `SonicBoom.tick` uses `ServerLevel.sendParticles` for each ray point. /// Keep the local event's rendering; connected players receive one at rest. pub(super) fn lan_sonic_boom(&self, options: &ParticleOptions, at: [f64; 3]) { - let Some(particle) = self.network_particle(options, None) else { + let (Some(host), Some(particle)) = (&self.lan, self.network_particle(options, None)) else { return; }; let packet = C::LevelParticles(play::LevelParticles { @@ -41,7 +41,6 @@ impl Game<'_> { count: 0, randomization: 0, }); - let host = self.lan.as_ref().unwrap(); for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) { // ServerLevel compares the player's block centre, strictly within 32. let distance: f64 = (0..3) From cdbe1edcdab34fbe874538872d6122fe6378b00b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:42:48 +0100 Subject: [PATCH 44/62] Text displays: keep the background at vanilla's -1..width, -1..height TextDisplayRenderer.submitInner calls submitTextBackground(-1, -1, width, height), and Font.prepareBackground's effect glyph spans x0..x1, y0..y1, so the fill is width + 1 by height + 1 from (-1, -1), as before. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/text_displays.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs index b669c8357..45bd64fa7 100644 --- a/crates/horizon-client/src/game/text_displays.rs +++ b/crates/horizon-client/src/game/text_displays.rs @@ -210,10 +210,11 @@ impl Game<'_> { if bg != 0 { batch.fill( atlas, + // submitTextBackground(-1, -1, width, height): corners, not a size. -1.0, -1.0, - width + 2.0, - height + 2.0, + width + 1.0, + height + 1.0, rgba( (bg >> 16) as u8, (bg >> 8) as u8, From ee83d8f2475063b157b41f87a83237362eb35f06 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:47:27 +0100 Subject: [PATCH 45/62] Chat test: set the abilities through set_abilities (clippy) Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/chat_tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/chat_tests.rs b/crates/horizon-client/src/chat_tests.rs index 071cd8839..beec6cd81 100644 --- a/crates/horizon-client/src/chat_tests.rs +++ b/crates/horizon-client/src/chat_tests.rs @@ -446,7 +446,7 @@ fn a_guests_line_follows_the_player_message_permission() { let font = font(); let shown = |visibility, source| { let mut chat = Chat::default(); - chat.abilities = ChatAbilities::new(visibility); + chat.set_abilities(&font, ChatAbilities::new(visibility)); chat.add_message(&font, Text::literal("line"), None, source, 0, false); chat.messages.len() }; From fe19efb9172be2c00656c1c175b4a2bddf824d4e Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:14:59 +0100 Subject: [PATCH 46/62] Predicted break: test BaseFireBlock by its class, as the server does The world side checks Class::BaseFire; the tag is a data-pack list that can differ from the class. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/remote.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 87e06d586..8992558cd 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3817,7 +3817,7 @@ impl Game<'_> { // sound), which BaseFireBlock skips: the server's extinguish sound // is all a player hears. let facts = self.res.facts().get(state); - if !self.res.items().block_in_tag("minecraft:fire", &facts.name) { + if !facts.has_class("BaseFireBlock") { let s = facts.sounds.clone(); let at = [ f64::from(pos[0]) + 0.5, From c23b4e8e416a59bd7001f77f3e8738b04db9deb3 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:27:06 +0100 Subject: [PATCH 47/62] Mod API: game.raycast, the block the player looks at (level 2) `game.raycast(distance)` returns the first block along the player's view (fluids pass), up to 1024 blocks: through the loaded chunks as the crosshair's ray goes, then across the distant terrain's ground heights (`Lod::ground`, from Stink-O's fork). The game casts it only while a running mod imports the function. It is API level 2, so older Horizons refuse a mod that calls it with "update Horizon". Co-authored-by: Stink-O <180130752+Stink-O@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/mods.rs | 57 +++++++++++++++++++ crates/horizon-client/src/lod.rs | 19 +++++++ crates/horizon-mod-sdk/wit/horizon.wit | 21 ++++++- crates/horizon-mods/src/api_level.rs | 5 +- crates/horizon-mods/src/runtime.rs | 29 +++++++++- crates/horizon-mods/tests/sandbox.rs | 47 ++++++++++++++- crates/horizon-mods/tests/ui_guest/src/lib.rs | 16 +++++- docs/api/mods-reference.md | 17 +++++- docs/api/stability.md | 2 +- docs/mods.md | 2 +- 10 files changed, 202 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs index a83277376..1752dec91 100644 --- a/crates/horizon-client/src/game/mods.rs +++ b/crates/horizon-client/src/game/mods.rs @@ -415,8 +415,65 @@ impl Game<'_> { cps, font_widths: self.mods.font_widths.clone(), players: Vec::new(), + view_hit: self.mod_view_hit(), } } + /// The first block along the player's view within + /// [`horizon_mods::RAYCAST_MAX`] and its distance from the eye + /// (`game.raycast`): through the loaded chunks as the crosshair's ray + /// goes (fluids pass), then across the distant terrain's ground heights, + /// a block at a time. + fn mod_view_hit(&self) -> Option<(f32, horizon_mods::Hit)> { + if !self.mods.mods.wants_raycast() { + return None; + } + let eye = self.eye_position()?; + let dir = super::view_vector(self.yaw, self.pitch); + let reach = f64::from(horizon_mods::RAYCAST_MAX); + let (pos, point, state) = match self.clip_ray(eye, dir, reach) { + Some(hit) => ( + hit.pos, + hit.point, + self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]), + ), + None => self.lod_ray(eye, dir, reach)?, + }; + let distance = (0..3).map(|i| (point[i] - eye[i]).powi(2)).sum::(); + let hit = horizon_mods::Hit { + block_x: pos[0], + block_y: pos[1], + block_z: pos[2], + x: point[0], + y: point[1], + z: point[2], + block: self.res.facts().get(state).name.to_string(), + }; + Some((distance.sqrt() as f32, hit)) + } + /// Past the resident chunks: the view walked across the distant + /// terrain's ground heights (`Lod::ground`), a block at a time. Columns in + /// loaded chunks are left to `clip_ray`, which has already missed them. + fn lod_ray( + &self, + eye: [f64; 3], + dir: [f64; 3], + reach: f64, + ) -> Option<([i32; 3], [f64; 3], horizon_world::registry::BlockStateId)> { + let lod = self.lod.as_ref()?; + let mut t = 0.0; + while t <= reach { + let p = [0, 1, 2].map(|i| eye[i] + dir[i] * t); + let (x, z) = (p[0].floor() as i32, p[2].floor() as i32); + if !self.world.loaded(x, z) + && let Some((height, state)) = lod.ground(x, z) + && p[1] <= f64::from(height) + { + return Some(([x, height - 1, z], [p[0], f64::from(height), p[2]], state)); + } + t += 1.0; + } + None + } /// A game tick. pub(super) fn tick_mods(&mut self) { // Here, at the player's level: shown inside a console call (a control diff --git a/crates/horizon-client/src/lod.rs b/crates/horizon-client/src/lod.rs index a429863a7..1ee61cdf4 100644 --- a/crates/horizon-client/src/lod.rs +++ b/crates/horizon-client/src/lod.rs @@ -752,6 +752,25 @@ impl Lod { saved_order: VecDeque::new(), } } + /// The solid ground at block column (x, z): its top face's height and + /// its block, from the finest tile sampled there. For aiming past the + /// resident chunks (`game.raycast`); water is passed, as the view's ray + /// passes it. + pub fn ground(&self, x: i32, z: i32) -> Option<(i32, BlockStateId)> { + (0..=MAX_LEVEL).find_map(|level| { + let size = 16 << level; + let key = TileKey { + x: x.div_euclid(size), + z: z.div_euclid(size), + level, + }; + let columns = self.ready.get(&key).filter(|c| c.len() == CELLS * CELLS)?; + let cell = size / CELLS as i32; + let (cx, cz) = ((x - key.x * size) / cell, (z - key.z * size) / cell); + let surface = columns[cz as usize * CELLS + cx as usize].surface?; + Some((surface.height, surface.state)) + }) + } pub fn stats(&self) -> (usize, usize) { (self.active.len(), self.ready.len()) } diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit index 84be4d4f0..7f8245c48 100644 --- a/crates/horizon-mod-sdk/wit/horizon.wit +++ b/crates/horizon-mod-sdk/wit/horizon.wit @@ -18,7 +18,8 @@ interface log { write: func(level: level, message: string); } -/// Capability `game-read`: the local player and the world clock. +/// Capability `game-read`: the local player, the world clock and the block +/// the player looks at. interface game { record player { /// Feet position, in blocks. @@ -46,6 +47,24 @@ interface game { get-player: func() -> option; /// None on the title screen. get-clock: func() -> option; + /// A block along the player's view. + record hit { + /// The block hit. + block-x: s32, + block-y: s32, + block-z: s32, + /// The point on its face where the view meets it. + x: f64, + y: f64, + z: f64, + /// `minecraft:stone`, ... + block: string, + } + /// The first block along the player's view (fluids pass), up to + /// `distance` blocks (at most 1024; past the loaded chunks, across the + /// distant terrain when LOD Distance is on), as of this tick. None when + /// nothing is hit, and on the title screen. + raycast: func(distance: f32) -> option; } /// Capability `chat`: messages only the local player sees. diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs index e7b72c20b..0627b71ae 100644 --- a/crates/horizon-mods/src/api_level.rs +++ b/crates/horizon-mods/src/api_level.rs @@ -7,13 +7,13 @@ //! version's level so the launcher can tell before it installs. /// The newest level this Horizon serves. -pub const LEVEL: u32 = 1; +pub const LEVEL: u32 = 2; /// Every function the game offers mods, as `interface.function`, with its /// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new /// function takes the next level and raises [`LEVEL`] (the `api_reference` /// test fails until it is listed here). -pub const FUNCTIONS: [(&str, u32); 32] = [ +pub const FUNCTIONS: [(&str, u32); 33] = [ ("log.write", 0), ("game.get-player", 0), ("game.get-clock", 0), @@ -46,6 +46,7 @@ pub const FUNCTIONS: [(&str, u32); 32] = [ ("players.online", 1), ("players.tell", 1), ("players.broadcast", 1), + ("game.raycast", 2), ]; /// A function's level; None for one this Horizon doesn't have. diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs index f1859337d..ea603ee31 100644 --- a/crates/horizon-mods/src/runtime.rs +++ b/crates/horizon-mods/src/runtime.rs @@ -41,7 +41,7 @@ mod ui_bindings { }); } pub use bindings::horizon::mods::{ - game::{Clock, Player}, + game::{Clock, Hit, Player}, hud::{Corner, Line}, }; use bindings::{ @@ -89,6 +89,8 @@ const FUEL_FRAME: u64 = 10_000_000; const FUEL_EVENT: u64 = 100_000_000; /// Chat lines a mod may show per call, HUD lines and their length. const CHAT_PER_CALL: usize = 8; +/// How far `game.raycast` sees, in blocks. +pub const RAYCAST_MAX: f32 = 1024.0; const HUD_LINES: usize = 16; const LINE_CHARS: usize = 256; /// Total bytes a mod's `storage` may hold on disk, across all its keys. @@ -124,6 +126,10 @@ pub struct Snapshot { pub font_widths: Arc<[f32]>, /// The players on the server, for server mods. pub players: Vec, + /// The first block along the player's view within [`RAYCAST_MAX`] and + /// its distance from the eye, for `game.raycast`; the game works it out + /// only while a mod calls it ([`Mods::wants_raycast`]). + pub view_hit: Option<(f32, Hit)>, } /// Which mods a game starts: the window's game the client mods, the game @@ -227,6 +233,8 @@ struct Running { /// server mod. ui: Option, hooks: Hooks, + /// It imports `game.raycast`. + raycasts: bool, } /// A running mod's exports and the hooks its `init` asked for. @@ -490,7 +498,12 @@ impl Mods { free }); self.out.append(&mut store.data_mut().out); - Ok(Some(Running { store, ui, hooks })) + Ok(Some(Running { + store, + ui, + hooks, + raycasts: functions.iter().any(|f| f == "game.raycast"), + })) } /// True when at least one mod runs: the game skips its mod work otherwise. @@ -743,6 +756,13 @@ impl Mods { .iter() .filter_map(|e| e.run.as_ref()?.store.data().corner.as_ref()) } + /// Some running mod calls `game.raycast`: the snapshot needs a + /// [`Snapshot::view_hit`]. + pub fn wants_raycast(&self) -> bool { + self.entries + .iter() + .any(|e| e.run.as_ref().is_some_and(|r| r.raycasts)) + } /// Some running mod has a `frame` hook: the game refreshes the snapshot /// every frame for it. pub fn wants_frames(&self) -> bool { @@ -1093,6 +1113,11 @@ impl game::Host for State { fn get_clock(&mut self) -> Option { self.snapshot.clock } + fn raycast(&mut self, distance: f32) -> Option { + let (at, hit) = self.snapshot.view_hit.as_ref()?; + // NaN compares false: no hit. + (*at <= distance.min(RAYCAST_MAX) && !distance.is_nan()).then(|| hit.clone()) + } } impl State { /// Queues a chat line unless the call already sent [`CHAT_PER_CALL`]. diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs index aaec89ec7..8eceec815 100644 --- a/crates/horizon-mods/tests/sandbox.rs +++ b/crates/horizon-mods/tests/sandbox.rs @@ -2,8 +2,8 @@ //! examples and a guest //! that misbehaves on command. Needs `rustup target add wasm32-unknown-unknown`. use horizon_mods::{ - BlockPos, Clock, Corner, GameMode, HeldItem, Mods, Output, Package, Player, Runs, ServerPlayer, - Shape, Snapshot, Status, + BlockPos, Clock, Corner, GameMode, HeldItem, Hit, Mods, Output, Package, Player, Runs, + ServerPlayer, Shape, Snapshot, Status, manifest::componentize, testing::{Script, TestGame}, }; @@ -26,7 +26,7 @@ id = "test_ui_guest" name = "Test UI Guest" version = "0.1.0" api = "0.1" -capabilities = ["chat", "ui", "render", "input"] +capabilities = ["game-read", "chat", "ui", "render", "input"] experimental = ["ui", "render", "input"] "#; @@ -722,6 +722,47 @@ fn render_minimap_is_clamped_and_hidden() { assert_eq!(map(&mut mods, "off"), None); } +/// `game.raycast`: the view's hit the game worked out, up to the distance +/// asked for; the game works it out only while a mod imports the call. +#[test] +fn game_raycast_sees_the_view_hit_within_its_distance() { + let mut mods = load("horizon_mods_test_ui_guest.hmod"); + assert!(mods.wants_raycast()); + assert!(!load("coords_hud.hmod").wants_raycast()); + let said = |mods: &mut Mods, args: &str| -> Vec { + assert!(mods.command(&format!("raycast {args}"))); + mods.drain() + .into_iter() + .filter_map(|o| match o { + Output::Chat { text, .. } => Some(text), + _ => None, + }) + .collect() + }; + assert_eq!(said(&mut mods, "100"), ["no hit"]); + mods.set_snapshot(Snapshot { + view_hit: Some(( + 40.5, + Hit { + block_x: 12, + block_y: 63, + block_z: -44, + x: 12.5, + y: 64.0, + z: -43.75, + block: "minecraft:grass_block".into(), + }, + )), + ..player() + }); + let hit = "hit minecraft:grass_block at 12 63 -44 (12.5 64.0 -43.8)"; + assert_eq!(said(&mut mods, "100"), [hit]); + assert_eq!(said(&mut mods, "40"), ["no hit"]); + // NaN asks for nothing; past 1024 is 1024. + assert_eq!(said(&mut mods, "x"), ["no hit"]); + assert_eq!(said(&mut mods, "1e9"), [hit]); +} + #[test] fn corner_panels_text_width_and_readings() { let mut mods = load("horizon_mods_test_ui_guest.hmod"); diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs index 3d4c66076..32e811fc7 100644 --- a/crates/horizon-mods/tests/ui_guest/src/lib.rs +++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs @@ -4,9 +4,10 @@ //! `/render_hud`, `/render_clear` and `/render_shake` test `render`; //! `/input_claim`, `/input_poll`, `/input_held` and `/input_wheel` test //! `input`; `/zoom FACTOR SMOOTH TURN` tests `render.set-zoom`; -//! `/corner` and `/readings` the calls the official extras mods use. +//! `/corner` and `/readings` the calls the official extras mods use; +//! `/raycast DISTANCE` says what `game.raycast` sees. use horizon_mod_sdk::{ - Mod, Registration, chat, + Mod, Registration, chat, game, input::{self, Event}, render::{self, FillShape, ItemShape, Point, QuadShape, Rect, Shape, SpriteShape, TextShape}, ui::{self, ItemWidget, ListWidget, Screen, TextWidget, Widget}, @@ -97,6 +98,7 @@ impl Mod for Guest { "input_wheel", "zoom", "minimap", + "raycast", "corner", "readings", ] @@ -217,6 +219,16 @@ impl Mod for Guest { }); render::set_minimap(map); } + "raycast" => { + let distance = args.parse().unwrap_or(f32::NAN); + chat::show(&match game::raycast(distance) { + Some(h) => format!( + "hit {} at {} {} {} ({:.1} {:.1} {:.1})", + h.block, h.block_x, h.block_y, h.block_z, h.x, h.y, h.z + ), + None => "no hit".into(), + }); + } // Clamped to (1, 10); the two after it shake nothing. "render_shake" => { render::shake(2.0, 99.0); diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md index d7bf879b8..a197b2c04 100644 --- a/docs/api/mods-reference.md +++ b/docs/api/mods-reference.md @@ -76,7 +76,7 @@ The mod's log, in the game's log under the mod's id. Always granted. Access: capability `game-read`. -Capability `game-read`: the local player and the world clock. +Capability `game-read`: the local player, the world clock and the block the player looks at. ### record `player` @@ -98,10 +98,25 @@ Capability `game-read`: the local player and the world clock. | `game-time` | `u64` | Ticks since the world was created. | | `day-time` | `u64` | 24000 ticks per day; 0 is 6:00 on the first day. | +### record `hit` + +A block along the player's view. + +| Field | Type | | +| --- | --- | --- | +| `block-x` | `s32` | The block hit. | +| `block-y` | `s32` | | +| `block-z` | `s32` | | +| `x` | `f64` | The point on its face where the view meets it. | +| `y` | `f64` | | +| `z` | `f64` | | +| `block` | `string` | `minecraft:stone`, ... | + | Function | Signature | What it does | | --- | --- | --- | | `get-player` | `func() -> option` | None on the title screen. | | `get-clock` | `func() -> option` | None on the title screen. | +| `raycast` | `func(distance: f32) -> option` | The first block along the player's view (fluids pass), up to `distance` blocks (at most 1024; past the loaded chunks, across the distant terrain when LOD Distance is on), as of this tick. None when nothing is hit, and on the title screen. | ## `chat` diff --git a/docs/api/stability.md b/docs/api/stability.md index 65cfc0c13..f6b40fabe 100644 --- a/docs/api/stability.md +++ b/docs/api/stability.md @@ -38,7 +38,7 @@ don't import it); faster, or fixing behaviour to what the reference already says A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`): -level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`. A mod needs the level of +level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`. A mod needs the level of the newest function it imports (a component imports only the functions it calls). The level is read from the file, never declared: diff --git a/docs/mods.md b/docs/mods.md index 03ca120b2..7093a22be 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -83,7 +83,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3. | Interface | Capability | Functions | |---|---|---| | `log` | always | `write(level, message)`, in the game log as `[mod ]` | -| `game` | `game-read` | `get-player()`: x y z, yaw, pitch, health, food, dimension; `get-clock()`: game time, day time | +| `game` | `game-read` | `get-player()`: x y z, yaw, pitch, health, food, dimension; `get-clock()`: game time, day time; `raycast(distance)`: the first block along the view (fluids pass), up to 1024 blocks and across the distant terrain, with the point hit and the block's id | | `chat` | `chat` | `show(text)`: a line only the local player sees, after the mod's name (8 per call) | | `hud` | `hud` | `set-panel(corner, lines)`, `clear()`: up to 16 lines of 256 characters | | `storage` | `storage` | `get(key)`, `set(key, value)`, `delete(key)`: a per-mod folder of up to 64 files, 4 MiB total, at most 1 MiB written per call | From f4b4f944e3e4a635d564c000e1c773d4a3d542dc Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:33:08 +0100 Subject: [PATCH 48/62] Capture test: the fixture's Game resets its inventory clicks too capture(true) now calls reset_inventory_clicks; the fixture compiles the method body against a stub Game. Co-Authored-By: Claude Opus 5.5 --- tests/test_world_input_capture.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_world_input_capture.py b/tests/test_world_input_capture.py index df91e3153..5607c3684 100644 --- a/tests/test_world_input_capture.py +++ b/tests/test_world_input_capture.py @@ -101,6 +101,7 @@ impl Default for Game { } impl Game { fn stop_mining(&mut self) { self.mining = false; } + fn reset_inventory_clicks(&mut self) {} METHODS } fn main() { From 5ec21ff5f1468b052d104bd84e5ae07b02a3afe8 Mon Sep 17 00:00:00 2001 From: kohad1ck <163426863+kohad1ck@users.noreply.github.com> Date: Mon, 26 Oct 2026 16:47:07 +0800 Subject: [PATCH 49/62] Font: menus keep their run-time glyphs when the renderer rebuilds its atlas Menu text drawn with characters the bitmap sheets lack (Chinese, Japanese, Korean) is rasterized into a reserve of the shared atlas at run time, and the font caches the atlas rect it got. The loading screen hands over to the game about two seconds after the title shows by building a new renderer, whose atlas texture is made from HudAtlas.pixels alone: those never hold a run-time glyph, while the cache still answers with the old rects, so every such character already drawn went blank. Latin text, straight from the sheets, stayed. build_renderer and loading_renderer now forget the cache before the new texture exists, so the characters that are drawn again are placed into it, as ui_theme clears its own cache when the atlas changes. Fixes #1824, fixes #2040. --- crates/horizon-client/src/font.rs | 25 +++++++++++++++++++++++++ crates/horizon-client/src/game.rs | 14 ++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs index 1903cab7e..d0e8c8499 100644 --- a/crates/horizon-client/src/font.rs +++ b/crates/horizon-client/src/font.rs @@ -1201,6 +1201,31 @@ mod tests { assert!(!font.take_patches().is_empty()); } + /// A renderer rebuilt over the same font (the loading screen's handoff) + /// makes its atlas texture from the textures alone, so the glyphs it had + /// rasterized into the previous texture must be placed into the new one. + #[test] + fn a_rebuilt_atlas_gets_its_glyphs_again() { + let sheet = png(16, 8, |x, _| x < 2 || (8..14).contains(&x)); + let default = br#"{"providers":[{"type":"bitmap","file":"minecraft:font/a.png","ascent":7,"chars":["ab"]}]}"#; + let root = root( + "rebuild", + &[ + ("assets/minecraft/font/default.json", default), + ("assets/minecraft/textures/font/a.png", &sheet), + ], + ); + let font = load(&root); + let _ = std::fs::remove_dir_all(&root); + let first = font.glyph('a'); + assert_eq!(font.take_patches().len(), 1); + font.reset_cache(); + // Nothing is left over: drawing the character again places its pixels. + assert!(font.take_patches().is_empty()); + assert_eq!(font.glyph('a').advance, first.advance); + assert_eq!(font.take_patches().len(), 1); + } + #[test] fn provider_filters_follow_the_font_options() { let sheet = png(8, 8, |x, _| x < 4); diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index cdbd72d7b..1bd288bb7 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -12995,6 +12995,14 @@ fn build_renderer( ) -> Result { let assets = &pack.render; let atlas = &gui.atlas; + // The new renderer's atlas texture starts from `HudAtlas.pixels`, which + // holds the textures but never a glyph rasterized at run time. The font's + // cache still answers with the rects it drew into the previous renderer's + // texture, so forget them: the glyphs that are drawn again are placed into + // this texture (as `ui_theme` does when its atlas changes). Without this, + // Chinese and Japanese menu labels go blank when the loading screen hands + // over to the game. + atlas.font.reset_cache(); let mut renderer = pollster::block_on(Renderer::new( window, offscreen, @@ -13041,6 +13049,12 @@ fn loading_renderer( Some(atlas) => (atlas.pixels.as_slice(), atlas.width, atlas.height), None => (EMPTY_HUD.as_slice(), 1, 1), }; + // A glyph rasterized into an earlier texture is not in these pixels; the + // new texture gets it again when the character is drawn (see + // `build_renderer`). + if let Some(atlas) = atlas { + atlas.font.reset_cache(); + } let mut renderer = pollster::block_on(Renderer::new( window, offscreen, From b279758c7c75447f74aac2466aa6d0ba1b758d82 Mon Sep 17 00:00:00 2001 From: kohad1ck <163426863+kohad1ck@users.noreply.github.com> Date: Mon, 26 Oct 2026 17:42:05 +0800 Subject: [PATCH 50/62] Localization: server screens and the new world name follow the language The Add/Edit Server, Direct Connection and Friends screens and Create New\nWorld built their titles, field labels, defaults and buttons from English\nliterals, so every non-English language showed English there. Route them\nthrough the current language with vanilla's keys:\n\n- ManageServerScreen: manageServer.add.title/edit.title, enterName, enterIp,\n selectServer.defaultName, gui.done and gui.cancel.\n- DirectJoinServerScreen: manageServer.enterIp (the addServer.enterIp key is\n not in 26.3), selectServer.select and gui.cancel.\n- WorldCreationUiState: selectWorld.newWorld.\n- Select World: selectWorld.title and selectWorld.versionUnknown.\n- DisconnectedScreen: disconnect.lost and gui.toMenu.\n\nA language missing a key keeps the English fallback, so en_us is unchanged.\n\nCo-Authored-By: ZCode Agent --- crates/horizon-client/src/multiplayer.rs | 28 ++++++++++++------------ crates/horizon-client/src/title.rs | 12 +++++++--- 2 files changed, 23 insertions(+), 17 deletions(-) diff --git a/crates/horizon-client/src/multiplayer.rs b/crates/horizon-client/src/multiplayer.rs index 07d8552ff..f13ffde0a 100644 --- a/crates/horizon-client/src/multiplayer.rs +++ b/crates/horizon-client/src/multiplayer.rs @@ -491,7 +491,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 96.0 + 18.0, 200.0, - "Done", + &crate::lang::get_or("gui.done", "Done"), servers::parse_address(address).is_some(), 50, ), @@ -499,7 +499,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 120.0 + 18.0, 200.0, - "Cancel", + &crate::lang::get_or("gui.cancel", "Cancel"), true, 51, ), @@ -532,7 +532,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 96.0 + 12.0, 200.0, - "Join Server", + &crate::lang::get_or("selectServer.select", "Join Server"), servers::parse_address(address).is_some(), 52, ), @@ -540,7 +540,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 120.0 + 12.0, 200.0, - "Cancel", + &crate::lang::get_or("gui.cancel", "Cancel"), true, 53, ), @@ -558,7 +558,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 120.0 + 18.0, 200.0, - "Cancel", + &crate::lang::get_or("gui.cancel", "Cancel"), true, 57, ), @@ -568,7 +568,7 @@ impl Screen { w / 2.0 - 100.0, h / 2.0 + 30.0, 200.0, - "Back to Server List", + &crate::lang::get_or("gui.toMenu", "Back to Server List"), true, 54, )]; @@ -876,10 +876,10 @@ impl Screen { } => { centered( batch, - if index.is_some() { - "Edit Server Info" + &if index.is_some() { + crate::lang::get_or("manageServer.edit.title", "Edit Server Info") } else { - "Add Server" + crate::lang::get_or("manageServer.add.title", "Add Server") }, 17.0, u32::MAX, @@ -888,7 +888,7 @@ impl Screen { Self::field( atlas, batch, - "Server Name", + &crate::lang::get_or("manageServer.enterName", "Server Name"), name, (53.0, 66.0), *focus == 0, @@ -897,7 +897,7 @@ impl Screen { Self::field( atlas, batch, - "Server Address", + &crate::lang::get_or("manageServer.enterIp", "Server Address"), address, (94.0, 106.0), *focus == 1, @@ -916,7 +916,7 @@ impl Screen { Self::field( atlas, batch, - &crate::lang::get_or("addServer.enterIp", "Server Address"), + &crate::lang::get_or("manageServer.enterIp", "Server Address"), address, (100.0, 116.0), true, @@ -973,7 +973,7 @@ impl Screen { Self::Disconnected { reason, retry } => { centered( batch, - "Connection Lost", + &crate::lang::get_or("disconnect.lost", "Connection Lost"), h / 2.0 - 40.0, rgba(170, 170, 170, 255), ); @@ -1019,7 +1019,7 @@ impl Screen { (Self::List { .. }, Some(42)) => { *self = Self::Edit { index: None, - name: "Minecraft Server".into(), + name: crate::lang::get_or("selectServer.defaultName", "Minecraft Server"), address: String::new(), focus: 1, packs: None, diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs index a6967816a..6ecaced9c 100644 --- a/crates/horizon-client/src/title.rs +++ b/crates/horizon-client/src/title.rs @@ -192,7 +192,7 @@ pub fn list_worlds(saves: &Path) -> Vec { commands: matches!(data.get("allowCommands"), Some(horizon_world::nbt::Tag::Byte(v)) if *v != 0), version: data.get("Version").and_then(|v| v.get("Name")) .and_then(|v| match v { horizon_world::nbt::Tag::String(s) => Some(s.to_string_lossy()), _ => None }) - .unwrap_or_else(|| "Unknown".into()), + .unwrap_or_else(|| lang::get_or("selectWorld.versionUnknown", "Unknown")), }) }) .collect(); @@ -272,7 +272,7 @@ impl Title { } pub(crate) fn new_world() -> Mode { Mode::Create { - name: "New World".into(), + name: lang::get_or("selectWorld.newWorld", "New World"), seed: String::new(), creative: false, focus: 0, @@ -867,7 +867,13 @@ impl Title { } Mode::Select { worlds, selected } => { crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false); - centered(atlas, batch, "Select World", 8.0, u32::MAX); + centered( + atlas, + batch, + &lang::get_or("selectWorld.title", "Select World"), + 8.0, + u32::MAX, + ); self.caret.borrow_mut().draw( batch, atlas, From f0649da024e683e1a2b3815a99033b06e63deb7b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:46:11 +0100 Subject: [PATCH 51/62] parity: server_ops_feedback ends steps on the server's clock, not a 2 s sleep Built on the Client of the harness-await branch (#2114). Under 2.5 s server stalls the old harness fails (a command's feedback filed under the next step) and the new one passes 3 of 3. Co-Authored-By: Claude Sonnet 5.5 --- tools/test_server_ops_feedback_parity.py | 42 +++++++++++------------- 1 file changed, 19 insertions(+), 23 deletions(-) diff --git a/tools/test_server_ops_feedback_parity.py b/tools/test_server_ops_feedback_parity.py index f7b7a0e73..91854fac6 100644 --- a/tools/test_server_ops_feedback_parity.py +++ b/tools/test_server_ops_feedback_parity.py @@ -19,17 +19,16 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server - from .test_locator_bar_parity import generate_world, server_dir + from .test_dedicated_server_parity import Server, game_time + from .test_locator_bar_parity import Client, generate_world, server_dir except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server - from test_locator_bar_parity import generate_world, server_dir + from test_dedicated_server_parity import Server, game_time + from test_locator_bar_parity import Client, generate_world, server_dir NAME = 'server-ops-feedback-parity' # (label, what the console does, what the players do). @@ -53,7 +52,11 @@ QUIET = [ ('alice', [], ['cmd Alice time set 3000']), ] CASES = {'broadcast': ({}, BROADCAST), 'quiet': ({'broadcast-console-to-ops': 'false'}, QUIET)} -STEP_SECONDS = 2.0 +STEP_TICKS = 40 +# A step ends by the server's clock (Client.wait): after a round trip of Alice's (Bob is deopped for a while, so +# his is not used). While send_command_feedback is off a command has no reply for her, so those steps wait for +# the ticks alone. +NO_SYNC = {'feedback-off', 'console-feedback-off'} # Steps whose reply can take longer than a step: the next step waits for this console line first. A loaded machine # took 2 s to save vanilla's world, and the transcript ended before "Saved the game". WAIT_FOR = {'console-save': r'System chat: Saved the game'} @@ -72,33 +75,26 @@ def run_side(label, case, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-{case}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) - - def tell(line): - client.stdin.write(line + '\n') - client.stdin.flush() + client = Client(client_command, port, out, log) try: for name in ('Alice', 'Bob'): - tell(f'join {name}') + client.tell(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - time.sleep(STEP_SECONDS) - tell('chat on') + client.wait(server, ['Alice'], STEP_TICKS) + client.tell('chat on') for step, console, actions in script: - tell(f'step {step}') + client.tell(f'step {step}') for command in console: server.console(command) + game_time(server) # the console runs its queue in order: these commands have run for action in actions: - tell(action) + client.tell(action) if step in WAIT_FOR: server.wait_for(WAIT_FOR[step], timeout=120) - time.sleep(STEP_SECONDS) - tell('end') - client.wait(timeout=60) + client.wait(server, [] if step in NO_SYNC else ['Alice'], STEP_TICKS) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): From 6a7951e150aaf013bf27959591a590c3ac9b5e45 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:09:28 +0100 Subject: [PATCH 52/62] mob_ai oracle: create a Peaceful scenario's hostile mobs past canSpawn EntityType.create returns null for a type that isn't allowedInPeaceful once the difficulty is Peaceful, so the peaceful_* scenarios threw in the oracle. Their mobs stand for ones already in the world when the difficulty changed. Co-Authored-By: Claude Opus 5.5 --- .../test/java/dev/horizonlab/parity/VanillaMobAiOracle.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java index 0345a4bc6..256333d46 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java @@ -60,6 +60,7 @@ import net.minecraft.util.debugchart.SampleLogger; import net.minecraft.world.clock.WorldClocks; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.EntitySpawnReason; +import net.minecraft.world.entity.EntitySpawnRequest; import net.minecraft.world.entity.EntityType; import net.minecraft.world.entity.EntityTypes; import net.minecraft.world.entity.monster.creaking.Creaking; @@ -540,7 +541,9 @@ public final class VanillaMobAiOracle { int id = 100000; for (MobSpec spec : s.mobs) { EntityType type = BuiltInRegistries.ENTITY_TYPE.getValue(net.minecraft.resources.Identifier.parse(spec.type)); - Mob mob = (Mob) type.create(level, EntitySpawnReason.COMMAND); + // Ignore canSpawn: a Peaceful scenario's hostile mob is one that was already + // in the world when the difficulty changed (create returns null at Peaceful). + Mob mob = (Mob) type.create(level, new EntitySpawnRequest(EntitySpawnReason.COMMAND, true)); if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, ENTS.size())); mob.setId(id++); mob.snapTo(spec.x, spec.y, spec.z, spec.yaw, 0.0F); From a34cad379faf46b163a3a26ea8b4c1aa85dcb142 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:32:27 +0100 Subject: [PATCH 53/62] mod registry image: copy horizon-shader-api, which horizon-mods now depends on Every Railway build of the registry has failed since horizon-mods gained the optional horizon-shader-api dependency ("no matching package named horizon-shader-api"). Built the same context locally: OK. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-mod-registry/Dockerfile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/horizon-mod-registry/Dockerfile b/crates/horizon-mod-registry/Dockerfile index 13522165a..ecd3a9164 100644 --- a/crates/horizon-mod-registry/Dockerfile +++ b/crates/horizon-mod-registry/Dockerfile @@ -4,6 +4,8 @@ WORKDIR /src # The root manifest only for the shared crate's workspace settings (edition, lints). COPY Cargo.toml Cargo.toml COPY crates/horizon-mods crates/horizon-mods +# horizon-mods' optional dependency: cargo needs its manifest even with the feature off. +COPY crates/horizon-shader-api crates/horizon-shader-api COPY crates/horizon-mod-registry crates/horizon-mod-registry RUN cargo build --release --locked --manifest-path crates/horizon-mod-registry/Cargo.toml From 4b3af580d97a1d99a44144d4977ad24ed844b2d8 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:34:52 +0100 Subject: [PATCH 54/62] mob_ai: drop the Peaceful type scenarios that diverge for other reasons A slime made without finalizeSpawn keeps 20 health where the probe's has 1, the probe doesn't report a piglin's brain, and a NoAI bee's flower cooldown runs one tick apart; none of that is the Peaceful despawn rule. Co-Authored-By: Claude Opus 5.5 --- tools/test_mob_ai_parity.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tools/test_mob_ai_parity.py b/tools/test_mob_ai_parity.py index 7aaa597e1..2ce6541e8 100644 --- a/tools/test_mob_ai_parity.py +++ b/tools/test_mob_ai_parity.py @@ -320,8 +320,9 @@ def scenarios(): 'player 6.5 -60 0.5', f'mob minecraft:zombie 0.5 -60 0.5 0 1 {flags}', ], f'difficulty={difficulty} time=18000') - for species in ('skeleton', 'creeper', 'slime', 'warden', 'wither', - 'piglin', 'shulker', 'bee', 'wolf', 'iron_golem', 'cow'): + # Not slime, piglin or bee: a slime made without finalizeSpawn keeps 20 health, the probe + # doesn't model a piglin's brain, and a NoAI bee's flower cooldown differs (none of it Peaceful). + for species in ('skeleton', 'creeper', 'warden', 'wither', 'shulker', 'wolf', 'iron_golem', 'cow'): add(f'peaceful_type_{species}', 1, [ 'player 6.5 -60 0.5', f'mob minecraft:{species} 0.5 -60 0.5 0 1 persistent noai', From 145c4c877b23e65e471b0cc99cf5b34a4999c8c2 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:37:04 +0100 Subject: [PATCH 55/62] Quiet commands: the server runs a mod's batch of commands with no chat A Horizon client sends a client mod's batch of command lines as one `horizon:quiet_commands` payload, which Horizon's server announces only to Horizon clients. Each line runs exactly as the player typing it would (the same checks, their own permission level), with vanilla's suppressed output: no feedback and no failure in anyone's chat. Batches wait in a queue: at most 64 lines run per player per tick, and at most 4096 wait. Each finished batch is one line in the server's log. tools/quiet_commands_e2e.py checks it on the dedicated server: a non-op's quiet setblock is refused, an op's runs, and nothing reaches the chat. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 1 + crates/horizon-client/src/game/commands.rs | 21 ++- crates/horizon-client/src/game/lan.rs | 11 ++ crates/horizon-client/src/game/lan_actions.rs | 92 ++++++---- crates/horizon-client/src/game/lan_chat.rs | 6 +- crates/horizon-client/src/game/lan_quiet.rs | 165 +++++++++++++++++ crates/horizon-client/src/game/net_harness.rs | 24 ++- crates/horizon-client/src/lan/conn.rs | 11 ++ crates/horizon-protocol/src/lib.rs | 1 + crates/horizon-protocol/src/quiet.rs | 166 ++++++++++++++++++ tools/quiet_commands_e2e.py | 135 ++++++++++++++ 11 files changed, 592 insertions(+), 41 deletions(-) create mode 100644 crates/horizon-client/src/game/lan_quiet.rs create mode 100644 crates/horizon-protocol/src/quiet.rs create mode 100644 tools/quiet_commands_e2e.py diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index b397882cd..9bb6602fd 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -80,6 +80,7 @@ mod lan_mobs; mod lan_mount_menu; mod lan_particles; mod lan_pvp; +mod lan_quiet; mod lan_screen; mod lan_stations; mod lan_trading; diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index f3afdcab6..dbe5d0ada 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -85,16 +85,16 @@ fn format_double(v: f64) -> String { impl Game<'_> { /// Commands.performCommand for a line without its slash. - pub(super) fn run_command(&mut self, command: &str) { + pub(super) fn run_command(&mut self, command: &str) -> bool { if self.mod_command(command) { - return; + return true; } let d = vanilla::game_dispatcher(); let parse = d.parse(command, &self.ui.registries); let result = match parse.executable() { Err(e) => { self.syntax_failure(&e, command); - return; + return false; } Ok((ctx, _)) => { let ctx = ctx.clone(); @@ -103,6 +103,7 @@ impl Game<'_> { self.run_chain(&root, &ctx) } }; + let ok = result.is_ok(); if let Err(e) = result { if e.input.is_some() { self.syntax_failure(&e, command); @@ -114,6 +115,20 @@ impl Game<'_> { if self.player.is_some() { self.check_inventory_trigger(); } + ok + } + /// `run_command` with its output suppressed + /// (`CommandSourceStack.withSuppressedOutput`): the player's own source, + /// rights and checks, no feedback and no failure in the chat. + pub(super) fn run_command_quietly(&mut self, command: &str) -> bool { + let quiet = execute::Source { + silent: true, + ..self.player_source() + }; + let outer = self.command_source.replace(quiet); + let ok = self.run_command(command); + self.command_source = outer; + ok } fn syntax_failure(&mut self, e: &CommandError, command: &str) { self.command_failure(e.message.clone()); diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 50fa222e6..b2af02f8a 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -71,6 +71,8 @@ pub(super) struct LanHost { /// Guests' commands waiting for the hub to be back in `self.lan`, where /// a command can reach every player (game/lan_actions.rs). pub commands: Vec, + /// Mods' quiet commands waiting to run a few a tick (game/lan_quiet.rs). + pub quiet: std::collections::VecDeque, /// The entities the guests track, described again every tick /// (`lan_entities`) over last tick's states. states: lan::entity::States, @@ -596,6 +598,7 @@ impl Game<'_> { waypoint_dead: Default::default(), border_sent: None, commands: Vec::new(), + quiet: std::collections::VecDeque::new(), states: Default::default(), }); self.audio.capture = Some(Vec::new()); @@ -1029,6 +1032,14 @@ impl Game<'_> { } host.states = states; } + if !host.quiet.is_empty() { + self.lan = Some(host); + self.run_quiet_commands(); + host = self + .lan + .take() + .expect("the hub is back after the quiet commands"); + } self.lan_flush_effects(&mut host); if !paused { self.tick_guests(&mut host); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index bbb0c37c0..0ad14bbcc 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -94,11 +94,14 @@ pub(super) struct GuestPlay { /// A guest's command waiting for the hub (`LanHost::commands`). pub(super) struct GuestCommand { - conn: u32, - command: String, - permission: u8, + pub(super) conn: u32, + pub(super) command: String, + pub(super) permission: u8, /// An integrated server's: no level teleports (yet). - integrated: bool, + pub(super) integrated: bool, + /// A mod's quiet command (game/lan_quiet.rs): its output suppressed, as + /// `CommandSourceStack.withSuppressedOutput` does. + pub(super) quiet: bool, } /// The game's own state while a guest's is swapped in (`enter_guest`), and @@ -1210,6 +1213,9 @@ impl Game<'_> { self.guest_carried_back(host, gi); } S::ChatCommand(c) => self.guest_chat_command(host, conn, &c.command), + S::CustomPayload(p) if p.channel == horizon_protocol::quiet::CHANNEL => { + self.guest_quiet_commands(host, conn, &p.data) + } S::ChatCommandSigned(p) => self.guest_signed_command(host, conn, p), S::ChangeDifficulty(p) if host.hub.guests[gi].permission >= 2 => { if !self.level.difficulty_locked && (0..=3).contains(&p.difficulty) { @@ -1559,6 +1565,7 @@ impl Game<'_> { command: command.trim_start_matches('/').to_owned(), permission, integrated, + quiet: false, }); } @@ -1573,41 +1580,54 @@ impl Game<'_> { return; } let c = host.commands.remove(0); - let mut host = self.lan.take().expect("checked above"); - let Some(swap) = self.enter_guest(&mut host, c.conn) else { - self.lan = Some(host); - continue; - }; - self.lan = Some(host); - self.chat_capture = Some(Vec::new()); - let level = std::mem::replace(&mut self.ui.registries.permission, c.permission); - self.run_command(&c.command); - self.ui.registries.permission = level; - let lines = self.chat_capture.take().unwrap_or_default(); - let mut host = self.lan.take().expect("a command puts the hub back"); - self.leave_guest(&mut host, swap); - host.hub.sync_all_effects(); - if !c.integrated { - // A teleport into another level happens before its feedback is sent. - self.run_level_teleports(&mut host); - } - // What the command earned is announced before its feedback. - self.announce_guest_advancements(&mut host); - for line in lines { - host.hub.send_to( - c.conn, - &C::SystemChat(play::SystemChat { - content: horizon_client::lan::data::component_nbt(&line.component()), - overlay: false, - }), - ); - } - // The other operators hear of it; never the player whose command it was. - self.send_admin_feedback(&mut host, Some(c.conn)); - self.lan = Some(host); + self.run_guest_command(c); } } + /// One guest's command as that guest, its feedback sent to them; false + /// when it failed (or the guest is gone). + pub(super) fn run_guest_command(&mut self, c: GuestCommand) -> bool { + let Some(mut host) = self.lan.take() else { + return false; + }; + let Some(swap) = self.enter_guest(&mut host, c.conn) else { + self.lan = Some(host); + return false; + }; + self.lan = Some(host); + self.chat_capture = Some(Vec::new()); + let level = std::mem::replace(&mut self.ui.registries.permission, c.permission); + let ok = if c.quiet { + self.run_command_quietly(&c.command) + } else { + self.run_command(&c.command) + }; + self.ui.registries.permission = level; + let lines = self.chat_capture.take().unwrap_or_default(); + let mut host = self.lan.take().expect("a command puts the hub back"); + self.leave_guest(&mut host, swap); + host.hub.sync_all_effects(); + if !c.integrated { + // A teleport into another level happens before its feedback is sent. + self.run_level_teleports(&mut host); + } + // What the command earned is announced before its feedback. + self.announce_guest_advancements(&mut host); + for line in lines { + host.hub.send_to( + c.conn, + &C::SystemChat(play::SystemChat { + content: horizon_client::lan::data::component_nbt(&line.component()), + overlay: false, + }), + ); + } + // The other operators hear of it; never the player whose command it was. + self.send_admin_feedback(&mut host, Some(c.conn)); + self.lan = Some(host); + ok + } + /// The `broadcastToAdmins` lines a command queued (`source`: the guest /// whose it was; none for the host's or the console's): every other /// operator gets them, and the console logs them as the server's own diff --git a/crates/horizon-client/src/game/lan_chat.rs b/crates/horizon-client/src/game/lan_chat.rs index f678480ab..621955967 100644 --- a/crates/horizon-client/src/game/lan_chat.rs +++ b/crates/horizon-client/src/game/lan_chat.rs @@ -28,7 +28,11 @@ impl Game<'_> { /// SignableCommand.of: the command's message arguments, by name, with /// their text, not past a redirect to the root (`execute ... run`). - fn signable_arguments(&mut self, permission: u8, command: &str) -> Vec<(String, String)> { + pub(super) fn signable_arguments( + &mut self, + permission: u8, + command: &str, + ) -> Vec<(String, String)> { let parse = self.parse_as(permission, command); let nodes = &vanilla::game_dispatcher().nodes; let root = parse.context.root; diff --git a/crates/horizon-client/src/game/lan_quiet.rs b/crates/horizon-client/src/game/lan_quiet.rs new file mode 100644 index 000000000..63d382c02 --- /dev/null +++ b/crates/horizon-client/src/game/lan_quiet.rs @@ -0,0 +1,165 @@ +//! Quiet commands (`horizon_protocol::quiet`): a Horizon client's mod sends a +//! batch of command lines in one payload, and the server runs each exactly as +//! that player typing it would (`guest_command`'s checks, the player's own +//! permission level, at the time it runs) with its output suppressed, as +//! vanilla's functions run (`CommandSourceStack.withSuppressedOutput`): no +//! feedback and no failure in anyone's chat. A batch waits in a queue and runs +//! [`PER_TICK`] lines a player a tick, so a mod can't flood a server; each +//! finished batch is one line in the server's log. +use super::{Game, lan::LanHost, lan_actions::GuestCommand}; +use horizon_protocol::quiet; +use std::collections::{HashMap, VecDeque}; + +/// Lines a player may have waiting at most; a batch past it loses the rest. +pub(super) const PENDING: usize = 4096; +/// Lines run a player a tick at most. +pub(super) const PER_TICK: usize = 64; + +/// A batch waiting to run. +pub(super) struct QuietBatch { + conn: u32, + mod_id: String, + lines: VecDeque, + ran: usize, + failed: usize, + /// Lines past [`PENDING`], never run. + dropped: usize, +} + +impl Game<'_> { + /// A `horizon:quiet_commands` payload from `conn`: queued (or logged as + /// refused when it breaks the payload's caps). + pub(super) fn guest_quiet_commands(&mut self, host: &mut LanHost, conn: u32, data: &[u8]) { + let Some(name) = host.hub.guest(conn).map(|g| g.name.clone()) else { + return; + }; + let batch = match quiet::decode(data) { + Ok(b) => b, + Err(e) => { + super::dedicated::log( + "WARN", + &format!("{name} sent quiet commands that were refused: {e}"), + ); + return; + } + }; + let waiting: usize = host + .quiet + .iter() + .filter(|b| b.conn == conn) + .map(|b| b.lines.len()) + .sum(); + let room = PENDING.saturating_sub(waiting); + let dropped = batch.lines.len().saturating_sub(room); + host.quiet.push_back(QuietBatch { + conn, + mod_id: batch.mod_id, + lines: batch.lines.into_iter().take(room).collect(), + ran: 0, + failed: 0, + dropped, + }); + } + + /// The waiting batches, [`PER_TICK`] lines a player this tick, in order. + pub(super) fn run_quiet_commands(&mut self) { + let mut left: HashMap = HashMap::new(); + let mut i = 0; + loop { + let Some(host) = self.lan.as_mut() else { + return; + }; + let Some(batch) = host.quiet.get_mut(i) else { + return; + }; + let conn = batch.conn; + let budget = left.entry(conn).or_insert(PER_TICK); + let gone = host.hub.guest(conn).is_none(); + if gone || batch.lines.is_empty() { + let batch = host.quiet.remove(i).expect("got it above"); + if !gone { + let name = host + .hub + .guest(conn) + .map_or(String::new(), |g| g.name.clone()); + super::dedicated::log("INFO", &summary(&name, &batch)); + } + continue; + } + if *budget == 0 { + i += 1; + continue; + } + *budget -= 1; + let line = batch.lines.pop_front().expect("not empty"); + let ok = self.run_quiet_line(conn, &line); + if let Some(batch) = self.lan.as_mut().and_then(|h| h.quiet.get_mut(i)) { + batch.ran += 1; + batch.failed += usize::from(!ok); + } + } + } + + /// One line as `guest_command` would run it for `conn`, quietly. False + /// when it is refused or fails. A command that carries a chat message + /// (`say`, `msg`...) is refused: it would need the player's signature. + fn run_quiet_line(&mut self, conn: u32, line: &str) -> bool { + let allowed = self.options.dedicated.is_some() || self.allow_commands(); + let Some(host) = self.lan.as_ref() else { + return false; + }; + let integrated = host.hub.config.integrated; + if !integrated && (!host.settings.guest_commands || !allowed) { + return false; + } + let Some(permission) = host.hub.guest(conn).map(|g| g.permission) else { + return false; + }; + let command = line.trim_start_matches('/'); + if !self.signable_arguments(permission, command).is_empty() { + return false; + } + self.run_guest_command(GuestCommand { + conn, + command: command.to_owned(), + permission, + integrated, + quiet: true, + }) + } +} + +/// The batch's line in the server's log. +fn summary(name: &str, b: &QuietBatch) -> String { + let mut line = format!( + "{name} ran {} quiet command(s) from mod {}: {} failed", + b.ran, b.mod_id, b.failed + ); + if b.dropped > 0 { + line += &format!(", {} dropped (more than {PENDING} waiting)", b.dropped); + } + line +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn the_log_line_counts_the_batch() { + let b = QuietBatch { + conn: 1, + mod_id: "orbital".into(), + lines: VecDeque::new(), + ran: 12, + failed: 3, + dropped: 0, + }; + assert_eq!( + summary("Alex", &b), + "Alex ran 12 quiet command(s) from mod orbital: 3 failed" + ); + let b = QuietBatch { dropped: 5, ..b }; + assert!(summary("Alex", &b).ends_with(", 5 dropped (more than 4096 waiting)")); + } +} diff --git a/crates/horizon-client/src/game/net_harness.rs b/crates/horizon-client/src/game/net_harness.rs index 1ec573e7c..468f1db71 100644 --- a/crates/horizon-client/src/game/net_harness.rs +++ b/crates/horizon-client/src/game/net_harness.rs @@ -3,7 +3,10 @@ //! window, waits until it stands in the world with the chunks around it, //! sends a chat message and `/list`, collects the chat it is shown, leaves //! and writes a JSON report (position, chunks, chat lines, whether the -//! server kept it connected throughout). +//! server kept it connected throughout). With `HORIZON_NET_QUIET` (lines +//! split by `;`) it then sends them as one batch of a mod's quiet commands +//! (`horizon_protocol::quiet`, `tools/quiet_commands_e2e.py`) and waits two +//! seconds for any chat they bring. use super::Game; use horizon_client::Result; use serde_json::json; @@ -23,6 +26,9 @@ impl Game<'_> { let mut step_at = Instant::now(); let mut chat_at = 0; let mut position = None; + let quiet: Vec = std::env::var("HORIZON_NET_QUIET") + .map(|v| v.split(';').map(str::to_owned).collect()) + .unwrap_or_default(); let mut chunks = 0; let mut error = None; while Instant::now() < deadline { @@ -71,6 +77,22 @@ impl Game<'_> { step_at = now; chat_at = shown; } + 2 if answered && !quiet.is_empty() => { + for data in horizon_protocol::quiet::encode("net_harness", &quiet) { + self.send(horizon_protocol::packets::play::Serverbound::CustomPayload( + horizon_protocol::packets::configuration::CustomPayload { + channel: horizon_protocol::quiet::CHANNEL.into(), + data, + }, + )); + } + step = 4; + step_at = now; + } + 4 if now - step_at > Duration::from_secs(2) => { + step = 3; + break; + } 2 if answered => { step = 3; break; diff --git a/crates/horizon-client/src/lan/conn.rs b/crates/horizon-client/src/lan/conn.rs index fb91f3006..f2dcf701d 100644 --- a/crates/horizon-client/src/lan/conn.rs +++ b/crates/horizon-client/src/lan/conn.rs @@ -823,6 +823,17 @@ fn login_and_configure( _ => {} } }; + // A Horizon client hears that this server runs its mods' quiet commands + // (horizon_protocol::quiet); a vanilla one is told nothing. + if brand == "horizon" { + send( + c, + cfg::Clientbound::CustomPayload(cfg::CustomPayload { + channel: horizon_protocol::quiet::CHANNEL.into(), + data: Vec::new(), + }), + )?; + } for packet in sync.registry_packets(known_pack) { send(c, cfg::Clientbound::RegistryData(packet))?; } diff --git a/crates/horizon-protocol/src/lib.rs b/crates/horizon-protocol/src/lib.rs index f0bea2ca2..299688560 100644 --- a/crates/horizon-protocol/src/lib.rs +++ b/crates/horizon-protocol/src/lib.rs @@ -11,6 +11,7 @@ pub mod frame; pub mod ids; pub mod item; pub mod packets; +pub mod quiet; pub mod registry; mod resolver; pub mod rsa; diff --git a/crates/horizon-protocol/src/quiet.rs b/crates/horizon-protocol/src/quiet.rs new file mode 100644 index 000000000..dcf48dbee --- /dev/null +++ b/crates/horizon-protocol/src/quiet.rs @@ -0,0 +1,166 @@ +//! Quiet commands: a client mod's batch of commands that a Horizon server runs +//! as the player who sent them, at that player's own permission level, with +//! no feedback in the chat (docs/mods.md, `command.run-quiet`). +//! +//! The server announces it understands them with an empty [`CHANNEL`] payload +//! in the configuration phase (a vanilla client ignores it); a client that +//! hears it sends each batch as a serverbound [`CHANNEL`] payload, and falls +//! back to chat commands on any other server. A payload is the mod's id, then +//! the lines without their slash. +use crate::{ + Error, Result, + buf::{Reader, Writer}, +}; + +/// The custom payload channel, both ways. +pub const CHANNEL: &str = "horizon:quiet_commands"; +/// Lines in one payload at most; a payload with more is refused whole. +pub const MAX_LINES: usize = 256; +/// Characters in a line at most (a chat command's limit). +pub const MAX_LINE: usize = 256; +/// Characters in a mod id at most. +pub const MAX_MOD_ID: usize = 64; +/// Bytes of a serverbound custom payload's data at most +/// (ServerboundCustomPayloadPacket.MAX_PAYLOAD_SIZE). +pub const MAX_PAYLOAD: usize = 32767; + +/// A batch as the server reads it. +#[derive(Clone, Debug, PartialEq)] +pub struct Batch { + pub mod_id: String, + pub lines: Vec, +} + +/// `lines` as few payloads as fit [`MAX_PAYLOAD`] and [`MAX_LINES`], in +/// order. Lines longer than [`MAX_LINE`] are cut, as a chat command's are. +pub fn encode(mod_id: &str, lines: &[String]) -> Vec> { + let mod_id: String = mod_id.chars().take(MAX_MOD_ID).collect(); + let mut payloads = Vec::new(); + let mut rest = lines + .iter() + .map(|l| -> String { l.chars().take(MAX_LINE).collect() }); + let mut next = rest.next(); + while next.is_some() { + let mut batch = Vec::new(); + // The id, the count (a varint of at most 2 bytes for 256). + let mut size = string_size(&mod_id) + 2; + while let Some(line) = next.take() { + let more = string_size(&line); + if !batch.is_empty() && (batch.len() == MAX_LINES || size + more > MAX_PAYLOAD) { + next = Some(line); + break; + } + size += more; + batch.push(line); + next = rest.next(); + } + let mut w = Writer::new(); + w.string(&mod_id); + w.varint(batch.len() as i32); + for line in &batch { + w.string(line); + } + payloads.push(w.data); + } + payloads +} + +fn string_size(s: &str) -> usize { + crate::buf::varint_size(s.len() as i32) + s.len() +} + +/// A payload's batch; an error for one that breaks a cap. +pub fn decode(data: &[u8]) -> Result { + if data.len() > MAX_PAYLOAD { + return Err(Error::new("quiet commands: payload too big")); + } + let mut r = Reader::new(data); + let mod_id = r.string(MAX_MOD_ID)?; + let count = r.varint()?; + if !(0..=MAX_LINES as i32).contains(&count) { + return Err(Error::new(format!("quiet commands: {count} lines"))); + } + let lines = (0..count) + .map(|_| r.string(MAX_LINE)) + .collect::>>()?; + if r.remaining() > 0 { + return Err(Error::new("quiet commands: trailing bytes")); + } + Ok(Batch { mod_id, lines }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn a_batch_round_trips() { + let lines = vec!["fill 0 0 0 1 1 1 stone".to_string(), "say hi".to_string()]; + let payloads = encode("orbital", &lines); + assert_eq!(payloads.len(), 1); + assert_eq!( + decode(&payloads[0]).unwrap(), + Batch { + mod_id: "orbital".into(), + lines + } + ); + } + + #[test] + fn big_batches_split_by_lines_and_bytes() { + let lines: Vec = (0..600) + .map(|i| format!("setblock {i} 0 0 stone")) + .collect(); + let payloads = encode("m", &lines); + let decoded: Vec = payloads.iter().map(|p| decode(p).unwrap()).collect(); + assert_eq!( + decoded.iter().map(|b| b.lines.len()).collect::>(), + [256, 256, 88] + ); + assert_eq!( + decoded + .into_iter() + .flat_map(|b| b.lines) + .collect::>(), + lines + ); + let long: Vec = (0..256).map(|_| "x".repeat(300)).collect(); + for p in encode("m", &long) { + assert!(p.len() <= MAX_PAYLOAD); + assert!( + decode(&p) + .unwrap() + .lines + .iter() + .all(|l| l.len() == MAX_LINE) + ); + } + } + + #[test] + fn payloads_over_the_caps_are_refused() { + let mut w = Writer::new(); + w.string("m"); + w.varint(MAX_LINES as i32 + 1); + for _ in 0..=MAX_LINES { + w.string("say"); + } + assert!(decode(&w.data).is_err()); + let mut w = Writer::new(); + w.string("m"); + w.varint(1); + w.string(&"x".repeat(MAX_LINE + 1)); + assert!(decode(&w.data).is_err()); + let mut w = Writer::new(); + w.string("m"); + w.varint(-1); + assert!(decode(&w.data).is_err()); + assert!(decode(&[0xFF]).is_err()); + let mut w = Writer::new(); + w.string("m"); + w.varint(0); + w.u8(1); + assert!(decode(&w.data).is_err()); + } +} diff --git a/tools/quiet_commands_e2e.py b/tools/quiet_commands_e2e.py new file mode 100644 index 000000000..f7008bbd6 --- /dev/null +++ b/tools/quiet_commands_e2e.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python3 +"""Mods' quiet commands on Horizon's dedicated server, end to end (horizon_protocol::quiet). + +Horizon's dedicated server (a flat world) and Horizon's headless client (`HORIZON_NET_REPORT`, the net +harness), which joins, then sends a batch of quiet commands as a mod would (`HORIZON_NET_QUIET`): + +- as a player who isn't an operator: `setblock` is refused (the block stays air), as it would be typed; +- as an operator: `setblock` runs, a `fill` that changes nothing fails, and `say` is refused (a chat + message needs the player's signature); +- either way the player's chat gets nothing of them, and the server logs one line per batch: the player, + the mod, how many ran and how many failed. + + python3 tools/quiet_commands_e2e.py --bin-dir target/fast + +The client runs with fresh HORIZON_HOME, launcher and XDG folders and without audio; the logs go to --out. +""" +import argparse +import json +import os +import shutil +import subprocess +import sys +import tempfile +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import lab # noqa: E402 +from integration_env import run_game # noqa: E402 +from test_dedicated_server_parity import Server # noqa: E402 + +ROOT = Path(__file__).resolve().parents[1] +PLAYER = 'Tester' +PROPERTIES = { + 'online-mode': 'false', + 'white-list': 'false', + 'level-type': 'minecraft\\:flat', + 'generate-structures': 'false', + 'spawn-protection': '0', + 'view-distance': '3', + 'simulation-distance': '3', + 'pause-when-empty-seconds': '-1', +} +BLOCK = '2 -55 2' +# What a player would see of these commands, were they typed. +FEEDBACK = ['Changed the block', 'No blocks were filled', 'Unknown or incomplete command', 'hi from a mod', + 'Could not set the block'] + + +def join(binary, port, out, label, lines): + """The headless client joins, sends `lines` as one quiet batch and leaves: its report.""" + home = Path(tempfile.mkdtemp(prefix=f'quiet-{label}-')) + report = out / f'{label}-report.json' + # run_game gives the game fresh home, launcher and XDG folders. + env = dict(HORIZON_NET_REPORT=str(report), HORIZON_NET_QUIET=';'.join(lines)) + with (out / f'{label}-client.log').open('w') as log: + run_game([str(binary), '--resources', str(lab.RESOURCES), '--render-distance', '2', + '--server', f'127.0.0.1:{port}', '--name', PLAYER], + cwd=home, env=dict(os.environ, **env), stdout=log, stderr=subprocess.STDOUT, timeout=300, + check=True) + shutil.rmtree(home, ignore_errors=True) + return json.loads(report.read_text()) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--bin-dir', help='a prebuilt horizon-client (default: build it with the fast profile)') + parser.add_argument('--out', default=str(ROOT / '.local/quiet-commands-e2e'), help='logs go here') + args = parser.parse_args() + out = Path(args.out) + shutil.rmtree(out, ignore_errors=True) + out.mkdir(parents=True) + if args.bin_dir: + binary = Path(args.bin_dir) / 'horizon-client' + else: + subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], + cwd=ROOT, check=True) + binary = Path(lab.cargo_target()) / 'fast' / 'horizon-client' + port = lab.free_port() + directory = out / 'server' + directory.mkdir() + props = dict(PROPERTIES, **{'server-port': str(port)}) + (directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()), + encoding='iso-8859-1') + (directory / 'eula.txt').write_text('eula=true\n') + server = Server([binary, '--resources', lab.RESOURCES, '--dedicated', '--nogui'], directory, 'server') + failures = [] + + def check(what, ok, detail=''): + print(('PASS ' if ok else 'FAIL ') + what + ('' if ok else f': {detail}')) + if not ok: + failures.append(what) + + def test_block(want): + """The console's `execute if block`: 'Test passed' when the block is `want`.""" + before = len(server.lines) + server.console(f'execute if block {BLOCK} {want}') + deadline = time.time() + 30 + while time.time() < deadline: + answer = [l for l in server.lines[before:] if 'Test passed' in l or 'Test failed' in l] + if answer: + return 'Test passed' in answer[0] + time.sleep(0.2) + raise AssertionError('the console never answered execute if block') + + try: + server.wait_for(r'Done \(') + # Not an operator: the setblock is refused, as typed. + got = join(binary, port, out, 'not-op', [f'setblock {BLOCK} minecraft:gold_block']) + server.wait_for(rf'{PLAYER} ran 1 quiet command\(s\) from mod net_harness: 1 failed', timeout=30) + check('not an operator: connected throughout', got['error'] is None, got['error']) + check("not an operator: a quiet setblock is refused", not test_block('minecraft:gold_block')) + heard = [c for c in got['chat'] if any(f in c for f in FEEDBACK)] + check('not an operator: nothing in the chat', not heard, heard) + server.wait_for(rf'{PLAYER} left the game', timeout=60) + # An operator: it runs, quietly. + server.console(f'op {PLAYER}') + server.wait_for(rf'Made {PLAYER} a server operator', timeout=30) + got = join(binary, port, out, 'op', [f'setblock {BLOCK} minecraft:gold_block', + f'fill {BLOCK} {BLOCK} minecraft:gold_block', 'say hi from a mod']) + server.wait_for(rf'{PLAYER} ran 3 quiet command\(s\) from mod net_harness: 2 failed', timeout=30) + check('operator: connected throughout', got['error'] is None, got['error']) + check('operator: the quiet setblock ran', test_block('minecraft:gold_block')) + heard = [c for c in got['chat'] if any(f in c for f in FEEDBACK)] + check('operator: nothing in the chat (no feedback, no failure, no say)', not heard, heard) + said = [l for l in server.lines if 'hi from a mod' in l] + check('operator: say is refused', not said, said) + finally: + server.stop() + print(f'logs: {out}') + sys.exit(1 if failures else 0) + + +if __name__ == '__main__': + main() From 9e76f8c4f0928500b28a5504d6815c487bb476ba Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 14:12:04 +0100 Subject: [PATCH 56/62] parity-main: a failure that passes again at HEAD counts as a pass Twice today (runs 40301239508, 40311712302) mob_ai failed in parity-main, passed when bisect ran it again at the same HEAD, and the run still ended red, so no game release could follow main for three hours. The harness step now continues on error and the bisect step gives the verdict: 0 when every failed harness passes again at HEAD, 1 when they fail at the base too or a merge is named. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/parity-main.yml | 9 ++++++--- tests/test_parity_main.py | 5 +++-- tools/parity_main.py | 17 +++++++++-------- 3 files changed, 18 insertions(+), 13 deletions(-) diff --git a/.github/workflows/parity-main.yml b/.github/workflows/parity-main.yml index c47005ab0..70fb33796 100644 --- a/.github/workflows/parity-main.yml +++ b/.github/workflows/parity-main.yml @@ -48,6 +48,9 @@ jobs: GH_TOKEN: ${{ github.token }} run: echo "sha=$(python3 tools/parity_main.py base)" >> "$GITHUB_OUTPUT" - name: The harnesses the merges since then can affect + id: harnesses + # A failure here is judged by the next step: the run passes when every failed harness passes again at HEAD. + continue-on-error: true env: PARITY_HOSTS: '' BASE_SHA: ${{ steps.base.outputs.sha }} @@ -55,8 +58,8 @@ jobs: echo "Merges since ${BASE_SHA}:" git log --first-parent --format=' %h %s' "$BASE_SHA..HEAD" python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400 - - name: The merge that broke them - if: failure() + - name: A flake, or the merge that broke them + if: steps.harnesses.outcome == 'failure' env: GH_TOKEN: ${{ github.token }} PARITY_HOSTS: '' @@ -65,7 +68,7 @@ jobs: rm -rf .local/parity-main-logs && cp -R .local/parity-runner/logs .local/parity-main-logs 2>/dev/null || true python3 tools/parity_main.py bisect "$BASE_SHA" --comment - name: Logs of the failed harnesses - if: failure() + if: steps.harnesses.outcome == 'failure' uses: actions/upload-artifact@v4 with: name: parity-main-logs diff --git a/tests/test_parity_main.py b/tests/test_parity_main.py index aa58375a6..46e3d0466 100644 --- a/tests/test_parity_main.py +++ b/tests/test_parity_main.py @@ -45,7 +45,7 @@ class ParityMainTests(unittest.TestCase): last_run.parent.mkdir(parents=True) last_run.write_text('{"failed": ["music"]}') real_run = parity_main.subprocess.run - for broken_from, blamed in ((None, None), (0, None), (2, "2")): + for broken_from, blamed, code in ((None, None, 0), (0, None, 1), (2, "2", 1)): comments = [] # git runs for real in the scratch repo; a `gh pr comment` is only recorded, never sent. fake_run = lambda command, **kwargs: (comments.append(command) if command[0] == "gh" @@ -55,7 +55,8 @@ class ParityMainTests(unittest.TestCase): and commits.index(git("rev-parse", "HEAD")) >= broken_from), \ mock.patch.object(parity_main.subprocess, "run", fake_run), \ mock.patch("builtins.print") as printed: - parity_main.bisect(commits[0], 60, comment=True) + self.assertEqual(parity_main.bisect(commits[0], 60, comment=True), code, + "0 only when the failures pass again at HEAD") if blamed: self.assertEqual([command[3] for command in comments], [blamed]) else: diff --git a/tools/parity_main.py b/tools/parity_main.py index 76fa49070..f61c9b028 100644 --- a/tools/parity_main.py +++ b/tools/parity_main.py @@ -78,34 +78,35 @@ def bisect(since, timeout, comment): failed = json.loads(LAST_RUN.read_text(encoding="utf-8")).get("failed") or [] if not failed: print("No failed harness recorded: nothing to bisect.") - return 0 + return 1 head = git("rev-parse", "HEAD").stdout.strip() commits = git("rev-list", "--first-parent", "--reverse", f"{since}..{head}").stdout.split() if not commits: print("No merge since the base.") - return 0 + return 1 def fails(commit): print(f"--- {commit[:9]} {git('log', '-1', '--format=%s', commit).stdout.strip()}", flush=True) git("checkout", "-q", "--detach", commit) return run_harnesses(failed, timeout) - def blame_nobody(why): + def blame_nobody(why, code): line = f"parity-main: {', '.join(failed)} {why}: no merge is named." print(line) if os.environ.get("GITHUB_STEP_SUMMARY"): with open(os.environ["GITHUB_STEP_SUMMARY"], "a", encoding="utf-8") as summary: summary.write(f"### {line}\n") - return 0 + return code # A merge is named only when the harnesses fail again at HEAD and pass at the base: otherwise the search would # end on the newest merge (a flake, or a runner missing files, passes everywhere now) or the oldest one (the - # runner fails at every commit) and blame it for nothing. + # runner fails at every commit) and blame it for nothing. The exit code is the run's verdict: 0 only when every + # failed harness passes when run again at HEAD (the commit is good, so releases may follow it), 1 otherwise. try: if not fails(head): - return blame_nobody(f"pass when run again at {head[:9]}: a flake or the runner") + return blame_nobody(f"pass when run again at {head[:9]}: a flake, counted as a pass", 0) if fails(since): - return blame_nobody(f"fail at the base {since[:9]} too: the runner or a flake") + return blame_nobody(f"fail at the base {since[:9]} too: the runner or a flake", 1) culprit = first_bad(commits, fails) if len(commits) > 1 else commits[0] finally: git("checkout", "-q", "--detach", head) @@ -122,7 +123,7 @@ def bisect(since, timeout, comment): body = (f"🤖 Agent: parity-main found that this merge breaks {', '.join(f'`{name}`' for name in failed)} on main " f"(bisected over {len(commits)} merges: {url}). Releases wait until parity-main passes again.") subprocess.run(["gh", "pr", "comment", number.group(1), "--repo", REPO, "--body", body]) - return 0 + return 1 def main(): From 455817204f21983955e1e83ef57026caa89d55d9 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 14:04:54 +0100 Subject: [PATCH 57/62] Mod registry: 1-5 star ratings, one per GitHub account The registry service keeps players' ratings of published projects in one SQLite file on a volume (REGISTRY_DB, /data on Railway): - GET /api/mods/ratings: every rated project's average and count, cached a minute; never who rated. - GET /api/mods/{id}/rating: the signed-in account's own rating. - POST /api/mods/{id}/rating: sets or changes it, checked like a submission (origin, session, CSRF token), 30 per account and 600 in all per hour, only for projects on the registry's main, never by their owners. - The sign-in takes ?back=/mods/ to come back to a project's page. The image hands the volume to nobody before running as nobody. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-mod-registry/Cargo.lock | 84 +++++- crates/horizon-mod-registry/Cargo.toml | 2 + crates/horizon-mod-registry/Dockerfile | 6 +- crates/horizon-mod-registry/README.md | 24 +- crates/horizon-mod-registry/src/lib.rs | 280 ++++++++++++++++---- crates/horizon-mod-registry/src/main.rs | 5 +- crates/horizon-mod-registry/src/ratings.rs | 129 +++++++++ crates/horizon-mod-registry/tests/submit.rs | 121 ++++++++- 8 files changed, 581 insertions(+), 70 deletions(-) create mode 100644 crates/horizon-mod-registry/src/ratings.rs diff --git a/crates/horizon-mod-registry/Cargo.lock b/crates/horizon-mod-registry/Cargo.lock index f80068fcc..59bd37134 100644 --- a/crates/horizon-mod-registry/Cargo.lock +++ b/crates/horizon-mod-registry/Cargo.lock @@ -294,6 +294,18 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "fallible-iterator" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649" + +[[package]] +name = "fallible-streaming-iterator" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a" + [[package]] name = "find-msvc-tools" version = "0.1.15" @@ -310,6 +322,12 @@ dependencies = [ "miniz_oxide", ] +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + [[package]] name = "foldhash" version = "0.2.0" @@ -394,17 +412,35 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + [[package]] name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" dependencies = [ - "foldhash", + "foldhash 0.2.0", "serde", "serde_core", ] +[[package]] +name = "hashlink" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1" +dependencies = [ + "hashbrown 0.15.5", +] + [[package]] name = "hmac" version = "0.12.1" @@ -424,6 +460,7 @@ dependencies = [ "hmac", "horizon-mods", "http-body-util", + "rusqlite", "serde", "serde_json", "sha2", @@ -651,7 +688,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" dependencies = [ "equivalent", - "hashbrown", + "hashbrown 0.17.1", "serde", "serde_core", ] @@ -674,6 +711,17 @@ version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" +[[package]] +name = "libsqlite3-sys" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "133c182a6a2c87864fe97778797e46c7e999672690dc9fa3ee8e241aa4a9c13f" +dependencies = [ + "cc", + "pkg-config", + "vcpkg", +] + [[package]] name = "litemap" version = "0.8.3" @@ -767,7 +815,7 @@ dependencies = [ "cfg_aliases", "codespan-reporting", "half", - "hashbrown", + "hashbrown 0.17.1", "indexmap", "libm", "log", @@ -786,7 +834,7 @@ version = "30.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49" dependencies = [ - "hashbrown", + "hashbrown 0.17.1", "indexmap", "rustc-hash", "thiserror", @@ -820,6 +868,12 @@ version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + [[package]] name = "potential_utf" version = "0.1.6" @@ -867,6 +921,20 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rusqlite" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "165ca6e57b20e1351573e3729b958bc62f0e48025386970b6e4d29e7a7e71f3f" +dependencies = [ + "bitflags", + "fallible-iterator", + "fallible-streaming-iterator", + "hashlink", + "libsqlite3-sys", + "smallvec", +] + [[package]] name = "rustc-hash" version = "1.1.0" @@ -1316,6 +1384,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + [[package]] name = "version_check" version = "0.9.5" @@ -1344,7 +1418,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757" dependencies = [ "bitflags", - "hashbrown", + "hashbrown 0.17.1", "indexmap", "semver", "serde", diff --git a/crates/horizon-mod-registry/Cargo.toml b/crates/horizon-mod-registry/Cargo.toml index affc08f62..959e84f91 100644 --- a/crates/horizon-mod-registry/Cargo.toml +++ b/crates/horizon-mod-registry/Cargo.toml @@ -23,6 +23,8 @@ hmac = "0.12" sha2 = "0.10" base64 = "0.22" getrandom = "0.3" +# Ratings: one SQLite file on a small volume, as the telemetry server keeps its data. +rusqlite = { version = "0.37", features = ["bundled"] } [dev-dependencies] tower = { version = "0.5", features = ["util"] } diff --git a/crates/horizon-mod-registry/Dockerfile b/crates/horizon-mod-registry/Dockerfile index ecd3a9164..ee2065008 100644 --- a/crates/horizon-mod-registry/Dockerfile +++ b/crates/horizon-mod-registry/Dockerfile @@ -12,5 +12,7 @@ RUN cargo build --release --locked --manifest-path crates/horizon-mod-registry/C FROM debian:stable-slim RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && rm -rf /var/lib/apt/lists/* COPY --from=build /src/crates/horizon-mod-registry/target/release/horizon-mod-registry /usr/local/bin/ -USER nobody -CMD ["horizon-mod-registry"] +ENV REGISTRY_DB=/data/registry.sqlite3 +# Railway mounts the ratings' volume at /data owned by root: hand it to nobody, then run as nobody (setpriv is +# util-linux's, in every Debian image). +CMD ["sh", "-c", "mkdir -p /data && chown nobody:nogroup /data && exec setpriv --reuid=nobody --regid=nogroup --clear-groups horizon-mod-registry"] diff --git a/crates/horizon-mod-registry/README.md b/crates/horizon-mod-registry/README.md index f7cdc68c5..d609e6739 100644 --- a/crates/horizon-mod-registry/README.md +++ b/crates/horizon-mod-registry/README.md @@ -7,20 +7,26 @@ entry's fields), uploads it to the `staging` release of request adding or updating `mods/.toml`. That repository's CI checks it again, with a trial run of a mod in the sandbox; reviewers decide, and merging publishes. Formats and rules: [docs/api/mod-index.md](../../docs/api/mod-index.md). -It keeps no data: a session is a signed cookie holding the GitHub login, and the user's OAuth token is used once, to -read that login, and dropped. The sign-in asks for no scope. +Signed-in players also rate published projects, 1 to 5 stars: one rating per GitHub account and project, which they can +change, never their own project's. That is the only data it keeps, in one SQLite file (`REGISTRY_DB`); it only ever +shows totals, never who rated. A session is a signed cookie holding the GitHub login and id, and the user's OAuth token +is used once, to read them, and dropped. The sign-in asks for no scope. | Route | | | --- | --- | -| `GET /api/mods/auth/login` | Starts the GitHub sign-in | -| `GET /api/mods/auth/callback` | GitHub's redirect: sets the session, back to `/mods/submit` | +| `GET /api/mods/auth/login` | Starts the GitHub sign-in; `?back=/mods/` (or `/mods`) comes back to that page | +| `GET /api/mods/auth/callback` | GitHub's redirect: sets the session, back to `/mods/submit` or the `back` page | | `POST /api/mods/auth/logout` | Ends it | | `GET /api/mods/me` | `{login, csrf}`, or 401 | | `POST /api/mods/submit` | Multipart: `entry` (JSON: `id kind name summary description authors license source icon key signature version game changelog`) and `file`; `{pull_request}` or `{error}` | +| `GET /api/mods/ratings` | `{projects: {: {average, count}}}` for every rated project; cached a minute | +| `GET /api/mods//rating` | The signed-in account's own `{stars}` (null when it hasn't rated), or 401 | +| `POST /api/mods//rating` | JSON `{stars}`, 1 to 5: sets or changes it; `{stars, average, count}` or `{error}` | | `GET /healthz` | `ok` | -A submission must come from `REGISTRY_PUBLIC_URL`'s origin with the session's `X-CSRF-Token`. Six per account and sixty -in all per hour. Only an entry's `owners` publish its updates; a key change, an icon in the repository or anything else +A submission or a rating must come from `REGISTRY_PUBLIC_URL`'s origin with the session's `X-CSRF-Token`. Six +submissions per account and sixty in all per hour; thirty ratings per account and 600 in all. A project's owners can't +rate it, and only projects on the registry's `main` can be rated. Only an entry's `owners` publish its updates; a key change, an icon in the repository or anything else is a pull request by hand. ## Running it @@ -28,7 +34,7 @@ is a pull request by hand. ```sh cargo test # against a mock GitHub (tests/submit.rs) REGISTRY_PUBLIC_URL=http://localhost:4173 REGISTRY_SESSION_KEY=... GITHUB_CLIENT_ID=... GITHUB_CLIENT_SECRET=... \ - GITHUB_BOT_TOKEN=... REGISTRY_REPO=you/horizon-mods-test cargo run + GITHUB_BOT_TOKEN=... REGISTRY_REPO=you/horizon-mods-test REGISTRY_DB=/tmp/registry.sqlite3 cargo run ``` | Variable | | @@ -38,10 +44,12 @@ REGISTRY_PUBLIC_URL=http://localhost:4173 REGISTRY_SESSION_KEY=... GITHUB_CLIENT | `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET` | The OAuth app | | `GITHUB_BOT_TOKEN` | Fine-grained, the registry repository only: Contents and Pull requests read and write | | `REGISTRY_REPO` | Default `ludovic111/horizon-mods` | +| `REGISTRY_DB` | The ratings' SQLite file: default `/data/registry.sqlite3`, the volume | | `PORT` | Default 8080 | On Railway it is the service `horizon-mod-registry` of the project `horizon-site`, next to the website: built from -`main` with this `Dockerfile` from the repository root, health check `/healthz`, no public domain and no volume. The +`main` with this `Dockerfile` from the repository root, health check `/healthz`, no public domain, and the volume +`registry-data` at `/data` for the ratings. The website's Caddy sends `/api/mods/*` to it over Railway's private network (`REGISTRY_UPSTREAM` on the website service: `http://horizon-mod-registry.railway.internal:8080`). `railway.json` lists the same settings; Railway reads them from the service, not from the file. diff --git a/crates/horizon-mod-registry/src/lib.rs b/crates/horizon-mod-registry/src/lib.rs index 72970017a..661337c8c 100644 --- a/crates/horizon-mod-registry/src/lib.rs +++ b/crates/horizon-mod-registry/src/lib.rs @@ -2,13 +2,15 @@ //! `playhorizon.dev/api/mods/*` (docs/api/mod-index.md). A creator signs in //! with GitHub, sends a file and its page; the service runs the file's own //! checks, uploads it to the registry's `staging` release and opens a pull -//! request with the entry. Reviewers decide; merging publishes. It keeps no -//! data: sessions are signed cookies, and GitHub holds everything else. +//! request with the entry. Reviewers decide; merging publishes. Signed-in +//! players also rate published projects (`ratings`, its only data: sessions +//! are signed cookies, and GitHub holds everything else). pub mod github; +pub mod ratings; use axum::{ Json, Router, - extract::{DefaultBodyLimit, Multipart, Query, State}, + extract::{DefaultBodyLimit, Multipart, Path as UrlPath, Query, State}, http::{HeaderMap, StatusCode, header}, response::{IntoResponse, Redirect, Response}, routing::{get, post}, @@ -20,6 +22,7 @@ use horizon_mods::index::{ self, Kind, registry::{self, Entry, EntryVersion, Sources}, }; +use ratings::Ratings; use serde::Deserialize; use serde_json::json; use sha2::Sha256; @@ -37,6 +40,12 @@ const PER_ACCOUNT: usize = 6; const PER_HOUR: usize = 60; /// The page's JSON. const MAX_FORM: usize = 64 << 10; +/// Ratings set per account per hour, and by everyone. +const RATINGS_PER_ACCOUNT: usize = 30; +const RATINGS_PER_HOUR: usize = 600; +/// How long the ratings' totals are served from memory (and cached by +/// browsers and the launcher). +const TOTALS_FOR: Duration = Duration::from_secs(60); pub struct Config { /// `https://playhorizon.dev`: where the form is, and the only origin it @@ -47,11 +56,14 @@ pub struct Config { pub github: GitHub, /// Where files wait during a submission. pub scratch: PathBuf, + /// The ratings' SQLite file (a volume): `:memory:` keeps them in memory. + pub database: PathBuf, } impl Config { /// `REGISTRY_PUBLIC_URL`, `REGISTRY_SESSION_KEY`, `REGISTRY_REPO`, - /// `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET`, `GITHUB_BOT_TOKEN`. + /// `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET`, `GITHUB_BOT_TOKEN`, + /// `REGISTRY_DB` (default `/data/registry.sqlite3`). pub fn from_env() -> Result { let var = |name: &str| std::env::var(name).map_err(|_| format!("{name} is not set")); let key = var("REGISTRY_SESSION_KEY")?; @@ -69,6 +81,8 @@ impl Config { var("GITHUB_BOT_TOKEN")?, ), scratch: std::env::temp_dir().join("horizon-mod-registry"), + database: std::env::var_os("REGISTRY_DB") + .map_or_else(|| PathBuf::from("/data/registry.sqlite3"), PathBuf::from), }) } @@ -80,17 +94,31 @@ impl Config { #[derive(Clone)] pub struct App(Arc); +type Windows = Mutex>>; + struct Inner { config: Config, - recent: Mutex>>, + /// Submissions in the last hour, by account ("" for everyone's). + recent: Windows, + /// Ratings set in the last hour, the same way. + rated: Windows, + ratings: Mutex, + /// `GET /api/mods/ratings`' body, and when it was made. + totals: Mutex>, } impl App { - pub fn new(config: Config) -> App { - App(Arc::new(Inner { + /// Fails when the ratings' file can't be opened. + pub fn new(config: Config) -> Result { + let ratings = Ratings::open(&config.database) + .map_err(|e| format!("{}: {e}", config.database.display()))?; + Ok(App(Arc::new(Inner { config, - recent: Mutex::new(HashMap::new()), - })) + recent: Mutex::default(), + rated: Mutex::default(), + ratings: Mutex::new(ratings), + totals: Mutex::default(), + }))) } } @@ -101,6 +129,8 @@ pub fn router(app: App) -> Router { .route("/api/mods/auth/callback", get(callback)) .route("/api/mods/auth/logout", post(logout)) .route("/api/mods/me", get(me)) + .route("/api/mods/ratings", get(totals)) + .route("/api/mods/{id}/rating", get(my_rating).post(rate)) .route( "/api/mods/submit", post(submit).layer(DefaultBodyLimit::max( @@ -203,9 +233,29 @@ fn csrf(app: &Inner, headers: &HeaderMap) -> Option { Some(signed.rsplit('.').next()?.chars().take(32).collect()) } -async fn login(State(app): State) -> Response { +#[derive(Deserialize)] +struct Login { + /// The site's page to come back to: `/mods`, `/mods/submit` (the + /// default) or `/mods/`. + back: Option, +} + +/// Whether `path` is a registry page a sign-in may come back to. +fn registry_page(path: &str) -> bool { + match path.strip_prefix("/mods") { + Some("") => true, + Some(rest) => rest.strip_prefix('/').is_some_and(index::valid_id) || rest == "/submit", + None => false, + } +} + +async fn login(State(app): State, Query(q): Query) -> Response { let state = random_hex(); - let signed = sign(&app.0.config.session_key, &state); + let back = q + .back + .filter(|b| registry_page(b)) + .unwrap_or_else(|| "/mods/submit".into()); + let signed = sign(&app.0.config.session_key, &format!("{state}\n{back}")); let url = app .0 .config @@ -229,13 +279,17 @@ async fn callback( headers: HeaderMap, Query(q): Query, ) -> Result { - let expected = cookie(&headers, "hm_state").and_then(|v| unsign(&app.0.config.session_key, &v)); - if expected.as_deref() != Some(q.state.as_str()) { + let started = cookie(&headers, "hm_state").and_then(|v| unsign(&app.0.config.session_key, &v)); + let Some((_, back)) = started + .as_deref() + .and_then(|s| s.split_once('\n')) + .filter(|(state, _)| *state == q.state) + else { return Err(Refusal::new( StatusCode::FORBIDDEN, "the sign-in expired or didn't start here: try again", )); - } + }; let inner = app.0.clone(); let (login, id) = tokio::task::spawn_blocking(move || { inner @@ -250,7 +304,7 @@ async fn callback( &app.0.config.session_key, &format!("{login}\n{id}\n{}", now() + SESSION), ); - let back = format!("{}/mods/submit", app.0.config.public_url); + let back = format!("{}{back}", app.0.config.public_url); let mut response = Redirect::to(&back).into_response(); let headers = response.headers_mut(); headers.append( @@ -283,6 +337,131 @@ async fn me( )) } +fn database(e: rusqlite::Error) -> Refusal { + eprintln!("horizon-mod-registry: ratings: {e}"); + Refusal::new( + StatusCode::INTERNAL_SERVER_ERROR, + "the ratings can't be read right now", + ) +} + +/// A mean as the pages show it: two decimals. +fn rounded(average: f64) -> f64 { + (average * 100.0).round() / 100.0 +} + +/// `GET /api/mods/ratings`: `{"projects": {"": {"average", "count"}}}` for +/// every rated project. Totals only: never who rated. +async fn totals(State(app): State) -> Result { + let mut cached = app.0.totals.lock().unwrap(); + let body = match cached.as_ref().filter(|(at, _)| at.elapsed() < TOTALS_FOR) { + Some((_, body)) => body.clone(), + None => { + let all = app + .0 + .ratings + .lock() + .unwrap() + .summaries() + .map_err(database)?; + let projects: serde_json::Map = all + .into_iter() + .map(|(id, s)| (id, json!({"average": rounded(s.average), "count": s.count}))) + .collect(); + let body = json!({ "projects": projects }).to_string(); + *cached = Some((Instant::now(), body.clone())); + body + } + }; + Ok(( + [ + (header::CONTENT_TYPE, "application/json"), + (header::CACHE_CONTROL, "public, max-age=60"), + ], + body, + ) + .into_response()) +} + +/// `GET /api/mods/{id}/rating`: the signed-in account's own rating, +/// `{"stars": 1..5}` or `{"stars": null}`. +async fn my_rating( + State(app): State, + headers: HeaderMap, + UrlPath(id): UrlPath, +) -> Result, Refusal> { + let (_, account) = session(&app.0, &headers) + .ok_or_else(|| Refusal::new(StatusCode::UNAUTHORIZED, "not signed in"))?; + let stars = app + .0 + .ratings + .lock() + .unwrap() + .mine(&id, account) + .map_err(database)?; + Ok(Json(json!({ "stars": stars }))) +} + +#[derive(Deserialize)] +struct Rating { + stars: u8, +} + +/// `POST /api/mods/{id}/rating` with `{"stars": 1..5}`: sets or changes the +/// signed-in account's rating of a published project, not its own. Answers +/// the project's new totals and `stars`. +async fn rate( + State(app): State, + headers: HeaderMap, + UrlPath(id): UrlPath, + Json(rating): Json, +) -> Result, Refusal> { + let inner = app.0.clone(); + let (login, account) = signed_in_here(&inner, &headers)?; + if !(1..=5).contains(&rating.stars) { + return Err(bad("a rating is 1 to 5 stars")); + } + if !index::valid_id(&id) { + return Err(Refusal::new(StatusCode::NOT_FOUND, "no such project")); + } + if !allow(&inner.rated, &login, RATINGS_PER_ACCOUNT, RATINGS_PER_HOUR) { + return Err(Refusal::new( + StatusCode::TOO_MANY_REQUESTS, + "too many ratings this hour: try again later", + )); + } + let lookup = inner.clone(); + let wanted = id.clone(); + let entry = tokio::task::spawn_blocking(move || lookup.config.github.entry(&wanted)) + .await + .map_err(|_| Refusal::new(StatusCode::INTERNAL_SERVER_ERROR, "the check crashed"))? + .map_err(github_down)?; + let Some((entry, _)) = entry else { + return Err(Refusal::new( + StatusCode::NOT_FOUND, + format!("{id} isn't published in the registry"), + )); + }; + if entry.owners.iter().any(|o| o.eq_ignore_ascii_case(&login)) { + return Err(Refusal::new( + StatusCode::FORBIDDEN, + "you publish this project: its players rate it", + )); + } + let summary = { + let ratings = inner.ratings.lock().unwrap(); + ratings + .rate(&id, account, rating.stars, now()) + .map_err(database)?; + ratings.summary(&id).map_err(database)? + }; + *inner.totals.lock().unwrap() = None; + let (average, count) = summary.map_or((0.0, 0), |s| (rounded(s.average), s.count)); + Ok(Json( + json!({"stars": rating.stars, "average": average, "count": count}), + )) +} + /// The page a submission fills in: a project's fields, and the version's. #[derive(Clone, Debug, Deserialize)] #[serde(deny_unknown_fields)] @@ -322,45 +501,56 @@ fn take(window: &mut VecDeque, max: usize) -> bool { window.len() < max } +/// A change sent by the site's own pages: from its origin, signed in, with +/// the session's CSRF token. The account: (login, id). +fn signed_in_here(app: &Inner, headers: &HeaderMap) -> Result<(String, u64), Refusal> { + let origin = headers.get(header::ORIGIN).and_then(|v| v.to_str().ok()); + if origin != Some(app.config.public_url.as_str()) { + return Err(Refusal::new( + StatusCode::FORBIDDEN, + "send it from the registry's pages", + )); + } + let account = session(app, headers) + .ok_or_else(|| Refusal::new(StatusCode::UNAUTHORIZED, "sign in with GitHub first"))?; + let sent = headers.get("x-csrf-token").and_then(|v| v.to_str().ok()); + if sent.is_none() || sent.map(str::to_owned) != csrf(app, headers) { + return Err(Refusal::new( + StatusCode::FORBIDDEN, + "reload the page and try again", + )); + } + Ok(account) +} + +/// Counts one more for `login` and for everyone, unless either is at its +/// hourly limit. +fn allow(windows: &Windows, login: &str, per_account: usize, per_hour: usize) -> bool { + let mut windows = windows.lock().unwrap(); + let account = login.to_lowercase(); + let ok = take(windows.entry(String::new()).or_default(), per_hour) + && take(windows.entry(account.clone()).or_default(), per_account); + if ok { + let at = Instant::now(); + windows.entry(String::new()).or_default().push_back(at); + windows.entry(account).or_default().push_back(at); + } + ok +} + async fn submit( State(app): State, headers: HeaderMap, mut multipart: Multipart, ) -> Result, Refusal> { let inner = app.0.clone(); - let origin = headers.get(header::ORIGIN).and_then(|v| v.to_str().ok()); - if origin != Some(inner.config.public_url.as_str()) { + let (login, user_id) = signed_in_here(&inner, &headers)?; + if !allow(&inner.recent, &login, PER_ACCOUNT, PER_HOUR) { return Err(Refusal::new( - StatusCode::FORBIDDEN, - "submit from the registry's form", + StatusCode::TOO_MANY_REQUESTS, + "too many submissions this hour: try again later", )); } - let (login, user_id) = session(&inner, &headers) - .ok_or_else(|| Refusal::new(StatusCode::UNAUTHORIZED, "sign in with GitHub first"))?; - let sent = headers.get("x-csrf-token").and_then(|v| v.to_str().ok()); - if sent.is_none() || sent.map(str::to_owned) != csrf(&inner, &headers) { - return Err(Refusal::new( - StatusCode::FORBIDDEN, - "reload the form and try again", - )); - } - { - let mut recent = inner.recent.lock().unwrap(); - let ok = take(recent.entry(String::new()).or_default(), PER_HOUR) - && take(recent.entry(login.to_lowercase()).or_default(), PER_ACCOUNT); - if !ok { - return Err(Refusal::new( - StatusCode::TOO_MANY_REQUESTS, - "too many submissions this hour: try again later", - )); - } - let at = Instant::now(); - recent.entry(String::new()).or_default().push_back(at); - recent - .entry(login.to_lowercase()) - .or_default() - .push_back(at); - } let dir = inner.config.scratch.join(random_hex()); std::fs::create_dir_all(&dir) .map_err(|e| Refusal::new(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?; diff --git a/crates/horizon-mod-registry/src/main.rs b/crates/horizon-mod-registry/src/main.rs index 81fe1b7b6..a1e40a57a 100644 --- a/crates/horizon-mod-registry/src/main.rs +++ b/crates/horizon-mod-registry/src/main.rs @@ -1,5 +1,5 @@ //! `horizon-mod-registry`: serves on `PORT` (default 8080). Configured by the -//! environment (see `Config::from_env`); keeps no data. +//! environment (see `Config::from_env`); keeps the ratings in `REGISTRY_DB`. use std::net::SocketAddr; use horizon_mod_registry::{App, Config, router}; @@ -16,7 +16,8 @@ async fn main() { .await .unwrap_or_else(|e| panic!("port {port}: {e}")); eprintln!("horizon-mod-registry: listening on {port}, submitting to {repo}"); - axum::serve(listener, router(App::new(config))) + let app = App::new(config).unwrap_or_else(|e| panic!("horizon-mod-registry: {e}")); + axum::serve(listener, router(app)) .with_graceful_shutdown(async { let _ = tokio::signal::ctrl_c().await; }) diff --git a/crates/horizon-mod-registry/src/ratings.rs b/crates/horizon-mod-registry/src/ratings.rs new file mode 100644 index 000000000..0cba85142 --- /dev/null +++ b/crates/horizon-mod-registry/src/ratings.rs @@ -0,0 +1,129 @@ +//! Players' ratings of published projects, 1 to 5 stars: one per GitHub +//! account and project, which its rater can change. Stored in one SQLite +//! file (a Railway volume). Only totals leave it: never who rated what, +//! except a signed-in account's own rating, to that account. +use rusqlite::{Connection, OptionalExtension, params}; +use std::{collections::BTreeMap, path::Path}; + +const SCHEMA: &str = " +PRAGMA journal_mode = WAL; +PRAGMA synchronous = NORMAL; +CREATE TABLE IF NOT EXISTS ratings ( + project TEXT NOT NULL, + account INTEGER NOT NULL, + stars INTEGER NOT NULL CHECK (stars BETWEEN 1 AND 5), + updated INTEGER NOT NULL, + PRIMARY KEY (project, account) +) WITHOUT ROWID; +"; + +/// A project's ratings: their mean, and how many. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Summary { + pub average: f64, + pub count: u64, +} + +pub struct Ratings { + db: Connection, +} + +impl Ratings { + /// Opens (or creates) the file at `path`; `:memory:` for a test. + pub fn open(path: &Path) -> rusqlite::Result { + let db = Connection::open(path)?; + db.execute_batch(SCHEMA)?; + Ok(Ratings { db }) + } + + /// Sets `account`'s rating of `project`, replacing an earlier one. + pub fn rate(&self, project: &str, account: u64, stars: u8, now: u64) -> rusqlite::Result<()> { + self.db.execute( + "INSERT INTO ratings (project, account, stars, updated) VALUES (?1, ?2, ?3, ?4) + ON CONFLICT (project, account) DO UPDATE SET stars = excluded.stars, updated = excluded.updated", + params![project, account as i64, stars, now as i64], + )?; + Ok(()) + } + + /// `account`'s own rating of `project`. + pub fn mine(&self, project: &str, account: u64) -> rusqlite::Result> { + self.db + .query_row( + "SELECT stars FROM ratings WHERE project = ?1 AND account = ?2", + params![project, account as i64], + |r| r.get(0), + ) + .optional() + } + + /// `project`'s summary; None when nobody rated it. + pub fn summary(&self, project: &str) -> rusqlite::Result> { + self.db + .query_row( + "SELECT avg(stars), count(*) FROM ratings WHERE project = ?1 HAVING count(*) > 0", + [project], + |r| { + Ok(Summary { + average: r.get(0)?, + count: r.get::<_, i64>(1)? as u64, + }) + }, + ) + .optional() + } + + /// Every rated project's summary. + pub fn summaries(&self) -> rusqlite::Result> { + let mut statement = self + .db + .prepare("SELECT project, avg(stars), count(*) FROM ratings GROUP BY project")?; + let rows = statement.query_map([], |r| { + Ok(( + r.get::<_, String>(0)?, + Summary { + average: r.get(1)?, + count: r.get::<_, i64>(2)? as u64, + }, + )) + })?; + rows.collect() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn one_rating_per_account_and_project() { + let r = Ratings::open(Path::new(":memory:")).unwrap(); + r.rate("zoom", 1, 5, 10).unwrap(); + r.rate("zoom", 2, 2, 10).unwrap(); + r.rate("zoom", 1, 4, 11).unwrap(); + r.rate("minimap", 1, 3, 11).unwrap(); + assert_eq!(r.mine("zoom", 1).unwrap(), Some(4)); + assert_eq!(r.mine("zoom", 3).unwrap(), None); + let all = r.summaries().unwrap(); + assert_eq!( + all["zoom"], + Summary { + average: 3.0, + count: 2 + } + ); + assert_eq!( + all["minimap"], + Summary { + average: 3.0, + count: 1 + } + ); + assert_eq!(r.summary("zoom").unwrap(), Some(all["zoom"])); + assert_eq!(r.summary("nothing").unwrap(), None); + assert!( + r.rate("zoom", 1, 6, 12).is_err(), + "the table checks the range too" + ); + } +} diff --git a/crates/horizon-mod-registry/tests/submit.rs b/crates/horizon-mod-registry/tests/submit.rs index f27f18697..d5591d4fc 100644 --- a/crates/horizon-mod-registry/tests/submit.rs +++ b/crates/horizon-mod-registry/tests/submit.rs @@ -1,6 +1,6 @@ //! The whole submission against a mock GitHub: sign in, submit the sample //! signed mod (`crates/horizon-mods/tests/index`), and what lands on GitHub; -//! then what is refused. +//! then what is refused. Then ratings: who may rate what, and what is shown. use axum::{ Json, Router, body::{Body, Bytes}, @@ -55,7 +55,9 @@ async fn mock_github() -> (String, Shared) { .route( "/user", get(|State(s): State| async move { - Json(json!({"login": s.lock().unwrap().login, "id": 7})) + let login = s.lock().unwrap().login.clone(); + let id = if login == "alice" { 7 } else { 8 }; + Json(json!({"login": login, "id": id})) }), ) .route( @@ -174,7 +176,16 @@ impl Client { } async fn sign_in(&mut self) -> String { - let (status, _, location) = self.send(self.get("/api/mods/auth/login")).await; + self.sign_in_from("").await + } + + /// Signs in from the page `back` (`?back=` of the sign-in; "" for none). + async fn sign_in_from(&mut self, back: &str) -> String { + let login = match back { + "" => "/api/mods/auth/login".to_owned(), + back => format!("/api/mods/auth/login?back={back}"), + }; + let (status, _, location) = self.send(self.get(&login)).await; assert_eq!(status, StatusCode::SEE_OTHER); let location = location.unwrap(); assert!(location.contains( @@ -197,10 +208,11 @@ impl Client { .send(self.get(&format!("/api/mods/auth/callback?code=good&state={state}"))) .await; assert_eq!(status, StatusCode::SEE_OTHER); - assert_eq!( - location.as_deref(), - Some("https://playhorizon.test/mods/submit") - ); + let page = match back { + "/mods" | "/mods/zoom" => back, + _ => "/mods/submit", + }; + assert_eq!(location, Some(format!("https://playhorizon.test{page}"))); let (status, me, _) = self.send(self.get("/api/mods/me")).await; assert_eq!(status, StatusCode::OK); me["csrf"].as_str().unwrap().to_owned() @@ -265,9 +277,10 @@ async fn setup() -> (Client, Shared) { "bot".into(), ), scratch, + database: ":memory:".into(), }; let client = Client { - app: router(App::new(config)), + app: router(App::new(config).unwrap()), cookies: HashMap::new(), }; (client, mock) @@ -376,3 +389,95 @@ async fn what_the_form_refuses() { "nothing reached GitHub" ); } + +const ENTRY: &str = "kind = \"mod\"\nname = \"N\"\nsummary = \"s\"\nlicense = \"MIT\"\nsource = \"https://x.test\"\n\n[[versions]]\nversion = \"1.0.0\"\npublished = \"2026-01-01\"\ngame = \"26.3\"\nfile = \"f.hmod\"\nsha256 = \"0000000000000000000000000000000000000000000000000000000000000000\"\n"; + +impl Client { + async fn rate(&mut self, csrf: &str, id: &str, body: &str) -> (StatusCode, Value) { + let request = Request::post(format!("/api/mods/{id}/rating")) + .header(header::COOKIE, self.cookie_header()) + .header(header::ORIGIN, PUBLIC) + .header("x-csrf-token", csrf) + .header(header::CONTENT_TYPE, "application/json") + .body(Body::from(body.to_owned())) + .unwrap(); + let (status, json, _) = self.send(request).await; + (status, json) + } +} + +#[tokio::test(flavor = "multi_thread")] +async fn ratings() { + let (mut client, mock) = setup().await; + { + let mut m = mock.lock().unwrap(); + m.main.insert( + "mods/zoom.toml".into(), + format!("id = \"zoom\"\nowners = [\"bob\"]\n{ENTRY}"), + ); + m.main.insert( + "mods/mine.toml".into(), + format!("id = \"mine\"\nowners = [\"Alice\"]\n{ENTRY}"), + ); + } + // Nothing rated yet; signed out, no own rating and no rating at all. + let (status, json, _) = client.send(client.get("/api/mods/ratings")).await; + assert_eq!((status, json), (StatusCode::OK, json!({"projects": {}}))); + let (status, ..) = client.send(client.get("/api/mods/zoom/rating")).await; + assert_eq!(status, StatusCode::UNAUTHORIZED); + let (status, _) = client.rate("x", "zoom", r#"{"stars": 4}"#).await; + assert_eq!(status, StatusCode::UNAUTHORIZED); + + // A sign-in from a project's page comes back to it; anywhere else is the form. + client.sign_in_from("https://evil.test/").await; + let csrf = client.sign_in_from("/mods/zoom").await; + let (status, json) = client.rate("wrong", "zoom", r#"{"stars": 4}"#).await; + assert_eq!(status, StatusCode::FORBIDDEN, "{json}"); + for stars in ["0", "6"] { + let (status, json) = client + .rate(&csrf, "zoom", &format!(r#"{{"stars": {stars}}}"#)) + .await; + assert_eq!(status, StatusCode::BAD_REQUEST, "{json}"); + } + let (status, json) = client.rate(&csrf, "zoom", r#"{"stars": 4}"#).await; + assert_eq!(status, StatusCode::OK, "{json}"); + assert_eq!(json, json!({"stars": 4, "average": 4.0, "count": 1})); + // Changing it replaces it. + let (status, json) = client.rate(&csrf, "zoom", r#"{"stars": 2}"#).await; + assert_eq!(status, StatusCode::OK, "{json}"); + assert_eq!(json["count"], 1); + let (_, json, _) = client.send(client.get("/api/mods/zoom/rating")).await; + assert_eq!(json, json!({"stars": 2})); + let (_, json, _) = client.send(client.get("/api/mods/minimap/rating")).await; + assert_eq!(json, json!({"stars": null})); + + // Not one's own project, nor one that isn't published. + let (status, json) = client.rate(&csrf, "mine", r#"{"stars": 5}"#).await; + assert_eq!(status, StatusCode::FORBIDDEN, "{json}"); + let (status, json) = client.rate(&csrf, "nothing", r#"{"stars": 5}"#).await; + assert_eq!(status, StatusCode::NOT_FOUND, "{json}"); + + // Another account's rating counts once more; the totals never say whose. + let mut other = Client { + app: client.app.clone(), + cookies: HashMap::new(), + }; + mock.lock().unwrap().login = "carol".into(); + let carol = other.sign_in().await; + let (status, json) = other.rate(&carol, "zoom", r#"{"stars": 5}"#).await; + assert_eq!(status, StatusCode::OK, "{json}"); + assert_eq!(json, json!({"stars": 5, "average": 3.5, "count": 2})); + let (status, json, _) = client.send(client.get("/api/mods/ratings")).await; + assert_eq!(status, StatusCode::OK); + assert_eq!( + json, + json!({"projects": {"zoom": {"average": 3.5, "count": 2}}}) + ); + + // The limit per account and hour. + let mut last = StatusCode::OK; + for _ in 0..40 { + (last, _) = client.rate(&csrf, "zoom", r#"{"stars": 3}"#).await; + } + assert_eq!(last, StatusCode::TOO_MANY_REQUESTS); +} From f49d5d91e6ca96ca70804fc0e8778d20b32d5fb5 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 14:29:02 +0100 Subject: [PATCH 58/62] Site: downloads and 1-5 star ratings on /mods - The list shows each project's rating (stars, mean and count) and its downloads ("12.3k downloads"), ordered by downloads by default; an Order menu also sorts by rating or name (?sort= too). - A project's page shows the same, then a rating control: five stars when signed in (the account's own rating lit), "Sign in with GitHub to rate" (coming back to the page) when not, a note for its owners. - Ratings come from the registry service's GET /api/mods/ratings; a rating is POSTed with the session's CSRF token. Until the service answers, the pages show downloads only. Co-Authored-By: Claude Opus 5.5 --- docs/mods.md | 4 ++ website/build.mjs | 5 +- website/src/mods-page.js | 98 +++++++++++++++++++++++++++++++++++---- website/src/mods.js | 72 +++++++++++++++++++++++++--- website/src/mods.test.mjs | 49 +++++++++++++++++++- website/src/style.css | 19 ++++++++ 6 files changed, 229 insertions(+), 18 deletions(-) diff --git a/docs/mods.md b/docs/mods.md index 0d26978dc..470c8aad8 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -515,6 +515,10 @@ published. Players find them at [playhorizon.dev/mods](https://playhorizon.dev/m 5. A reviewer merges it: within minutes the file is a release of horizon-mods, and the project is on the site and in the launcher. +Once it is published, its page and its card in the launcher show its downloads (GitHub's counts of its files, +refreshed every hour) and its rating: players signed in with GitHub on its page give it 1 to 5 stars, one rating per +account, which they can change. Its owners can't rate it, and nobody sees who rated. + An update is the same form with a new version; only the project's `owners` can publish one, signed with its key if it has one. A published file never changes. Without the form, open the pull request by hand (the repository's README says how). The formats: [api/mod-index.md](api/mod-index.md). diff --git a/website/build.mjs b/website/build.mjs index b979f83f8..8e93c82b4 100644 --- a/website/build.mjs +++ b/website/build.mjs @@ -18,7 +18,7 @@ import { CPUS, GPUS, singleThread } from "./src/hardware.js"; import { isGame, isLauncher, launcherVersion, newestFirst } from "./src/versions.js"; import { contributorsFrom, contributorsHtml } from "./src/contributors.js"; import { areaFilterHtml, boardFilterHtml, boardFrom, boardHtml, creditFrom, creditHtml, helpWantedHtml, journalFrom, journalHtml, journalJson, overviewHtml, roadmapHtml, slimIssue, suggestItemsHtml } from "./src/hub.js"; -import { INDEX_URL, KINDS, SUBMIT, listHtml, projectHtml, readIndex, submitHtml } from "./src/mods.js"; +import { INDEX_URL, KINDS, SORTS, SUBMIT, listHtml, projectHtml, readIndex, sorted, submitHtml } from "./src/mods.js"; const site = dirname(fileURLToPath(import.meta.url)); const dist = join(site, "dist"); @@ -484,10 +484,11 @@ const modsList = `

ModsMade for Horizon, r ${KINDS.map(([k, label]) => ` `).join("\n")} +

${modProjects.length} of ${modProjects.length}

-${listHtml(modProjects)} +${listHtml(sorted(modProjects, "downloads"))}
`; const modPages = [ { file: "mods.html", path: "/mods", title: "Mods", description: "Mods, modpacks and resource packs made for Horizon, reviewed, each with what it may do and how to install it.", main: modsList }, diff --git a/website/src/mods-page.js b/website/src/mods-page.js index 121ba8067..335e863bd 100644 --- a/website/src/mods-page.js +++ b/website/src/mods-page.js @@ -1,32 +1,47 @@ -// /mods and /mods/: the registry's list (kind filter, search) and a project's page. The pages are baked from -// the index at build time; this fetches the published index again so a project merged since shows at once. -import { INDEX_URL, KINDS, listHtml, matches, projectHtml, readIndex } from "./mods.js"; +// /mods and /mods/: the registry's list (kind filter, search, order) and a project's page. The pages are baked +// from the index at build time; this fetches the published index again so a project merged since shows at once, +// the ratings (crates/horizon-mod-registry), and on a project's page the signed-in player's own rating to change. +import { API, INDEX_URL, KINDS, RATINGS, SORTS, listHtml, matches, projectHtml, rateHtml, ratingOf, readIndex, sorted, starsHtml } from "./mods.js"; import { cached, setUpMenu, setUpTheme } from "./chrome.js"; +import { escape } from "./markdown.js"; const root = document.getElementById("mods"); const baked = readIndex(JSON.parse(document.getElementById("mods-index").textContent || "null")) || []; let projects = baked; +// Every project's ratings, once the service answered. +let ratings = null; let kind = "all"; let text = ""; +let order = "downloads"; +// On a project's page: the signed-in account ({login, csrf}) or null, and its own rating of the project. +let me; +let mine = null; const id = (location.pathname.match(/^\/mods\/([a-z0-9_]+)\/?$/) || [])[1]; function showList() { const list = root.querySelector("#mod-list"); if (!list) return; - const shown = projects.filter((p) => matches(p, kind, text)); - list.innerHTML = listHtml(shown); + const shown = sorted(projects.filter((p) => matches(p, kind, text)), order, ratings); + list.innerHTML = listHtml(shown, ratings); root.querySelector("[data-mod-count]").textContent = `${shown.length} of ${projects.length}`; root.querySelectorAll("[data-kind-filter]").forEach((b) => b.setAttribute("aria-pressed", String(b.dataset.kindFilter === kind))); } +function showRate(p, message = "") { + const rate = root.querySelector("#mod-rate"); + if (!rate || me === undefined) return; + rate.innerHTML = rateHtml(p, me, mine) + (message ? `

${escape(message)}

` : ""); +} + function showProject() { const p = projects.find((x) => x.id === id); const page = root.querySelector(".mod-page, .mod-missing"); if (!page) return; if (p) { - page.outerHTML = projectHtml(p); + page.outerHTML = projectHtml(p, ratings ? ratingOf(ratings, p.id) : undefined); document.title = `${p.name} · Horizon`; + showRate(p); } else { page.outerHTML = `

Not in the registry

No project is called ${id} here. It may not be published yet, or it was taken down.

Every mod
`; } @@ -37,7 +52,56 @@ function render() { else showList(); } -if (!id) { +// The signed-in account and its own rating, for the page's rating control. +async function signIn() { + try { + const r = await fetch(`${API}/me`, { credentials: "same-origin" }); + me = r.ok ? await r.json() : null; + if (me) { + const own = await fetch(`${API}/${id}/rating`, { credentials: "same-origin" }); + mine = own.ok ? (await own.json()).stars : null; + } + } catch { + me = null; + } + const p = projects.find((x) => x.id === id); + if (p) showRate(p); +} + +async function rate(stars) { + const p = projects.find((x) => x.id === id); + if (!p || !me) return; + root.querySelectorAll(".mod-star").forEach((b) => (b.disabled = true)); + let message = ""; + try { + const r = await fetch(`${API}/${id}/rating`, { + method: "POST", + credentials: "same-origin", + headers: { "Content-Type": "application/json", "X-CSRF-Token": me.csrf }, + body: JSON.stringify({ stars }), + }); + const json = await r.json().catch(() => ({})); + if (r.ok) { + mine = json.stars; + ratings = { ...ratings, [id]: { average: json.average, count: json.count } }; + const line = root.querySelector("[data-mod-rating]"); + if (line) line.innerHTML = `${starsHtml(ratingOf(ratings, id))} · `; + } else { + message = json.error || `The service answered ${r.status}.`; + } + } catch { + message = "The service didn't answer. Try again in a minute."; + } + showRate(p, message); +} + +if (id) { + root.addEventListener("click", (e) => { + const star = e.target.closest?.("[data-stars]"); + if (star) rate(Number(star.dataset.stars)); + }); + signIn(); +} else { root.querySelectorAll("[data-kind-filter]").forEach((b) => b.addEventListener("click", () => { kind = b.dataset.kindFilter; @@ -48,8 +112,15 @@ if (!id) { text = e.target.value; showList(); }); - const wanted = new URLSearchParams(location.search).get("kind"); - if (KINDS.some(([k]) => k === wanted)) kind = wanted; + root.querySelector("#mod-sort")?.addEventListener("change", (e) => { + order = e.target.value; + showList(); + }); + const query = new URLSearchParams(location.search); + if (KINDS.some(([k]) => k === query.get("kind"))) kind = query.get("kind"); + if (SORTS.some(([k]) => k === query.get("sort"))) order = query.get("sort"); + const select = root.querySelector("#mod-sort"); + if (select) select.value = order; } setUpTheme(); @@ -64,3 +135,12 @@ cached("horizon:mod-index", () => fetch(INDEX_URL).then((r) => (r.ok ? r.json() } }) .catch(() => {}); +fetch(RATINGS) + .then((r) => (r.ok ? r.json() : Promise.reject(new Error(`${r.status}`)))) + .then((json) => { + if (json && typeof json.projects === "object") { + ratings = json.projects; + render(); + } + }) + .catch(() => {}); diff --git a/website/src/mods.js b/website/src/mods.js index 414db7396..28c31b9fe 100644 --- a/website/src/mods.js +++ b/website/src/mods.js @@ -8,6 +8,8 @@ const REGISTRY = "https://github.com/ludovic111/horizon-mods"; export const SUBMIT = "/mods/submit"; // The submission form's service (crates/horizon-mod-registry), behind the site's own address. export const API = "/api/mods"; +// Every project's ratings: {projects: {: {average, count}}}. +export const RATINGS = `${API}/ratings`; export const SCHEMA = 1; // The kinds the site shows, in the filter's order. Kinds a newer index adds are left out until the site knows them. @@ -43,21 +45,66 @@ const initial = (p) => escape((p.name || p.id).trim().charAt(0).toUpperCase()); const icon = (p) => https(p.icon) ? `` : ``; +// A count as the launcher writes it: 999, 12.3k, 4.1M. +export function count(n) { + if (n < 1000) return String(n); + if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`; + return `${(n / 1e6).toFixed(1)}M`; +} + +const downloads = (p) => { + const n = Number.isSafeInteger(p.downloads) && p.downloads > 0 ? p.downloads : 0; + return `${count(n)} download${n === 1 ? "" : "s"}`; +}; + +// A project's ratings from the service's answer, or null when it has none. +export function ratingOf(ratings, id) { + const r = ratings?.[id]; + return r && Number.isFinite(r.average) && Number.isSafeInteger(r.count) && r.count > 0 ? r : null; +} + +// Five stars, the mean's nearest whole number of them filled, and the mean and count beside. +export function starsHtml(r) { + if (!r) return `No ratings yet`; + const on = Math.min(5, Math.max(0, Math.round(r.average))); + const mean = r.average.toFixed(1); + return `Rated ${mean} out of 5 ${mean} (${count(r.count)})`; +} + +// The list's orders: the most downloaded first (the default), the best rated, or by name. +export const SORTS = [ + ["downloads", "Most downloaded"], + ["rating", "Best rated"], + ["name", "Name"], +]; + +export function sorted(projects, by, ratings) { + const avg = (p) => ratingOf(ratings, p.id)?.average || 0; + const votes = (p) => ratingOf(ratings, p.id)?.count || 0; + const name = (a, b) => a.name.localeCompare(b.name); + const order = { + downloads: (a, b) => (b.downloads || 0) - (a.downloads || 0) || name(a, b), + rating: (a, b) => avg(b) - avg(a) || votes(b) - votes(a) || name(a, b), + name, + }[by] || (() => 0); + return [...projects].sort(order); +} + export function matches(p, kind, text) { if (kind !== "all" && p.kind !== kind) return false; const hay = `${p.id} ${p.name} ${p.summary} ${(p.authors || []).join(" ")}`.toLowerCase(); return text.toLowerCase().split(/\s+/).filter(Boolean).every((w) => hay.includes(w)); } -// The list: a row per project, newest version and kind on the right. -export function listHtml(projects) { +// The list: a row per project; its kind, ratings (once `ratings` is known), downloads and newest version on the right. +export function listHtml(projects, ratings = null) { if (!projects.length) return `

Nothing here yet. Submit yours.

`; return projects .map( (p) => ` ${icon(p)} ${escape(p.name)}${escape(p.summary || "")} - ${escape(KIND_NAMES[p.kind] || p.kind)}${escape(p.versions[0].version)} · ${escape((p.authors || []).join(", "))} + ${escape(KIND_NAMES[p.kind] || p.kind)}${ratings ? `${starsHtml(ratingOf(ratings, p.id))} · ` : ""}${downloads(p)}${escape(p.versions[0].version)} · ${escape((p.authors || []).join(", "))} `, ) .join("\n"); @@ -92,8 +139,19 @@ export function ownersHtml(p) { return `

Published by ${links}

`; } -// One project's page. -export function projectHtml(p) { +// The rating control under a project's ratings: five stars to press when signed in (`mine`, the account's own +// rating, pressed), a sign-in link when not, a note for the project's owners. +export function rateHtml(p, me, mine) { + if (!me) return `Sign in with GitHub to rate`; + if ((p.owners || []).some((o) => o.toLowerCase() === String(me.login).toLowerCase())) return `

You publish it: players rate it.

`; + const stars = [1, 2, 3, 4, 5] + .map((n) => ``) + .join(""); + return `${mine ? "Your rating" : "Rate it"}${stars}`; +} + +// One project's page; `rating` is its ratings (null: none yet), left out when they aren't known. +export function projectHtml(p, rating) { const v = p.versions[0]; const caps = v.capabilities || []; const capsHtml = caps.length @@ -108,7 +166,9 @@ export function projectHtml(p) { return `
${icon(p)}

${escape(KIND_NAMES[p.kind] || p.kind)}${escape((p.authors || []).join(", "))}

${ownersHtml(p)}

${escape(p.name)}

${escape(p.summary || "")}

-

${trust(p)} ${escape(p.license)} ${escape(v.version)}${v.side ? ` ${escape(v.side)}` : ""}

+

${trust(p)} ${escape(p.license)} ${escape(v.version)}${v.side ? ` ${escape(v.side)}` : ""}

+

${rating === undefined ? "" : `${starsHtml(rating)} · `}${downloads(p)}

+
${p.description ? `
${markdown(p.description)}
` : ""} ${p.kind === "mod" ? `

What it may do

${capsHtml}

Mods run in a sandbox with no file, network or clock access. The game refuses a mod whose code uses more than this list.

` : ""} ${requires} diff --git a/website/src/mods.test.mjs b/website/src/mods.test.mjs index c5ff2e783..d94cc3e07 100644 --- a/website/src/mods.test.mjs +++ b/website/src/mods.test.mjs @@ -1,6 +1,6 @@ import { test } from "node:test"; import assert from "node:assert/strict"; -import { CAPABILITIES, entryFrom, listHtml, matches, projectHtml, readIndex, submitHtml } from "./mods.js"; +import { CAPABILITIES, count, entryFrom, listHtml, matches, projectHtml, rateHtml, ratingOf, readIndex, sorted, starsHtml, submitHtml } from "./mods.js"; const project = (over = {}) => ({ id: "coords_hud", kind: "mod", name: "Coordinates HUD", summary: "Where you are.", authors: ["Horizon"], @@ -61,3 +61,50 @@ test("a project's page links its owners' GitHub profiles, and only valid logins" for (const bad of ["bad login", "github.com/-x", "a--b", "