From 3287a74d64e64ac8b3aa976276987b9b4b93f83f Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 13:00:40 +0100 Subject: [PATCH 001/105] Send fence knots to server players so leads tied to fences are drawn --- crates/horizon-client/src/game.rs | 8 ++++++ crates/horizon-client/src/game/lan.rs | 4 +-- .../horizon-client/src/game/lan_entities.rs | 28 +++++++++++++++++++ crates/horizon-client/src/game/remote.rs | 10 +++++-- .../horizon-client/src/game/remote_objects.rs | 16 +++++++++-- 5 files changed, 60 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index cdbd72d7b..0134dd9a1 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1459,6 +1459,12 @@ struct Game<'a> { /// Map textures waiting for the next HUD batch to upload them. map_patches: Vec, text_displays: std::collections::HashMap, + /// The fence knots a server tracks to this client, by entity id, at their + /// block (`LeashFenceKnotEntity`). + remote_knots: HashMap, + /// The entity ids a hosted server gives the knots its mobs hang on, by + /// block, while a lead is tied there. + knot_ids: HashMap<[i32; 3], u32>, text_display_vertices: usize, /// Player skin downloads, and which skin each atlas skin slot holds /// (least recently shown first). @@ -12291,6 +12297,8 @@ impl<'a> Game<'a> { dragon_model: prepared.dragon_model, map_patches: Vec::new(), text_displays: Default::default(), + remote_knots: Default::default(), + knot_ids: Default::default(), text_display_vertices: 0, skin_downloads: RefCell::new(horizon_client::skins::Downloader::new( std::env::current_dir() diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 50fa222e6..c698e969e 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -819,7 +819,7 @@ impl Game<'_> { out.clear(); for m in self.mobs.iter().filter(|m| !m.removed) { // The lead's holder: the player the mob sees (a guest, else the - // host) or another mob. A fence knot isn't an entity here. + // host), another mob or a fence knot (game/lan_entities.rs). let leash = m.extra.leash.and_then(|h| match h { Holder::Player => mob_players .get(&m.id) @@ -827,7 +827,7 @@ impl Game<'_> { .map(|g| g.entity_id) .or(host_entity), Holder::Mob(id) => Some(id as i32), - Holder::Knot(_) => None, + Holder::Knot(p) => self.knot_ids.get(&p).map(|&id| id as i32), }); let e = out.add(m.id as i32, entity_uuid(m.id), m.kind.id.as_str()); e.position = [m.position.x, m.position.y, m.position.z]; diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index cd4ba2fb8..e161b9a2b 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -225,6 +225,16 @@ impl Game<'_> { } out.push(e); } + for (p, &id) in &self.knot_ids { + // LeashFenceKnotEntity.getAddEntityPacket: the fence's block. + out.push(state( + id, + "minecraft:leash_knot", + p.map(f64::from), + 0.0, + false, + )); + } for p in &self.paintings { let mut e = state(p.id, "minecraft:painting", p.pos.map(f64::from), 0.0, false); // Direction.get2DDataValue (south 0, west 1, north 2, east 3) to its @@ -260,6 +270,24 @@ impl Game<'_> { /// Gives the entities Horizon keeps without an id one (`Entity.id`, from /// the same counter as the rest) before they are first tracked. pub(super) fn lan_assign_ids(&mut self) { + // LeashFenceKnotEntity: one per fence post with a lead on it + // (`notifyLeasheeRemoved` discards it once the last lead is gone). + let knots: Vec<[i32; 3]> = self + .mobs + .iter() + .filter(|m| !m.removed) + .filter_map(|m| match m.extra.leash { + Some(horizon_client::mobs::leash::Holder::Knot(p)) => Some(p), + _ => None, + }) + .collect(); + self.knot_ids.retain(|p, _| knots.contains(p)); + for p in knots { + self.knot_ids.entry(p).or_insert_with(|| { + self.next_entity += 1; + self.next_entity + }); + } let next = &mut self.next_entity; let mut give = |id: &mut u32| { if *id == 0 { diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5651647b7..849d6dfab 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -1808,7 +1808,8 @@ impl Game<'_> { } C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers), // ClientPacketListener.handleEntityLinkPacket: who holds a mob's - // lead (this player, another player or a mob), for the rope. + // lead (this player, another player, a mob or a fence knot), for + // the rope. C::SetEntityLink(p) => { let me = self.remote.as_ref().map(|r| r.entity_id); if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.source as u32) { @@ -1816,7 +1817,12 @@ impl Game<'_> { m.extra.leash = match p.dest { 0 => None, d if Some(d) == me => Some(Holder::Player), - d => Some(Holder::Mob(d as u32)), + d => match self.remote_knots.get(&(d as u32)) { + Some(&block) => Some(Holder::Knot(block)), + // Not a known knot yet: kept by id until the knot + // arrives (game/remote_objects.rs). + None => Some(Holder::Mob(d as u32)), + }, }; } } diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs index 251d277f3..3f39072e9 100644 --- a/crates/horizon-client/src/game/remote_objects.rs +++ b/crates/horizon-client/src/game/remote_objects.rs @@ -1,9 +1,10 @@ -//! Boats, minecarts, armor stands, item frames and paintings on a server's +//! Boats, minecarts, armor stands, item frames, paintings and fence knots on a server's //! client (`ClientPacketListener.handleAddEntity`, `handleSetEntityData`, //! `handleSetEquipment`): the server simulates them, the client places them //! where it says and interpolates their moves like a mob's. use super::Game; use horizon_client::entities::{ArmorStand, ItemFrame, Painting}; +use horizon_client::mobs::leash::Holder; use horizon_core::geometry::Vec3; use horizon_protocol::entity_data::Value; use std::sync::Arc; @@ -24,7 +25,17 @@ impl Game<'_> { let at = Vec3::new(position[0], position[1], position[2]); let block = position.map(|v| v.floor() as i32); self.remove_remote_object(id); - if kind == "minecraft:text_display" { + if kind == "minecraft:leash_knot" { + // A lead that came before its knot waits as a mob holder with the + // knot's id (handleEntityLinkPacket's delayed holder); now it can + // be tied to the fence. + self.remote_knots.insert(id, block); + for m in &mut self.mobs { + if m.extra.leash == Some(Holder::Mob(id)) { + m.extra.leash = Some(Holder::Knot(block)); + } + } + } else if kind == "minecraft:text_display" { self.text_displays.insert( id as i32, super::text_displays::RemoteTextDisplay::new(position, yaw), @@ -292,6 +303,7 @@ impl Game<'_> { pub(super) fn remove_remote_object(&mut self, id: u32) { self.text_displays.remove(&(id as i32)); + self.remote_knots.remove(&id); self.carts.retain(|c| c.id != id); self.boats.retain(|b| b.id != id); self.armor_stands.retain(|a| a.id != id); From 2e91bd84e9ee9f0ddbca7bd9e53bdc7edd9ca0f7 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 13:05:47 +0100 Subject: [PATCH 002/105] Send villager, taming, love, spawn poof and snowball entity events to server clients Single player on the server thread drew these particles only into the server's own engine. The server now sends the entity event byte where vanilla does (20, 12/13/14, 6/7, 18 and 3), and the client draws it in handleEntityEvent's way. --- crates/horizon-client/src/game/allays.rs | 2 +- crates/horizon-client/src/game/creatures.rs | 47 ++++++++++--------- crates/horizon-client/src/game/lan.rs | 10 ++++ crates/horizon-client/src/game/llamas.rs | 6 +++ crates/horizon-client/src/game/mounts.rs | 21 ++++++--- crates/horizon-client/src/game/nautili.rs | 9 ++-- crates/horizon-client/src/game/remote.rs | 31 ++++++++++++ crates/horizon-client/src/game/spawner.rs | 11 ++++- crates/horizon-client/src/game/villagers.rs | 35 ++++++++++---- crates/horizon-client/src/mobs.rs | 5 +- .../horizon-client/src/mobs/villager_brain.rs | 15 ++++-- 11 files changed, 145 insertions(+), 47 deletions(-) diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs index bed835663..a1d2ba1df 100644 --- a/crates/horizon-client/src/game/allays.rs +++ b/crates/horizon-client/src/game/allays.rs @@ -160,7 +160,7 @@ impl Game<'_> { } // Allay.duplicateAllay: entity event 18, three spawnHeartParticle. let id = self.mobs[index].id; - self.particles_around_mob(id, "heart", horizon_client::particles::Burst::ALLAY); + self.mob_event_particles(id, 18); self.audio .play("minecraft:block.amethyst_block.chime", Some(at), 2.0, 1.0); self.consume_held(); diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 3a8562ee1..0d7b1f1bc 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1105,12 +1105,17 @@ impl Game<'_> { } } MobEvent::AroundSelf { + mob, + event, kind, feet, width, height, burst, - } => self.particles_around(kind, feet, [width, height], burst), + } => { + self.lan_entity_event(mob as i32, event, feet); + self.particles_around(kind, feet, [width, height], burst) + } MobEvent::ParticleAt { kind, at, velocity } => { if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) { let options = horizon_client::particles::ParticleOptions::simple(ty); @@ -1302,6 +1307,8 @@ impl Game<'_> { q.extra.in_love = 0; } let q = self.mobs.iter().find(|m| m.id == partner).cloned(); + // Animal.finalizeSpawnChildFromBreeding: entity event 18 for the parent. + self.mob_event_particles(parent, 18); // Sniffer.spawnChildFromBreeding: an egg instead of a baby. if p.species() == Species::Sniffer { self.lay_sniffer_egg(&p); @@ -2148,6 +2155,7 @@ impl Game<'_> { }; m.damage(amount, source); } + self.thrown_break_event(p.id, atp); self.item_burst(atp, "minecraft:snowball"); } (ProjectileKind::Egg, hit) => { @@ -2173,6 +2181,7 @@ impl Game<'_> { } } } + self.thrown_break_event(p.id, atp); self.item_burst(atp, "minecraft:egg"); } (ProjectileKind::EnderPearl, hit) => { @@ -2402,10 +2411,17 @@ impl Game<'_> { } Ok(()) } + /// `Snowball`/`ThrownEgg.onHit`: entity event 3 for the guests, before the + /// projectile is discarded (the clients lose it when the tracker next runs). + fn thrown_break_event(&mut self, id: u32, at: [f64; 3]) { + if id != 0 { + self.lan_entity_event(id as i32, 3, at); + } + } /// `Snowball`/`ThrownEgg.handleEntityEvent(3)`: eight crumbs of the /// thrown item where it broke, at rest for a snowball, scattered by the /// client entity's random (the particle engine's here) for an egg. - fn item_burst(&mut self, at: [f64; 3], item: &str) { + pub(super) fn item_burst(&mut self, at: [f64; 3], item: &str) { let options = self.item_particle(&horizon_client::items::ItemStack::new(item, 1)); let egg = item != "minecraft:snowball"; for _ in 0..8 { @@ -2662,14 +2678,8 @@ impl Game<'_> { m.ai.target = None; m.extra.sitting = true; } - // TamableAnimal.spawnTamingParticles. - let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). - self.particles_around_mob( - self.mobs[index].id, - kind, - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); if tamed { let view = self.mob_entity(&self.mobs[index]); self.trigger_entity("minecraft:tame_animal", "entity", &view); @@ -2736,13 +2746,8 @@ impl Game<'_> { m.extra.sitting = true; } eat = eating_sound(m, &mut self.world.random); - let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). - self.particles_around_mob( - self.mobs[index].id, - kind, - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); if tamed { let view = self.mob_entity(&self.mobs[index]); self.trigger_entity("minecraft:tame_animal", "entity", &view); @@ -2779,13 +2784,8 @@ impl Game<'_> { m.extra.tame = true; m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1])); } - let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). - self.particles_around_mob( - self.mobs[index].id, - kind, - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); if tamed { let view = self.mob_entity(&self.mobs[index]); self.trigger_entity("minecraft:tame_animal", "entity", &view); @@ -2803,6 +2803,11 @@ impl Game<'_> { Some(sound) => { consume = true; eat = sound; + // Animal.setInLove: entity event 18 (a baby that + // only grew is not in love). + if self.mobs[index].extra.in_love > 0 { + self.mob_event_particles(self.mobs[index].id, 18); + } } // Animal.mobInteract still consumes the client click when // an adult cannot breed, without swinging or taking food. diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 50fa222e6..0f946161f 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -913,6 +913,16 @@ impl Game<'_> { m.needs_sync = false; } let entities = states.as_slice(); + // An entity that left the level since the last tick (a snowball + // that hit) is dropped by the tracker below: its event goes out + // first, as `Level.broadcastEntityEvent` precedes the discard. + let (gone, later): (Vec<_>, Vec<_>) = std::mem::take(&mut self.lan_entity_events) + .into_iter() + .partition(|(id, ..)| !entities.iter().any(|e| e.id == *id)); + self.lan_entity_events = later; + for (id, event, at) in gone { + host.hub.entity_event(id, event, at); + } let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]); let events = { let clock_rate = self.network_clock_rate(); diff --git a/crates/horizon-client/src/game/llamas.rs b/crates/horizon-client/src/game/llamas.rs index 1ce518f31..080343952 100644 --- a/crates/horizon-client/src/game/llamas.rs +++ b/crates/horizon-client/src/game/llamas.rs @@ -25,11 +25,13 @@ impl Game<'_> { }; let m = &mut self.mobs[index]; let mut used = false; + let mut loved = false; if item == "minecraft:hay_block" && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0 { m.extra.in_love = 600; m.extra.love_player = true; used = true; + loved = true; } if m.health < m.attrs.max_health { m.health = (m.health + heal).min(m.attrs.max_health); @@ -57,6 +59,10 @@ impl Game<'_> { if !used { return false; } + // Animal.setInLove: entity event 18. + if loved { + self.mob_event_particles(self.mobs[index].id, 18); + } self.llama_sound(index, "entity.llama.eat", 1.0); self.consume_held(); true diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs index fa4bbc209..60c6d143c 100644 --- a/crates/horizon-client/src/game/mounts.rs +++ b/crates/horizon-client/src/game/mounts.rs @@ -215,10 +215,12 @@ impl Game<'_> { return false; } let mut used = false; + let mut loved = false; if love && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0 { m.extra.in_love = 600; m.extra.love_player = true; used = true; + loved = true; } if m.health < m.attrs.max_health && heal > 0.0 { m.health = (m.health + heal).min(m.attrs.max_health); @@ -238,6 +240,7 @@ impl Game<'_> { // eating(): the mouth opens and the horse eats. m.anim.v[2] = 1.0; let at = m.center(); + let id = m.id; let sound = match m.species() { Species::Camel => "minecraft:entity.camel.eat", Species::CamelHusk => "minecraft:entity.camel_husk.eat", @@ -247,6 +250,10 @@ impl Game<'_> { }; let pitch = (self.world.random.next_float() - self.world.random.next_float()) * 0.2 + 1.0; self.audio.play(sound, Some(at), 1.0, pitch); + // Animal.setInLove: entity event 18. + if loved { + self.mob_event_particles(id, 18); + } self.consume_held(); true } @@ -452,14 +459,16 @@ impl Game<'_> { m.extra.owner = owner; m.persistent = true; // AbstractHorse.tameWithName: entity event 7, spawnTamingParticles(true). - self.particles_around_mob( - mob, - "heart", - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(mob, 7); } } - MobEvent::Buck { mob } if self.riding == Some(mob) => self.dismount_mount(), + MobEvent::Buck { mob } => { + if self.riding == Some(mob) { + self.dismount_mount(); + } + // RunAroundLikeCrazyGoal.tick: entity event 6, smoke. + self.mob_event_particles(mob, 6); + } _ => {} } } diff --git a/crates/horizon-client/src/game/nautili.rs b/crates/horizon-client/src/game/nautili.rs index e7f16ca18..5e384db98 100644 --- a/crates/horizon-client/src/game/nautili.rs +++ b/crates/horizon-client/src/game/nautili.rs @@ -85,13 +85,8 @@ impl Game<'_> { m.ai.target = None; } let sound = nautilus::eat_sound(m); - let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). - self.particles_around_mob( - self.mobs[index].id, - kind, - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); self.nautilus_sound(index, sound); if tamed { let view = self.mob_entity(&self.mobs[index]); @@ -145,6 +140,8 @@ impl Game<'_> { let sound = nautilus::eat_sound(m); self.use_nautilus_food(item); self.nautilus_sound(index, sound); + // Animal.setInLove: entity event 18. + self.mob_event_particles(self.mobs[index].id, 18); return true; } false diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5651647b7..2fe1a3344 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2072,6 +2072,37 @@ impl Game<'_> { if p.event == super::totem::TOTEM_EVENT { self.remote_totem(p.id); } + // Mob.handleEntityEvent 20: the spawn poof. + if p.event == 20 && self.mobs.iter().any(|m| m.id == p.id as u32) { + self.poof_particles(p.id as u32); + } + // Villager 12, 13 and 14, TamableAnimal and AbstractHorse 6 and + // 7, Animal and Allay 18: the particles about the mob. + if matches!(p.event, 6 | 7 | 12 | 13 | 14 | 18) { + self.entity_event_particles(p.id as u32, p.event); + } + // Snowball and ThrownEgg.handleEntityEvent 3: the crumbs where + // the projectile is (the server removes it right after). + if p.event == 3 { + let crumbs = self + .creatures + .projectiles + .iter() + .find(|pr| pr.id == p.id as u32) + .and_then(|pr| { + let item = match pr.kind { + horizon_client::projectiles::ProjectileKind::Snowball => { + "minecraft:snowball" + } + horizon_client::projectiles::ProjectileKind::Egg => "minecraft:egg", + _ => return None, + }; + Some(([pr.position.x, pr.position.y, pr.position.z], item)) + }); + if let Some((at, item)) = crumbs { + self.item_burst(at, item); + } + } } C::Animate(p) => self.remote_animate(p.id, p.action), // ClientPacketListener.handleSwingAnimation: the entity swings diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs index 538cb39e7..f2835446f 100644 --- a/crates/horizon-client/src/game/spawner.rs +++ b/crates/horizon-client/src/game/spawner.rs @@ -257,8 +257,17 @@ impl Game<'_> { let Some(m) = self.mobs.iter().find(|m| m.id == id) else { return; }; - let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height())); + let at = m.position; self.lan_entity_event(id as i32, 20, [at.x, at.y, at.z]); + self.poof_particles(id); + } + /// `Mob.handleEntityEvent` 20 (`spawnAnim` on a client): the poof about + /// mob `id`. + pub(super) fn poof_particles(&mut self, id: u32) { + let Some(m) = self.mobs.iter().find(|m| m.id == id) else { + return; + }; + let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height())); let options = ParticleOptions::simple(ParticleType::Poof); for _ in 0..20 { let r = self.particles.level_random(); diff --git a/crates/horizon-client/src/game/villagers.rs b/crates/horizon-client/src/game/villagers.rs index 3cfe8aa1d..092faaadf 100644 --- a/crates/horizon-client/src/game/villagers.rs +++ b/crates/horizon-client/src/game/villagers.rs @@ -116,7 +116,7 @@ impl Game<'_> { // VillagerMakeLove: entity event 13 for the partner, then the parent. for i in [ib, ia] { let id = self.mobs[i].id; - self.villager_particles(id, "angry_villager"); + self.mob_event_particles(id, 13); } return; }; @@ -141,12 +141,31 @@ impl Game<'_> { child.extra.bed = Some(bed); } // VillagerMakeLove.giveBirth: entity event 12 for the child. - self.villager_particles(id, "heart"); + self.mob_event_particles(id, 12); } - /// `Villager.handleEntityEvent` 12, 13, 14 and 42: - /// `AbstractVillager.addParticlesAroundSelf`. - pub(super) fn villager_particles(&mut self, id: u32, kind: &'static str) { - self.particles_around_mob(id, kind, horizon_client::particles::Burst::VILLAGER); + /// `Level.broadcastEntityEvent` of an event whose `handleEntityEvent` + /// draws particles about the mob (villager 12, 13 and 14, taming 6 and 7, + /// love 18): the guests get the byte, and this game draws it as its own + /// client would. + pub(super) fn mob_event_particles(&mut self, id: u32, event: i8) { + let Some(m) = self.mobs.iter().find(|m| m.id == id) else { + return; + }; + let at = [m.position.x, m.position.y, m.position.z]; + self.lan_entity_event(id as i32, event, at); + self.entity_event_particles(id, event); + } + /// `handleEntityEvent(event)`'s particles about mob `id` + /// (`Villager`, `TamableAnimal`, `AbstractHorse`, `Animal`, `Allay`). + pub(super) fn entity_event_particles(&mut self, id: u32, event: i8) { + let Some(m) = self.mobs.iter().find(|m| m.id == id) else { + return; + }; + if let Some((kind, burst)) = + horizon_client::particles::entity_event_burst(&m.kind.id, event as u8) + { + self.particles_around_mob(id, kind, burst); + } } /// `particles::around_self` about mob `id`. pub(super) fn particles_around_mob( @@ -283,7 +302,7 @@ impl Game<'_> { } // Villager.setLastHurtByMob: entity event 13. for id in angry { - self.villager_particles(id, "angry_villager"); + self.mob_event_particles(id, 13); } } /// `Villager.tellWitnessesThatIWasMurdered`: the villagers that saw a @@ -338,7 +357,7 @@ impl Game<'_> { gossip::REPUTATION_CHANGE_PER_TRADE, ); // Villager.customServerAiStep after a trade: entity event 14. - self.villager_particles(id, "happy_villager"); + self.mob_event_particles(id, 14); } /// `Villager.getPlayerReputation` of the local player. pub(super) fn villager_reputation(&self, id: u32) -> i32 { diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 1b5dddbe7..e8fa6eb91 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1011,8 +1011,11 @@ pub enum MobEvent { at: [f64; 3], count: u32, }, - /// Client particles about a mob's box (`particles::around_self`). + /// Client particles about a mob's box (`particles::around_self`) and the + /// entity event `event` that shows them, sent for mob `mob`. AroundSelf { + mob: u32, + event: i8, kind: &'static str, feet: [f64; 3], width: f64, diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs index 7b311a9e0..339318a06 100644 --- a/crates/horizon-client/src/mobs/villager_brain.rs +++ b/crates/horizon-client/src/mobs/villager_brain.rs @@ -2905,11 +2905,18 @@ impl B { let mut bodies = Vec::new(); if let Some(t) = cx.w.target_info(target) { let (min, max) = (t.bounds.min_position(), t.bounds.max_position()); - bodies.push((t.position, max.x - min.x, max.y - min.y)); + bodies.push((partner, t.position, max.x - min.x, max.y - min.y)); } - bodies.push((m.position, f64::from(m.width()), f64::from(m.height()))); - for (feet, width, height) in bodies { + bodies.push(( + m.id, + m.position, + f64::from(m.width()), + f64::from(m.height()), + )); + for (mob, feet, width, height) in bodies { cx.events.push(MobEvent::AroundSelf { + mob, + event: 12, kind: "heart", feet: [feet.x, feet.y, feet.z], width, @@ -3580,6 +3587,8 @@ fn pois_scan_order(_m: &Mob, found: &[(Poi, [i32; 3])]) -> Vec { /// `AbstractVillager.addParticlesAroundSelf(HAPPY_VILLAGER)` on the client. fn happy_particles(m: &Mob, cx: &mut Bx) { cx.events.push(MobEvent::AroundSelf { + mob: m.id, + event: 14, kind: "happy_villager", feet: [m.position.x, m.position.y, m.position.z], width: f64::from(m.width()), From 4825e537ccc51d123bcc0f97d777e3330a570f52 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 13:05:51 +0100 Subject: [PATCH 003/105] Tilt a server player's camera towards the hit The server never sent ClientboundHurtAnimationPacket, and the client ignored the yaw it carried, so a player on a server got the flash but the camera never tilted towards where the hit came from. ServerPlayer.indicateDamage now runs where the hit's knockback is dealt (and with no direction for hits that have none), the packet goes out when the guest's turn ends, and the client keeps the yaw as Player.hurtDir for GameRenderer.bobHurt. --- crates/horizon-client/src/game/creatures.rs | 4 +++ crates/horizon-client/src/game/fov.rs | 2 +- crates/horizon-client/src/game/lan_actions.rs | 7 +++++ crates/horizon-client/src/game/remote.rs | 3 ++- crates/horizon-client/src/health.rs | 27 +++++++++++++++++++ 5 files changed, 41 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 3a8562ee1..2f80be926 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1528,6 +1528,10 @@ impl Game<'_> { // hurt cooldown (a stronger hit there only adds its difference). if o.knockback { let (xd, zd) = (from[0] - player.position.x, from[2] - player.position.z); + // dealDefaultKnockback's `indicateDamage`, unless blocked. + if o.blocked <= 0.0 { + player.health.indicate_damage(xd, zd, player.yaw); + } self.knock_back_player(f64::from(0.4_f32), xd, zd); if let Some(p) = self.player.as_mut() && let Some(r) = p.hurt_log.last_mut() diff --git a/crates/horizon-client/src/game/fov.rs b/crates/horizon-client/src/game/fov.rs index 95e2e1e6e..364f89189 100644 --- a/crates/horizon-client/src/game/fov.rs +++ b/crates/horizon-client/src/game/fov.rs @@ -114,7 +114,7 @@ impl Game<'_> { living: Some(HurtBob { hurt_time: p.health.hurt_animation_time as f32 - partial, hurt_duration: hurt.hurt_duration, - hurt_dir: 0.0, + hurt_dir: p.health.hurt_dir, death_time: self.death_time().map(|t| t as f32 + partial), }), player: Some(( diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index bbb0c37c0..e6869650b 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -650,6 +650,13 @@ impl Game<'_> { g.sprinting = false; } m.sprinting = false; + // ServerPlayer.indicateDamage: the hit's direction to the player. + if let Some(yaw) = m.health.indicated_dir.take() { + g.send(&C::HurtAnimation(play::HurtAnimation { + id: g.entity_id, + yaw, + })); + } let teleported = std::mem::take(&mut m.teleported); let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum(); g.motion = Some(Box::new(m)); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5651647b7..c4571c3a9 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2042,8 +2042,9 @@ impl Game<'_> { } C::HurtAnimation(p) => { if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) { + // Player.animateHurt: the tilt turns around the yaw. if let Some(pl) = self.player.as_mut() { - pl.health.animate_hurt(); + pl.health.animate_hurt_dir(p.yaw); } } else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { m.hurt_time = 10; diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs index 25c719bfb..b9670d065 100644 --- a/crates/horizon-client/src/health.rs +++ b/crates/horizon-client/src/health.rs @@ -163,6 +163,12 @@ pub struct PlayerHealth { pub hurt: State, /// Client hurt animation; fully blocked hits only refresh the server's hurt state. pub hurt_animation_time: i32, + /// `Player.hurtDir` on a client: the yaw `ClientboundHurtAnimationPacket` + /// gave, which `GameRenderer.bobHurt` tilts the camera around. + pub hurt_dir: f32, + /// `ServerPlayer.hurtDir` of a hit the player's client hasn't been told + /// of yet (`indicateDamage`). + pub indicated_dir: Option, pub dead: bool, pub sync_velocity: bool, pub game_time: i64, @@ -213,6 +219,8 @@ impl PlayerHealth { last_stamp: 0, }, hurt_animation_time: 0, + hurt_dir: 0.0, + indicated_dir: None, dead: false, sync_velocity: false, game_time: 0, @@ -260,6 +268,18 @@ impl PlayerHealth { self.hurt.hurt_time = 10; self.hurt_animation_time = 10; } + /// `LivingEntity.animateHurt(yaw)` on a player: the tilt restarts around + /// `yaw` (`Player.animateHurt` keeps it as `hurtDir`). + pub fn animate_hurt_dir(&mut self, yaw: f32) { + self.animate_hurt(); + self.hurt_dir = yaw; + } + /// `ServerPlayer.indicateDamage`: the hit's direction relative to where + /// the player looks, kept for the packet to its client. + pub fn indicate_damage(&mut self, xd: f64, zd: f64, yaw: f32) { + use horizon_core::geometry::trig::{RAD_TO_DEG, atan2}; + self.indicated_dir = Some((atan2(zd, xd) * f64::from(RAD_TO_DEG) - f64::from(yaw)) as f32); + } /// `LocalPlayer.hurtTo` with `flashOnSetHealth`: a drop below the current /// health starts the hurt animation; `damageCooldownTime` (20 on a drop, /// 10 on a gain) is what lets `Hud.extractPlayerHealth` blink the hearts. @@ -348,6 +368,13 @@ impl PlayerMotion { if outcome.hurt { h.hurt_animation_time = h.hurt.hurt_time; } + // `dealDefaultKnockback` ends in `indicateDamage` unless blocked: a + // hit with no direction of its own (`xd` and `zd` zero) is sent as + // the opposite of the player's yaw. A hit that has a direction + // replaces this (`mob_hits_player`). + if outcome.knockback && outcome.blocked <= 0.0 { + h.indicate_damage(0.0, 0.0, self.yaw); + } let after = h.health() + h.absorption(); if self.hurt_log.len() >= HURT_LOG { self.hurt_log.remove(0); From 2f6f0e3e0f22c91d1cf7205563e2574d75d6f570 Mon Sep 17 00:00:00 2001 From: Joansitoh Date: Mon, 26 Oct 2026 13:16:35 +0100 Subject: [PATCH 004/105] Launcher: Game arguments edits at the caret The field only appended and popped the last character, and Space typed nothing on Windows (it arrives without a character). A shared one-line field, launcher/src/line_edit.rs, now holds the text, caret, selection and undo history: arrows, Home/End, Ctrl+arrows by word, Shift to select, mouse click, drag, double and triple click, Ctrl+A/C/X/V and Ctrl+Z / Ctrl+Y. --- launcher/src/line_edit.rs | 672 ++++++++++++++++++++++++++++++++++++++ launcher/src/main.rs | 53 ++- 2 files changed, 692 insertions(+), 33 deletions(-) create mode 100644 launcher/src/line_edit.rs diff --git a/launcher/src/line_edit.rs b/launcher/src/line_edit.rs new file mode 100644 index 000000000..0647f5861 --- /dev/null +++ b/launcher/src/line_edit.rs @@ -0,0 +1,672 @@ +//! The one-line text field every launcher input shares: the state (text, caret, selection, +//! undo), the keyboard (`handle`) and what it draws (`content`). A page keeps its own box and +//! its Enter/Escape; this is what is inside it. Positions count characters, not bytes. + +use super::*; +use gpui::{ + black, canvas, Bounds, Font, MouseButton, MouseDownEvent, MouseMoveEvent, Pixels, Point, + TextRun, +}; +use std::{cell::RefCell, rc::Rc}; + +/// What a key did to the field. +#[derive(Debug, PartialEq)] +pub(super) enum Key { + Enter, + Escape, + /// Not the field's: Tab (focus), shortcuts. + Pass, + /// The caret or the selection moved; the text is the same. + Moved, + /// The text changed. + Edited, + /// Ctrl/Cmd-V: `handle` inserts the clipboard's first line. + Paste, + /// Ctrl/Cmd-C: `handle` puts this on the clipboard. + Copy(String), + /// Ctrl/Cmd-X: the text changed; `handle` puts this on the clipboard. + Cut(String), +} + +/// What the last edit was, so a run of typing undoes as one step. +#[derive(Clone, Copy, PartialEq)] +enum Run { + None, + Typing, + Deleting, + Other, +} + +/// Where the text was drawn last frame, and how: what turns a mouse position into a character. +struct Area { + bounds: Bounds, + font: Font, + size: Pixels, + mask: bool, +} + +struct Snap { + text: String, + caret: usize, +} + +pub(super) struct LineEdit { + text: String, + caret: usize, + /// The other end of the selection; equal to `caret` when nothing is selected. + anchor: usize, + scroll: usize, + max: usize, + /// How many characters the box shows. + visible: usize, + undo: Vec, + redo: Vec, + run: Run, + area: Rc>>, + /// A drag that started in this field is on. + dragging: bool, +} + +const HISTORY: usize = 100; + +impl LineEdit { + pub(super) fn new(text: String, max: usize, visible: usize) -> Self { + let caret = text.chars().count(); + let mut e = LineEdit { + text, + caret, + anchor: caret, + scroll: 0, + max, + visible, + undo: Vec::new(), + redo: Vec::new(), + run: Run::None, + area: Rc::default(), + dragging: false, + }; + e.reveal(); + e + } + + pub(super) fn text(&self) -> &str { + &self.text + } + + pub(super) fn select_all(&mut self) { + self.anchor = 0; + self.caret = self.len(); + } + + /// The character under `pos`, from where the text was drawn last frame. + fn index_at(&self, window: &Window, pos: Point) -> Option { + let area = self.area.borrow(); + let a = area.as_ref()?; + let shown: String = self + .text + .chars() + .skip(self.scroll) + .take(self.visible) + .collect(); + let shown = if a.mask { + "•".repeat(shown.chars().count()) + } else { + shown + }; + let run = TextRun { + len: shown.len(), + font: a.font.clone(), + color: black(), + background_color: None, + underline: None, + strikethrough: None, + }; + let line = window + .text_system() + .shape_line(shown.clone().into(), a.size, &[run], None); + let at = line + .closest_index_for_x(pos.x - a.bounds.origin.x) + .min(shown.len()); + Some(self.scroll + shown[..at].chars().count()) + } + + fn select_word(&mut self, at: usize) { + self.anchor = self.word(at, false); + self.caret = self.word(at, true).max(self.anchor); + self.run = Run::None; + } + + fn len(&self) -> usize { + self.text.chars().count() + } + + fn byte(&self, at: usize) -> usize { + self.text + .char_indices() + .nth(at) + .map_or(self.text.len(), |(i, _)| i) + } + + fn range(&self) -> (usize, usize) { + (self.caret.min(self.anchor), self.caret.max(self.anchor)) + } + + fn selected(&self) -> String { + let (lo, hi) = self.range(); + self.text.chars().skip(lo).take(hi - lo).collect() + } + + fn snap(&self) -> Snap { + Snap { + text: self.text.clone(), + caret: self.caret, + } + } + + /// Runs an edit and remembers the text it replaced for undo, unless it changed nothing + /// (typing a "t" over a selected "t") or continues a run. A run of typing is one step per + /// word: `split` starts a new one. + fn edit(&mut self, run: Run, split: bool, f: impl FnOnce(&mut Self)) { + let prev = self.snap(); + let prev_run = self.run; + f(self); + if self.text == prev.text { + self.run = prev_run; + return; + } + if run == Run::Other || run != prev_run || split { + if self.undo.len() == HISTORY { + self.undo.remove(0); + } + self.undo.push(prev); + } + self.redo.clear(); + self.run = run; + } + + fn restore(&mut self, s: Snap) { + self.text = s.text; + self.caret = s.caret; + self.anchor = s.caret; + self.run = Run::None; + } + + fn undo(&mut self) { + if let Some(s) = self.undo.pop() { + self.redo.push(self.snap()); + self.restore(s); + } + } + + fn redo(&mut self) { + if let Some(s) = self.redo.pop() { + self.undo.push(self.snap()); + self.restore(s); + } + } + + fn delete_selection(&mut self) -> bool { + let (lo, hi) = self.range(); + if lo == hi { + return false; + } + self.text.replace_range(self.byte(lo)..self.byte(hi), ""); + self.caret = lo; + self.anchor = lo; + true + } + + fn put(&mut self, s: &str) { + self.delete_selection(); + let room = self.max.saturating_sub(self.len()); + let s: String = s.chars().filter(|c| !c.is_control()).take(room).collect(); + self.text.insert_str(self.byte(self.caret), &s); + self.caret += s.chars().count(); + self.anchor = self.caret; + } + + /// Replaces the selection with `s` (control characters dropped), up to the length limit. + pub(super) fn insert(&mut self, s: &str) { + self.edit(Run::Other, false, |e| e.put(s)); + self.reveal(); + } + + fn move_to(&mut self, at: usize, extend: bool) { + self.caret = at.min(self.len()); + if !extend { + self.anchor = self.caret; + } + self.run = Run::None; + } + + /// The start of the word before `from`, or the end of the one after it. + fn word(&self, from: usize, forward: bool) -> usize { + let chars: Vec = self.text.chars().collect(); + let mut i = from; + if forward { + while i < chars.len() && chars[i].is_whitespace() { + i += 1; + } + while i < chars.len() && !chars[i].is_whitespace() { + i += 1; + } + } else { + while i > 0 && chars[i - 1].is_whitespace() { + i -= 1; + } + while i > 0 && !chars[i - 1].is_whitespace() { + i -= 1; + } + } + i + } + + /// Applies a key press. `command` is Ctrl, or Cmd on macOS. + pub(super) fn key( + &mut self, + key: &str, + key_char: Option<&str>, + command: bool, + shift: bool, + ) -> Key { + let (lo, hi) = self.range(); + let out = match key { + "enter" => Key::Enter, + "escape" => Key::Escape, + "left" if !shift && lo != hi && !command => { + self.move_to(lo, false); + Key::Moved + } + "right" if !shift && lo != hi && !command => { + self.move_to(hi, false); + Key::Moved + } + "left" => { + let to = if command { + self.word(self.caret, false) + } else { + self.caret.saturating_sub(1) + }; + self.move_to(to, shift); + Key::Moved + } + "right" => { + let to = if command { + self.word(self.caret, true) + } else { + self.caret + 1 + }; + self.move_to(to, shift); + Key::Moved + } + "home" => { + self.move_to(0, shift); + Key::Moved + } + "end" => { + self.move_to(self.len(), shift); + Key::Moved + } + "backspace" | "delete" => { + let run = if lo == hi { Run::Deleting } else { Run::Other }; + self.edit(run, false, |e| { + if !e.delete_selection() { + let (from, to) = match (key, command) { + ("backspace", false) => (e.caret.saturating_sub(1), e.caret), + ("backspace", true) => (e.word(e.caret, false), e.caret), + (_, false) => (e.caret, (e.caret + 1).min(e.len())), + (_, true) => (e.caret, e.word(e.caret, true)), + }; + e.anchor = from; + e.caret = to; + e.delete_selection(); + } + }); + Key::Edited + } + "a" if command => { + self.select_all(); + self.run = Run::None; + Key::Moved + } + "z" if command && shift => { + self.redo(); + Key::Edited + } + "z" if command => { + self.undo(); + Key::Edited + } + "y" if command => { + self.redo(); + Key::Edited + } + "c" if command => Key::Copy(self.selected()), + "x" if command => { + let cut = self.selected(); + self.edit(Run::Other, false, |e| { + e.delete_selection(); + }); + Key::Cut(cut) + } + "v" if command => Key::Paste, + _ if command => Key::Pass, + // Not every platform gives Space a character. + "space" => { + let run = if lo == hi { Run::Typing } else { Run::Other }; + self.edit(run, false, |e| e.put(" ")); + Key::Edited + } + _ => match key_char { + Some(ch) if !ch.is_empty() && !ch.chars().any(char::is_control) => { + let starts_word = !ch.starts_with(char::is_whitespace) + && self + .text + .chars() + .nth(self.caret.wrapping_sub(1)) + .is_some_and(char::is_whitespace); + let run = if lo == hi { Run::Typing } else { Run::Other }; + self.edit(run, starts_word, |e| e.put(ch)); + Key::Edited + } + _ => Key::Pass, + }, + }; + self.reveal(); + out + } + + /// Scrolls the field so the caret shows. + fn reveal(&mut self) { + if self.caret < self.scroll { + self.scroll = self.caret; + } else if self.caret > self.scroll + self.visible { + self.scroll = self.caret - self.visible; + } + } + + /// What shows: the text before the selection, the selection, the text after, and whether the + /// caret sits before the selection (otherwise after it). `whole` shows all of it selected. + fn view(&self, whole: bool) -> (String, String, String, bool) { + let (lo, hi) = if whole { (0, self.len()) } else { self.range() }; + let end = self.scroll + self.visible; + let part = |a: usize, b: usize| -> String { + let (a, b) = (a.max(self.scroll), b.min(end)); + self.text + .chars() + .skip(a) + .take(b.saturating_sub(a)) + .collect() + }; + ( + part(0, lo), + part(lo, hi), + part(hi, usize::MAX), + self.caret == lo, + ) + } +} + +/// The keyboard in a field: moves the caret, edits, copies and pastes. Never returns Paste, Copy +/// or Cut (they are done); Enter, Escape and Pass are the page's. +pub(super) fn handle(edit: &mut LineEdit, ev: &KeyDownEvent, cx: &mut App) -> Key { + let k = &ev.keystroke; + let command = k.modifiers.control || k.modifiers.platform; + match edit.key(&k.key, k.key_char.as_deref(), command, k.modifiers.shift) { + Key::Paste => { + if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) { + edit.insert(text.lines().next().unwrap_or_default().trim()); + } + Key::Edited + } + Key::Copy(s) => { + cx.write_to_clipboard(gpui::ClipboardItem::new_string(s)); + Key::Moved + } + Key::Cut(s) => { + cx.write_to_clipboard(gpui::ClipboardItem::new_string(s)); + Key::Edited + } + other => other, + } +} + +/// Puts mouse handling on a field's box: a click puts the caret in (Shift extends the selection), +/// a drag selects, a double click selects a word and a triple click the line. +pub(super) fn mouse( + el: E, + cx: &mut Context, + edit: impl Fn(&mut T) -> &mut LineEdit + Clone + 'static, +) -> E { + let get = edit.clone(); + el.on_mouse_down( + MouseButton::Left, + cx.listener(move |this, ev: &MouseDownEvent, window, cx| { + let e = get(this); + if let Some(at) = e.index_at(window, ev.position) { + match ev.click_count { + 1 => e.move_to(at, ev.modifiers.shift), + 2 => e.select_word(at), + _ => e.select_all(), + } + e.dragging = true; + cx.notify(); + } + }), + ) + .on_mouse_move(cx.listener(move |this, ev: &MouseMoveEvent, window, cx| { + let e = edit(this); + if !ev.dragging() { + e.dragging = false; + } else if e.dragging { + if let Some(at) = e.index_at(window, ev.position) { + e.move_to(at, true); + cx.notify(); + } + } + })) +} + +/// What a field draws inside its box: the placeholder while empty and unfocused, else the text +/// with its selection and caret. `mask` shows dots (a token); `whole` shows all selected. +pub(super) fn content( + edit: &LineEdit, + t: &theme::Theme, + focused: bool, + whole: bool, + mask: bool, + placeholder: &'static str, +) -> Div { + if edit.text.is_empty() && !focused { + return div().text_color(t.muted).child(placeholder); + } + let (before, selected, after, caret_first) = edit.view(whole); + let text = |s: String| { + let s = if mask { + "•".repeat(s.chars().count()) + } else { + s + }; + div().flex_none().whitespace_nowrap().child(s) + }; + let caret = || div().flex_none().w(px(1.)).h(px(14.)).bg(t.ink); + let area = edit.area.clone(); + div() + .relative() + .flex() + .items_center() + .text_color(t.ink) + .child(text(before)) + .when(focused && caret_first, |d| d.child(caret())) + .when(!selected.is_empty(), |d| { + d.child( + text(selected) + .rounded(px(2.)) + .bg(t.accent.opacity(theme::SELECTION)), + ) + }) + .when(focused && !caret_first, |d| d.child(caret())) + .child(text(after)) + .child( + // Records where the text sits and in what font, for the mouse. + canvas( + move |bounds, window, _| { + let style = window.text_style(); + *area.borrow_mut() = Some(Area { + bounds, + font: style.font(), + size: style.font_size.to_pixels(window.rem_size()), + mask, + }); + }, + |_, _, _, _| {}, + ) + .absolute() + .size_full(), + ) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn edit(text: &str) -> LineEdit { + LineEdit::new(text.into(), 1024, 38) + } + + fn typed(e: &mut LineEdit, s: &str) { + for c in s.chars() { + let key = if c == ' ' { "space" } else { "x" }; + let ch = c.to_string(); + e.key(key, (c != ' ').then_some(ch.as_str()), false, false); + } + } + + #[test] + fn spaces_type_and_the_caret_moves_and_edits_in_the_middle() { + let mut e = edit(""); + typed(&mut e, "--name Steve"); + assert_eq!(e.text(), "--name Steve"); + for _ in 0..5 { + e.key("left", None, false, false); + } + typed(&mut e, "X"); + assert_eq!(e.text(), "--name XSteve"); + e.key("backspace", None, false, false); + e.key("delete", None, false, false); + assert_eq!(e.text(), "--name teve"); + e.key("home", None, false, false); + e.key("delete", None, false, false); + assert_eq!(e.text(), "-name teve"); + } + + #[test] + fn undo_steps_back_a_run_at_a_time_and_redo_returns() { + let mut e = edit(""); + typed(&mut e, "--name Steve"); + e.key("home", None, false, false); + e.key("delete", None, false, false); + e.key("delete", None, false, false); + assert_eq!(e.text(), "name Steve"); + e.key("z", None, true, false); + assert_eq!(e.text(), "--name Steve"); + // Typing undoes a word at a time. + e.key("z", None, true, false); + assert_eq!(e.text(), "--name "); + e.key("z", None, true, false); + assert_eq!(e.text(), ""); + e.key("z", None, true, false); + assert_eq!(e.text(), ""); + e.key("y", None, true, false); + assert_eq!(e.text(), "--name "); + e.key("y", None, true, false); + assert_eq!(e.text(), "--name Steve"); + e.key("z", None, true, false); + e.key("z", None, true, true); + assert_eq!(e.text(), "--name Steve"); + // A paste is a step of its own, and typing after an undo drops the redo. + e.key("end", None, false, false); + e.insert("!"); + e.key("z", None, true, false); + assert_eq!(e.text(), "--name Steve"); + typed(&mut e, "?"); + e.key("y", None, true, false); + assert_eq!(e.text(), "--name Steve?"); + } + + #[test] + fn selection_is_replaced_copied_and_cut() { + let mut e = edit("--name Steve"); + e.key("a", None, true, false); + assert_eq!( + e.key("c", None, true, false), + Key::Copy("--name Steve".into()) + ); + e.key("home", None, false, false); + for _ in 0..2 { + e.key("right", None, false, true); + } + assert_eq!(e.key("x", None, true, false), Key::Cut("--".into())); + assert_eq!(e.text(), "name Steve"); + e.key("a", None, true, false); + e.key("y", Some("y"), false, false); + assert_eq!(e.text(), "y"); + e.insert("a\nb c"); + assert_eq!(e.text(), "yab c"); + } + + #[test] + fn words_and_the_length_limit() { + let mut e = edit("one two three"); + e.key("backspace", None, true, false); + assert_eq!(e.text(), "one two "); + e.key("left", None, true, false); + e.key("delete", None, true, false); + assert_eq!(e.text(), "one "); + let mut e = LineEdit::new("abc".into(), 4, 38); + e.insert("defg"); + assert_eq!(e.text(), "abcd"); + assert_eq!(e.key("tab", None, false, false), Key::Pass); + assert_eq!(e.key("q", None, true, false), Key::Pass); + assert_eq!(e.key("enter", Some("\n"), false, false), Key::Enter); + assert_eq!(e.key("escape", None, false, false), Key::Escape); + } + + #[test] + fn an_edit_that_changes_nothing_is_not_an_undo_step() { + let mut e = edit("test"); + e.key("left", None, false, false); + e.key("end", None, false, false); + e.key("left", None, false, true); + e.key("t", Some("t"), false, false); + assert_eq!(e.text(), "test"); + e.key("delete", None, false, false); + e.key("home", None, false, false); + e.key("backspace", None, false, false); + e.key("z", None, true, false); + assert_eq!(e.text(), "test"); + e.insert(""); + e.key("x", Some("x"), false, false); + assert_eq!(e.text(), "xtest"); + e.key("z", None, true, false); + assert_eq!(e.text(), "test"); + } + + #[test] + fn a_selected_text_is_replaced_by_what_is_typed() { + let mut e = edit("My server"); + e.select_all(); + e.key("f", Some("F"), false, false); + assert_eq!(e.text(), "F"); + } + + #[test] + fn the_view_follows_the_caret() { + let mut e = edit(&"é".repeat(100)); + let (before, sel, after, _) = e.view(false); + assert_eq!((before.chars().count(), sel.len(), after.len()), (38, 0, 0)); + e.key("home", None, false, false); + assert_eq!(e.view(false).2.chars().count(), 38); + assert_eq!(e.view(true).1.chars().count(), 38); + } +} diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 7d778b6b9..0632a51ca 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -13,6 +13,7 @@ mod console; mod cull; mod game_tools; mod internet; +mod line_edit; mod markdown; mod mcp; mod modpacks_page; @@ -183,7 +184,7 @@ struct Launcher { friend_focus: FocusHandle, joining: Option, /// Settings' Game arguments field: the line, whether it has focus, and its focus handle. - args_input: String, + args_input: line_edit::LineEdit, args_focused: bool, args_focus: FocusHandle, /// Opt-in data collection: the player's answer and Settings' section (`collection`). @@ -298,7 +299,7 @@ impl Launcher { install_error: None, confirm_remove: None, picker_open: false, - args_input: settings.game_args.clone(), + args_input: line_edit::LineEdit::new(settings.game_args.clone(), 1024, 38), args_focused: false, args_focus: cx.focus_handle(), settings, @@ -2615,46 +2616,32 @@ impl Launcher { .font_family(theme::MONO) .text_size(px(12.)) .cursor_text() - .child(if self.args_input.is_empty() && !focused { - div() - .text_color(t.muted) - .child("For example --server-thread") - } else { - // The end of a long line stays in view while typing. - let chars: Vec = self.args_input.chars().collect(); - let shown: String = chars[chars.len().saturating_sub(44)..].iter().collect(); - div().text_color(t.ink).child(shown) - }) - .when(focused, |d| d.child(div().w(px(1.)).h(px(14.)).bg(t.ink))) + .child(line_edit::content( + &self.args_input, + &t, + focused, + false, + false, + "For example --server-thread", + )) .on_click(cx.listener(|this, _: &ClickEvent, window, cx| { window.focus(&this.args_focus); cx.notify(); })) - .on_key_down(cx.listener(|this, ev: &KeyDownEvent, _, cx| { - let k = &ev.keystroke; - let paste = k.key == "v" && (k.modifiers.control || k.modifiers.platform); - match k.key.as_str() { - "backspace" => { - this.args_input.pop(); + .on_key_down(cx.listener(|this, ev: &KeyDownEvent, window, cx| { + match line_edit::handle(&mut this.args_input, ev, cx) { + line_edit::Key::Pass => return, + line_edit::Key::Escape => window.blur(), + line_edit::Key::Edited => { + this.settings.game_args = this.args_input.text().to_string(); + this.settings.save(); } - _ if paste => { - if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) { - this.args_input.push_str(text.trim()); - } - } - _ if !k.modifiers.control && !k.modifiers.platform => { - if let Some(ch) = &k.key_char { - this.args_input.push_str(ch); - } - } - _ => return, + _ => {} } - this.args_input.truncate(1024); - this.settings.game_args = this.args_input.clone(); - this.settings.save(); cx.stop_propagation(); cx.notify(); })); + let field = line_edit::mouse(field, cx, |this| &mut this.args_input); index_row( n, "Game arguments", From 7cc8def23f1d74efbd6b5dfa096b40e540a10c4c Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:10:57 +0100 Subject: [PATCH 005/105] Let a lit TNT minecart explode when it hits a wall --- crates/horizon-client/src/game/minecarts.rs | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index a19b6df73..ceff3f127 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -539,7 +539,6 @@ impl Game<'_> { // applyGravity c.velocity.y -= if self.cart_in_water(c) { 0.005 } else { 0.04 }; let pos = self.rail_block(c.position); - let fall_speed = c.velocity; if let Some(rail) = self.rail(pos[0], pos[1], pos[2]) { self.move_along_track(c, pos, &rail, intent); if &*rail.name == "minecraft:activator_rail" { @@ -581,15 +580,15 @@ impl Game<'_> { } } CartKind::Tnt => { - let speed = fall_speed.x * fall_speed.x + fall_speed.z * fall_speed.z; + // MinecartTNT.tick: the fuse and the collision check are separate. if c.fuse > 0 { c.fuse -= 1; let at = [c.position.x, c.position.y + 0.5, c.position.z]; self.particles .add(&ParticleOptions::simple(ParticleType::Smoke), at, [0.0; 3]); - } else if c.fuse == 0 || (c.horizontal_collision && speed >= 0.01) { + } else if c.fuse == 0 { let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z; - let speed = if c.fuse == 0 && c.velocity.y > 0.0 { + let speed = if c.velocity.y > 0.0 { c.velocity.y * c.velocity.y } else { speed @@ -597,6 +596,13 @@ impl Game<'_> { self.explode_cart(c, speed); return false; } + if c.horizontal_collision { + let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z; + if speed >= f64::from(0.01_f32) { + self.explode_cart(c, speed); + return false; + } + } } _ => {} } From cc39d57e070d73b84080e031157704f2295529ce Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:12:42 +0100 Subject: [PATCH 006/105] Explosions empty and anger the bees of destroyed hives --- crates/horizon-client/src/game/beehives.rs | 2 +- crates/horizon-client/src/game/combat.rs | 4 +++ crates/horizon-client/src/game/creatures.rs | 10 ++++++- crates/horizon-client/src/game/explosion.rs | 29 +++++++++++++++++++++ crates/horizon-client/src/game/minecarts.rs | 4 ++- crates/horizon-client/src/game/tnt.rs | 4 ++- crates/horizon-client/src/game/wither.rs | 2 +- 7 files changed, 50 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs index b7f7efb1a..258610f5e 100644 --- a/crates/horizon-client/src/game/beehives.rs +++ b/crates/horizon-client/src/game/beehives.rs @@ -196,7 +196,7 @@ impl Game<'_> { } /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down) /// without a target go for a player in the same box. - fn anger_nearby_bees(&mut self, at: [i32; 3]) { + pub(super) fn anger_nearby_bees(&mut self, at: [i32; 3]) { let min = Vec3::new( f64::from(at[0]) - 8.0, f64::from(at[1]) - 6.0, diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index 106e0e1a1..91cf5c61b 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -31,6 +31,10 @@ pub(super) struct CombatTracker { /// The mob exploding now (`ServerExplosion.source`): its team's friendly /// fire decides whom the blast may hurt. pub(super) explosion_source: Option, + /// The blast now going off comes from a primed TNT, creeper, wither + /// skull, wither or TNT minecart, the sources that empty a hive they + /// destroy (`BeehiveBlock.getDrops`). + pub(super) hive_emptying_blast: bool, /// The player's fall distance before this tick's movement (as of the /// end of the last one). fall_before: f64, diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 194256040..6e6610dcc 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -915,7 +915,15 @@ impl Game<'_> { self.note_attacker("minecraft:explosion", id); } self.combat.explosion_source = source_mob; - let result = self.explode(at, radius); + // Only a creeper or a wither empties the hives it blows up. + let empties_hives = source_mob + .and_then(|id| self.mobs.iter().find(|m| m.id == id)) + .is_some_and(|m| matches!(m.species(), Species::Creeper | Species::Wither)); + let result = if empties_hives { + self.with_hive_emptying_blast(|g| g.explode(at, radius)) + } else { + self.explode(at, radius) + }; self.combat.explosion_source = None; result? } diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs index 6ecba3a54..805e4ebff 100644 --- a/crates/horizon-client/src/game/explosion.rs +++ b/crates/horizon-client/src/game/explosion.rs @@ -489,6 +489,15 @@ impl Game<'_> { ); } } + /// Runs an explosion whose source empties the hives it destroys + /// (`BeehiveBlock.getDrops`: primed TNT, creeper, wither skull, wither, + /// TNT minecart). + pub(super) fn with_hive_emptying_blast(&mut self, blast: impl FnOnce(&mut Self) -> R) -> R { + self.combat.hive_emptying_blast = true; + let result = blast(self); + self.combat.hive_emptying_blast = false; + result + } /// `Level.explode` on the server: positions, entities, blocks, fire; then /// the client's explosion sound. pub(super) fn server_explode( @@ -600,6 +609,22 @@ impl Game<'_> { // Block.onExplosionHit: the drops copy from the block entity, which // then spills its contents as the block turns to air. let key = (pos[0], pos[1], pos[2]); + let is_hive = matches!(&*name, "minecraft:beehive" | "minecraft:bee_nest"); + // BeehiveBlock.getDrops: the bees of a hive blown up by TNT, a + // creeper, a wither skull, a wither or a TNT minecart come out. + if is_hive && self.combat.hive_emptying_blast { + let facing = self + .pack + .assets + .registry + .state(state) + .and_then(|s| s.properties.get("facing").cloned()); + self.empty_hive( + pos, + horizon_client::beehive::facing_step(facing.as_deref()), + horizon_client::beehive::Release::Emergency, + ); + } if let Some(entity) = self.world.block_entities.get(&key).cloned() { let custom = self.world.block_names.get(&key).cloned(); self.pending.record(pos, &entity, &name, custom); @@ -631,6 +656,10 @@ impl Game<'_> { } self.pending.clear(pos); self.level_set(pos, self.world.air)?; + // BeehiveBlock.onExplosionHit: the bees about turn on the player. + if is_hive { + self.anger_nearby_bees(pos); + } // TntBlock.wasExploded: new PrimedTnt (its push drawn first), then // getRandomShortFuse(80); no game event. if is_tnt && self.ui.rules.bool("tnt_explodes") { diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index a19b6df73..d21c99a55 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -640,7 +640,9 @@ impl Game<'_> { // The cart is the explosion's source: it is gone before the blast // looks for entities, so it can't hit itself. self.carts.retain(|x| x.id != c.id); - let _ = self.server_explode(at, power, BlockInteraction::Destroy, false); + let _ = self.with_hive_emptying_blast(|g| { + g.server_explode(at, power, BlockInteraction::Destroy, false) + }); } /// `MinecartHopper.suckInItems`: items above, into the five slots. fn hopper_cart_pickup(&mut self, c: &mut Minecart) { diff --git a/crates/horizon-client/src/game/tnt.rs b/crates/horizon-client/src/game/tnt.rs index 6bd2ae956..14d80c90e 100644 --- a/crates/horizon-client/src/game/tnt.rs +++ b/crates/horizon-client/src/game/tnt.rs @@ -178,7 +178,9 @@ impl Game<'_> { ]; self.tnts.remove(i); count -= 1; - self.server_explode(center, 4.0, BlockInteraction::Destroy, false)?; + self.with_hive_emptying_blast(|g| { + g.server_explode(center, 4.0, BlockInteraction::Destroy, false) + })?; } else { i += 1; } diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs index 8084425ca..789e5cf68 100644 --- a/crates/horizon-client/src/game/wither.rs +++ b/crates/horizon-client/src/game/wither.rs @@ -130,7 +130,7 @@ impl Game<'_> { if let Some(id) = owner { self.note_attacker("minecraft:explosion", id); } - self.explode(at, 1.0) + self.with_hive_emptying_blast(|g| g.explode(at, 1.0)) } } /// Wither skulls drawn as the skull model, blue when dangerous. From 2a0824cf5f532d1671e71b878dd03673be6ec0a2 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:13:15 +0100 Subject: [PATCH 007/105] Invisible players are harder for mobs to notice Mobs now scale their detection range by 0.7 times the worn armor fraction (at least 0.1) when the player has Invisibility, like vanilla's getVisibilityPercent. --- .../horizon-client/examples/probe/mob_ai_probe.rs | 1 + crates/horizon-client/src/game/creatures.rs | 1 + crates/horizon-client/src/game/lan_mobs.rs | 1 + crates/horizon-client/src/mobs.rs | 15 +++++++++++++++ crates/horizon-client/src/mobs/animal_brain.rs | 3 +-- crates/horizon-client/src/mobs/goals.rs | 5 +---- crates/horizon-client/src/mobs/happy_ghast.rs | 3 +-- 7 files changed, 21 insertions(+), 8 deletions(-) diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index ecdf02901..033ef6faa 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -1050,6 +1050,7 @@ pub fn main() -> horizon_client::Result<()> { off_hand: None, head: None, armor_cover: 0.0, + invisible: false, spectator: false, gold_armor: false, hurt_by: None, diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 194256040..ae31d23dd 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -186,6 +186,7 @@ impl Game<'_> { off_hand: None, head: self.armor[0].as_ref().map(|s| s.item.clone()), armor_cover: self.armor.iter().filter(|a| a.is_some()).count() as f32 / 4.0, + invisible: self.potions.effects.get("invisibility").is_some(), spectator: self.spectator(), gold_armor: self.wearing_gold(), hurt_by: self.player_hurt_by(), diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index 4f53cec60..88632c7aa 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -363,6 +363,7 @@ mod tests { off_hand: None, head: None, armor_cover: 0.0, + invisible: false, spectator: false, gold_armor: false, hurt_by: None, diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 1b5dddbe7..ba9d63080 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1448,6 +1448,8 @@ pub struct PlayerView { pub off_hand: Option>, pub head: Option>, pub armor_cover: f32, + /// The Invisibility effect (`isInvisible`). + pub invisible: bool, pub spectator: bool, /// `PiglinAi.isWearingSafeArmor`: some golden armour. pub gold_armor: bool, @@ -1468,6 +1470,19 @@ pub struct PlayerView { /// (`EntitySelector.pushableBy` on the client). pub remote: bool, } +impl PlayerView { + /// `LivingEntity.getVisibilityPercent` without the worn-skull scaling. + pub fn visibility_percent(&self) -> f64 { + let mut visibility = 1.0; + if self.sneaking { + visibility *= 0.8; + } + if self.invisible { + visibility *= 0.7 * f64::from(self.armor_cover).max(0.1); + } + visibility + } +} #[derive(Clone)] pub struct MobWorld<'a> { pub world: &'a World, diff --git a/crates/horizon-client/src/mobs/animal_brain.rs b/crates/horizon-client/src/mobs/animal_brain.rs index bd0eb9c90..d928c34ee 100644 --- a/crates/horizon-client/src/mobs/animal_brain.rs +++ b/crates/horizon-client/src/mobs/animal_brain.rs @@ -625,8 +625,7 @@ fn targetable(m: &mut Mob, w: &MobWorld, who: Who) -> bool { // TargetingConditions.forNonCombat(): in range (scaled by the // player's visibility, at least 2) and in sight. let Some(p) = &w.player else { return false }; - let visibility = if p.sneaking { 0.8 } else { 1.0 }; - let r = (range * visibility).max(2.0); + let r = (range * p.visibility_percent()).max(2.0); p.alive && !p.spectator && m.distance_sqr(p.position) <= r * r && m.sees(w, who) } Who::Mob(id) => { diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs index 7f73e32c4..c44614571 100644 --- a/crates/horizon-client/src/mobs/goals.rs +++ b/crates/horizon-client/src/mobs/goals.rs @@ -601,10 +601,7 @@ impl Mob { return false; } // LivingEntity.getVisibilityPercent - let mut visibility = 1.0; - if p.sneaking { - visibility *= 0.8; - } + let mut visibility = p.visibility_percent(); if let Some(head) = &p.head { let skull = match self.species() { Species::Zombie | Species::Husk | Species::Drowned | Species::ZombieVillager => { diff --git a/crates/horizon-client/src/mobs/happy_ghast.rs b/crates/horizon-client/src/mobs/happy_ghast.rs index bd4c5b1f3..efcbf5246 100644 --- a/crates/horizon-client/src/mobs/happy_ghast.rs +++ b/crates/horizon-client/src/mobs/happy_ghast.rs @@ -364,8 +364,7 @@ impl Goal for GhastTempt { let Some(p) = &cx.w.player else { return false }; // getNearestPlayer(TargetingConditions.forNonCombat() // .ignoreLineOfSight().range(TEMPT_RANGE 16)): creative players too. - let visibility = if p.sneaking { 0.8 } else { 1.0 }; - let range = (16.0_f64 * visibility).max(2.0); + let range = (16.0_f64 * p.visibility_percent()).max(2.0); p.alive && !p.spectator && (Self::wants(m, &p.main_hand) || Self::wants(m, &p.off_hand)) From 329ce1b724aa72ee67dc1cfeeaeb884acb541399 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:13:27 +0100 Subject: [PATCH 008/105] Make armadillos shed scutes on their own Armadillos never dropped scutes because nothing ran their shed timer. Follow Armadillo.customServerAiStep: count down 5 to 10 minutes, then drop a scute, play the sound and post the entity_place game event. --- crates/horizon-client/src/game/creatures.rs | 18 +++++++++++++++ crates/horizon-client/src/mobs.rs | 6 +++++ crates/horizon-client/src/mobs/ai.rs | 25 +++++++++++++++++++++ 3 files changed, 49 insertions(+) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 194256040..9a78bc2e5 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1221,6 +1221,24 @@ impl Game<'_> { m.ai.aggressive |= aggressive; } } + MobEvent::ShedScute { mob, at, pitch } => { + // shouldDropLoot: the `mob_drops` rule. + if self.ui.rules.bool("mob_drops") { + let table = "minecraft:gameplay/armadillo_shed"; + let drops = self.sequence_loot(table, table, None); + for d in drops { + self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d); + } + self.audio.play( + "minecraft:entity.armadillo.scute_drop", + Some(at), + 1.0, + pitch, + ); + let ctx = self.who_context(Some(Who::Mob(mob)), None); + self.post_game_event("minecraft:entity_place", at, ctx); + } + } MobEvent::GiftLoot { table, at } => { let drops = self.res diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 1b5dddbe7..315bfdce2 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1131,6 +1131,12 @@ pub enum MobEvent { table: &'static str, at: [f64; 3], }, + /// `Armadillo.customServerAiStep`: the armadillo sheds a scute. + ShedScute { + mob: u32, + at: [f64; 3], + pitch: f32, + }, /// A lead snaps or loses its holder: the lead item drops when asked. LeashBreak { mob: u32, diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 8335cb745..8259ddccb 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -307,6 +307,10 @@ fn generic(m: &mut Mob) { g.add(5, Stroll::avoiding_water(if rabbit { 0.6 } else { 1.0 })); g.add(6, LookAtPlayer::new(6.0)); g.add(7, RandomLookAround::default()); + if m.kind.species == Species::Armadillo { + // Armadillo's constructor: pickNextScuteDropTime. + m.extra.egg_time = next_scute_time(m); + } } } /// Subclasses of `net.minecraft.world.entity.monster.Monster`. @@ -930,9 +934,30 @@ fn server_ai_step( } m.jump_control_tick(); } +/// `Armadillo.pickNextScuteDropTime`: 5 to 10 minutes. +fn next_scute_time(m: &mut Mob) -> i32 { + m.random.next_int_bound(20 * 60 * 5).unwrap_or(0) + 20 * 60 * 5 +} +/// `Armadillo.customServerAiStep`: the scute timer. A baby only resets it +/// (`shouldDropLoot`); the game checks the `mob_drops` rule. +fn armadillo_server_ai_step(m: &mut Mob, events: &mut Vec) { + m.extra.egg_time -= 1; + if m.alive() && m.extra.egg_time <= 0 { + if !m.is_baby() { + let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0; + events.push(MobEvent::ShedScute { + mob: m.id, + at: [m.position.x, m.position.y, m.position.z], + pitch, + }); + } + m.extra.egg_time = next_scute_time(m); + } +} fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { match m.species() { Species::Rabbit => super::rabbit::server_ai_step(m), + Species::Armadillo => armadillo_server_ai_step(m, cx.events), Species::Sheep => {} Species::Zombie | Species::Husk From 183382cd2beead9560f0d6303106b9886dd3307c Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:13:34 +0100 Subject: [PATCH 009/105] Fire the fishing_rod_hooked trigger when a hook is reeled in --- .../horizon-client/src/game/advancements.rs | 29 +++++++++++++++++++ crates/horizon-client/src/game/fishing.rs | 24 +++++++++++++-- 2 files changed, 51 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 0f76d0ca9..082bf0d62 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -708,6 +708,35 @@ impl Game<'_> { let it = item_view(stack); self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w)); } + /// `FishingRodHookedTrigger`: the rod, what the hook is in (or the hook) + /// and the items it caught. + pub(super) fn trigger_fishing_rod_hooked( + &mut self, + rod: &ItemStack, + hooked: &EntityView, + items: &[ItemStack], + ) { + let me = self.player_entity(); + let rod = item_view(rod); + let hooked = hooked.clone(); + let items: Vec = items.iter().map(item_view).collect(); + self.trigger("minecraft:fishing_rod_hooked", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + let ectx = adv::Entities { + this: Some(&hooked), + ..pctx + }; + adv::conditions(&c["player"], &pctx, w) + && adv::item(&c["rod"], &rod, w) + && adv::conditions(&c["entity"], &ectx, w) + && (c["item"].is_null() || items.iter().any(|i| adv::item(&c["item"], i, w))) + }); + } /// `EnterBlockTrigger`: the block, its state properties and the player. pub(super) fn trigger_enter_block(&mut self, state: horizon_world::registry::BlockStateId) { let Some(definition) = self.pack.assets.registry.state(state).cloned() else { diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs index d454df406..33d93fb82 100644 --- a/crates/horizon-client/src/game/fishing.rs +++ b/crates/horizon-client/src/game/fishing.rs @@ -2,6 +2,7 @@ //! bobbing, lure and bite timers, open water, hooking mobs, retrieving the //! `gameplay/fishing` loot) and `FishingHookRenderer` (bobber and line). use super::{Game, view_vector}; +use horizon_client::advancements::EntityView; use horizon_client::lan::{entity::States, hub::Hub}; use horizon_client::{ blocks::Fluid, @@ -77,7 +78,7 @@ impl Game<'_> { let at = [p.position.x, p.position.y, p.position.z]; let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8); if self.hook.is_some() { - let damage = self.retrieve_hook(); + let damage = self.retrieve_hook(stack); self.damage_held(damage); self.audio.play( "minecraft:entity.fishing_bobber.retrieve", @@ -143,7 +144,7 @@ impl Game<'_> { true } /// `FishingHook.retrieve`: the rod damage it costs. - fn retrieve_hook(&mut self) -> u32 { + fn retrieve_hook(&mut self, rod: &ItemStack) -> u32 { let Some(hook) = self.hook.take() else { return 0; }; @@ -166,6 +167,15 @@ impl Game<'_> { m.velocity.z + d.z * 0.1, ); } + // CriteriaTriggers.FISHING_ROD_HOOKED with no items. + let hooked = self + .mobs + .iter() + .find(|m| m.id == id) + .map(|m| self.mob_entity(m)); + if let Some(hooked) = hooked { + self.trigger_fishing_rod_hooked(rod, &hooked, &[]); + } damage = 5; } else if hook.nibble > 0 { let biome = self.biome_name_at(hook.position); @@ -184,6 +194,7 @@ impl Game<'_> { self.world.random = random; // FishingHook.retrieve: fish_caught for a catch. self.stats.custom("fish_caught", 1); + let mut caught = Vec::new(); for stack in items { let mut item = ItemStack { item: Arc::from(stack.item.as_str()), @@ -205,6 +216,7 @@ impl Game<'_> { if let Some(potion) = &stack.potion { item = item.with_potion(potion); } + caught.push(item.clone()); let (dx, dy, dz) = ( owner.x - hook.position.x, owner.y - hook.position.y, @@ -224,6 +236,14 @@ impl Game<'_> { let xp = self.world.random.next_int_bound(6).unwrap_or(0) as u32 + 1; self.spawn_orbs([owner.x, owner.y + 0.5, owner.z + 0.5], xp); } + // CriteriaTriggers.FISHING_ROD_HOOKED: the hook itself is the entity. + let bobber = EntityView { + kind: "minecraft:fishing_bobber".into(), + position: [hook.position.x, hook.position.y, hook.position.z], + on_ground: hook.on_ground, + ..Default::default() + }; + self.trigger_fishing_rod_hooked(rod, &bobber, &caught); damage = 1; } if hook.on_ground { From 5fa423169f8fe5791f4cf31ee5b97e485806e46a Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:13:51 +0100 Subject: [PATCH 010/105] Fire player_hurt_entity and entity_hurt_player advancement triggers --- crates/horizon-client/src/advancements.rs | 46 ++++++++++++ crates/horizon-client/src/game.rs | 9 +++ .../horizon-client/src/game/advancements.rs | 71 +++++++++++++++++++ crates/horizon-client/src/game/creatures.rs | 35 +++++++++ crates/horizon-client/src/game/trident.rs | 13 +++- 5 files changed, 173 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs index 6706532b7..62e7f365f 100644 --- a/crates/horizon-client/src/advancements.rs +++ b/crates/horizon-client/src/advancements.rs @@ -703,6 +703,52 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo } true } +/// A damage event as `DamagePredicate` sees it. +#[derive(Clone, Debug, Default)] +pub struct DamageView { + /// The damage type id (`minecraft:arrow`). + pub kind: String, + /// `DamageSource.getDirectEntity` and `getEntity`. + pub direct: Option, + pub source: Option, + /// `DamageSource.isDirect`: the direct entity is the causing one. + pub is_direct: bool, + /// The damage before and after the shield took its share. + pub original: f32, + pub actual: f32, + pub blocked: bool, +} +/// `DamagePredicate`, with its `DamageSourcePredicate` as `type`. +pub fn damage(v: &Value, d: &DamageView, w: &dyn World, origin: [f64; 3]) -> bool { + if v.is_null() { + return true; + } + let by = |key: &str, e: &Option| { + v[key].is_null() || e.as_ref().is_some_and(|e| entity(&v[key], e, w, origin)) + }; + if !range_f(&v["dealt"], f64::from(d.original)) + || !range_f(&v["taken"], f64::from(d.actual)) + || !by("source_entity", &d.source) + || v["blocked"].as_bool().is_some_and(|b| b != d.blocked) + { + return false; + } + let ty = &v["type"]; + let tags_ok = ty["tags"].as_array().into_iter().flatten().all(|t| { + let tag = t["id"].as_str().unwrap_or(""); + let tag = tag.strip_prefix('#').unwrap_or(tag); + w.in_tag("damage_type", tag, &d.kind) == t["expected"].as_bool().unwrap_or(true) + }); + let direct_ok = ty["direct_entity"].is_null() + || d.direct + .as_ref() + .is_some_and(|e| entity(&ty["direct_entity"], e, w, origin)); + let source_ok = ty["source_entity"].is_null() + || d.source + .as_ref() + .is_some_and(|e| entity(&ty["source_entity"], e, w, origin)); + tags_ok && direct_ok && source_ok && ty["is_direct"].as_bool().is_none_or(|b| b == d.is_direct) +} /// The entities a loot-style condition list may refer to. pub struct Entities<'a> { pub this: Option<&'a EntityView>, diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1d86fe990..44ae588cb 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -7602,6 +7602,15 @@ impl Game<'_> { None => horizon_client::mobs::Damage::of(horizon_client::mobs::DamageKind::Generic), }; let landed = self.hurt_by_player(index, amount, source); + if landed { + let victim = self.mob_entity(&self.mobs[index]); + self.player_hit( + &victim, + creatures::damage_type(source.kind, true), + None, + amount, + ); + } if let Some(p) = self.player.as_mut() { if p.attack_log.len() >= 64 { p.attack_log.remove(0); diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 0f76d0ca9..ab783cbfa 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -180,6 +180,14 @@ impl adv::World for View<'_, '_> { "block" => items.block_tags.get(tag).is_some_and(|t| t.contains(id)), "entity_type" => self.0.res.mob_data().entity_has(tag, id), "worldgen/biome" => self.0.res.mob_data().biome_has(tag, id), + "damage_type" => self + .0 + .res + .stations() + .enchantments + .damage_tags + .get(tag) + .is_some_and(|t| t.contains(id)), _ => false, } } @@ -681,6 +689,69 @@ impl Game<'_> { adv::conditions(&c["player"], &pctx, w) && adv::conditions(&c[&key], &ectx, w) }); } + /// `PlayerHurtEntityTrigger`: the player, the damage and the victim. + pub(super) fn trigger_player_hurt_entity( + &mut self, + victim: &EntityView, + damage: &adv::DamageView, + ) { + let me = self.player_entity(); + let (victim, damage) = (victim.clone(), damage.clone()); + self.trigger("minecraft:player_hurt_entity", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + let vctx = adv::Entities { + this: Some(&victim), + ..pctx + }; + adv::conditions(&c["player"], &pctx, w) + && adv::damage(&c["damage"], &damage, w, me.position) + && adv::conditions(&c["entity"], &vctx, w) + }); + } + /// The player's hit on `victim` as `LivingEntity.hurtServer` reports it: + /// `kind` damage of `amount` from `direct` (the player's own hand when + /// `None`), nothing blocked. + pub(super) fn player_hit( + &mut self, + victim: &EntityView, + kind: &str, + direct: Option, + amount: f32, + ) { + let me = self.player_entity(); + self.trigger_player_hurt_entity( + victim, + &adv::DamageView { + kind: kind.to_owned(), + is_direct: direct.is_none(), + direct: direct.or_else(|| Some(me.clone())), + source: Some(me), + original: amount, + actual: amount, + blocked: false, + }, + ); + } + /// `EntityHurtPlayerTrigger`: the player and the damage it took. + pub(super) fn trigger_entity_hurt_player(&mut self, damage: &adv::DamageView) { + let me = self.player_entity(); + let damage = damage.clone(); + self.trigger("minecraft:entity_hurt_player", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) + && adv::damage(&c["damage"], &damage, w, me.position) + }); + } /// A player condition plus one item (`item` key). pub(super) fn trigger_item(&mut self, name: &str, stack: &ItemStack) { let me = self.player_entity(); diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 194256040..e7395c3f0 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1544,6 +1544,23 @@ impl Game<'_> { self.hurt_armor(amount); self.thorns(from); } + // LivingEntity.hurtServer: ENTITY_HURT_PLAYER, unless it returned + // early (invulnerable, or inside the hurt cooldown). + if outcome.hurt || outcome.sound { + let source = attacker + .or(owner) + .and_then(|id| self.mobs.iter().find(|m| m.id == id)) + .map(|m| self.mob_entity(m)); + self.trigger_entity_hurt_player(&horizon_client::advancements::DamageView { + kind: damage_type.to_owned(), + direct: source.clone().filter(|_| !projectile), + is_direct: !projectile, + source, + original: amount, + actual: amount - outcome.blocked, + blocked: outcome.blocked > 0.0, + }); + } if raised { self.after_block(outcome, amount, attacker, projectile); } @@ -2111,6 +2128,24 @@ impl Game<'_> { .is_some_and(|m| m.damage(amount, source)); if p.owner == Some(Who::Player) { self.last_hurt_by_player.insert(id, self.lan_acting); + if hurt && let Some(m) = self.mobs.iter().find(|m| m.id == id) { + // LivingEntity.hurtServer: PLAYER_HURT_ENTITY. + let victim = self.mob_entity(m); + let spectral = p.arrow.as_ref().is_some_and(|a| { + &*a.pickup_item.item == "minecraft:spectral_arrow" + }); + let direct = horizon_client::advancements::EntityView { + kind: if spectral { + "minecraft:spectral_arrow" + } else { + "minecraft:arrow" + } + .into(), + position: [p.position.x, p.position.y, p.position.z], + ..Default::default() + }; + self.player_hit(&victim, "minecraft:arrow", Some(direct), amount); + } } hurt } diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs index c31094596..04a1be415 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -311,9 +311,10 @@ impl Game<'_> { }); let damage = 8.0 + if aquatic { 2.5 * impaling } else { 0.0 }; t.dealt_damage = true; + let mut hurt = false; if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { let from = Some([t.position.x, t.position.y, t.position.z]); - m.damage( + hurt = m.damage( damage, Damage { kind: DamageKind::Arrow, @@ -322,6 +323,16 @@ impl Game<'_> { }, ); } + if hurt && let Some(m) = self.mobs.iter().find(|m| m.id == id) { + // LivingEntity.hurtServer: PLAYER_HURT_ENTITY. + let victim = self.mob_entity(m); + let direct = horizon_client::advancements::EntityView { + kind: "minecraft:trident".into(), + position: [t.position.x, t.position.y, t.position.z], + ..Default::default() + }; + self.player_hit(&victim, "minecraft:trident", Some(direct), damage); + } self.audio.play( "minecraft:item.trident.hit", Some([t.position.x, t.position.y, t.position.z]), From 8d77913ea524f60ea52c7ac22ccba3092f5d7409 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:14:10 +0100 Subject: [PATCH 011/105] Note blocks play on a left click, and take mob heads on top Mining a note block now plays its note and counts the play_noteblock statistic. A mob head used on the top face is placed instead of tuning the block. --- crates/horizon-client/src/game.rs | 8 +++-- crates/horizon-world/src/level/interact.rs | 35 ++++++++++++++++++---- 2 files changed, 36 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1d86fe990..3548bf15a 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2510,9 +2510,13 @@ impl Game<'_> { self.process_level_events() } fn attack_block(&mut self, pos: [i32; 3]) -> Result<()> { - self.with_level(|b, level, ticks| { - b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2])); + let note = self.with_level(|b, level, ticks| { + b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2])) }); + // NoteBlock.attack awards the statistic. + if note { + self.stats.custom("play_noteblock", 1); + } self.process_level_events() } /// Track which chunks are ticking (Ticks needs chunk load/unload). diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs index 7b2195c34..ed7c03dfb 100644 --- a/crates/horizon-world/src/level/interact.rs +++ b/crates/horizon-world/src/level/interact.rs @@ -513,20 +513,26 @@ impl Behaviours { sim.game_event_state(pos, "minecraft:block_change", next); } - /// The state change of `RedStoneOreBlock.attack` when mining begins. + /// `BlockBehaviour.attack` when mining begins: `RedStoneOreBlock.attack` + /// lights the ore, `NoteBlock.attack` plays the note. True for a note + /// block, whose player also earns the `play_noteblock` statistic. pub fn attack_block( &self, level: &mut L, ticks: &mut Ticks, pos: BlockPos, - ) { + ) -> bool { let mut sim = self.sim(level, ticks); let state = sim.state(pos); - if self.data(state).chain.contains(&Class::RedStoneOre) - && !self.table.bool(state, self.props.lit) - { + let chain = &self.data(state).chain; + if chain.contains(&Class::Note) { + sim.note_play(pos, state); + return true; + } + if chain.contains(&Class::RedStoneOre) && !self.table.bool(state, self.props.lit) { sim.set_block_and_update(pos, self.table.set_bool(state, self.props.lit, true)); } + false } /// `BlockState.useWithoutItem` for a right-click on `pos` (hit face and @@ -595,6 +601,25 @@ impl Behaviours { if self.data(state).chain.contains(&Class::CopperGolemStatue) { return self.turn_statue(level, ticks, pos, state, item); } + // NoteBlock.useItemOn: a mob head on the top face is placed, not tuned + // (`#minecraft:noteblock_top_instruments`). + if face == Direction::Up + && self.data(state).chain.contains(&Class::Note) + && item.is_some_and(|i| { + matches!( + i, + "minecraft:zombie_head" + | "minecraft:skeleton_skull" + | "minecraft:creeper_head" + | "minecraft:dragon_head" + | "minecraft:wither_skeleton_skull" + | "minecraft:piglin_head" + | "minecraft:player_head" + ) + }) + { + return InteractionResult::Pass; + } self.use_without_item(level, ticks, pos, face, hit, player) } From 8691d9a8e88dcdd3f25783a42f24cd00af293eaa Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:14:34 +0100 Subject: [PATCH 012/105] Let players harvest a full beehive with shears or a glass bottle --- crates/horizon-client/src/game.rs | 4 + crates/horizon-client/src/game/beehives.rs | 107 +++++++++++++++++++++ 2 files changed, 111 insertions(+) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1d86fe990..01442b5c4 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3539,6 +3539,10 @@ impl Game<'_> { self.swing_arm(); return Ok(true); } + if self.use_beehive(hit.pos, held.as_ref())? { + self.swing_arm(); + return Ok(true); + } match self.use_respawn_anchor(hit.pos, held.as_ref())? { respawn_anchor::AnchorUse::Charged => { self.swing_arm(); diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs index b7f7efb1a..dfd4382a8 100644 --- a/crates/horizon-client/src/game/beehives.rs +++ b/crates/horizon-client/src/game/beehives.rs @@ -3,8 +3,10 @@ //! player breaks the hive or fire reaches it. use super::Game; use horizon_client::{ + Result, beehive::{self, Beehive, HiveHost, Release}, containers::BlockEntity, + items::ItemStack, mobs::{Mob, Who, bee}, }; use horizon_core::{ @@ -194,6 +196,111 @@ impl Game<'_> { } self.anger_nearby_bees(at); } + /// `BeehiveBlock.useItemOn` with `held` in the acting hand: shears take + /// the honeycombs and a glass bottle a honey bottle from a full hive + /// (honey level 5), then the honey level resets and, unless a campfire + /// smokes the hive, the bees come out angry. True when it took the click. + pub(super) fn use_beehive(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> Result { + let Some(held) = held else { return Ok(false) }; + let shears = &*held.item == "minecraft:shears"; + if !shears && &*held.item != "minecraft:glass_bottle" { + return Ok(false); + } + let state = self.world.block(pos[0], pos[1], pos[2]); + if !matches!( + &*self.res.facts().get(state).name, + "minecraft:beehive" | "minecraft:bee_nest" + ) { + return Ok(false); + } + let prop = |key: &str| { + self.pack + .assets + .registry + .state(state) + .and_then(|s| s.properties.get(key).cloned()) + }; + if prop("honey_level").and_then(|v| v.parse::().ok()) != Some(5) { + return Ok(false); + } + let facing = beehive::facing_step(prop("facing").as_deref()); + let at = self + .player + .as_ref() + .map(|p| [p.position.x, p.position.y, p.position.z]); + if shears { + // dropHoneycomb (harvest/beehive), the shear sound, hurtAndBreak. + for stack in self.sequence_loot( + "minecraft:harvest/beehive", + "minecraft:harvest/beehive", + Some(held), + ) { + self.pop_resource(pos, stack); + } + self.audio + .play("minecraft:block.beehive.shear", at, 1.0, 1.0); + self.damage_held(1); + self.post_block_game_event("minecraft:shear", pos, self.sculk_actor(), None); + } else { + // shrink(1), then the honey bottle in the hand, the inventory or + // on the ground. + self.audio.play("minecraft:item.bottle.fill", at, 1.0, 1.0); + let cell = self.held_mut(); + if let Some(s) = cell.as_mut() { + s.count -= 1; + if s.count == 0 { + *cell = None; + } + } + let bottle = ItemStack::new("minecraft:honey_bottle", 1); + if self.held().is_none() { + *self.held_mut() = Some(bottle); + } else if let Some(rest) = self.give(bottle) + && let Some(eye) = self.eye_position() + { + self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40); + } + self.post_block_game_event("minecraft:fluid_pickup", pos, self.sculk_actor(), None); + } + self.stats.add("used", &held.item, 1); + let smokey = beehive::smokey(&self.mob_world_base(&[]), pos); + let key = (pos[0], pos[1], pos[2]); + if !smokey + && matches!(self.world.block_entities.get(&key), Some(BlockEntity::Beehive(h)) if !h.bees.is_empty()) + { + self.anger_nearby_bees(pos); + } + // resetHoneyLevel. + if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) { + self.level_set(pos, reset)?; + } + if !smokey + && let Some(BlockEntity::Beehive(mut hive)) = self.world.block_entities.take(&key) + { + // emptyAllLivingFromHive: the bees within 4 blocks of the player + // go for them. + let released = hive.release_all( + pos, + facing, + None, + Release::Emergency, + &mut GameHive { game: self }, + ); + self.world + .block_entities + .put(key, BlockEntity::Beehive(hive)); + if let Some(p) = self.player_view().map(|p| p.position) { + for m in self.mobs.iter_mut().filter(|m| released.contains(&m.id)) { + if m.distance_sqr(p) <= 16.0 { + m.ai.target = Some(Who::Player); + } + } + } + } + // ServerPlayerGameMode.useItemOn: the action was consumed. + self.trigger_block("minecraft:item_used_on_block", pos, held); + Ok(true) + } /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down) /// without a target go for a player in the same box. fn anger_nearby_bees(&mut self, at: [i32; 3]) { From 85a6ce09214e684be1810ee6530e85c4476407b3 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:15:30 +0100 Subject: [PATCH 013/105] Lightning scrapes oxidation off copper A struck copper block goes back to unoxidized, and 3 to 5 random walks take one step of oxidation off the weathering copper around it. Waxed blocks stay as they are but still start the walks. --- crates/horizon-client/src/game/lightning.rs | 11 +++ crates/horizon-world/src/level/tick.rs | 83 +++++++++++++++++++++ 2 files changed, 94 insertions(+) diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 916bd2a0a..55e867f87 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -221,6 +221,7 @@ impl Game<'_> { if !b.visual_only { self.bolt_fire(b.at, 4); self.strike_rod(b.at); + self.bolt_clear_copper(b.at); } } b.life -= 1; @@ -278,6 +279,16 @@ impl Game<'_> { self.level_event_at(3002, p, axis); } } + /// `LightningBolt.clearCopperOnLightningStrike` at the block the bolt struck. + fn bolt_clear_copper(&mut self, at: [f64; 3]) { + let p = BlockPos::new( + at[0].floor() as i32, + (at[1] - 1.0e-6).floor() as i32, + at[2].floor() as i32, + ); + self.with_level(|b, level, ticks| b.lightning_clear_copper(level, ticks, p)); + let _ = self.process_level_events(); + } /// `thunderHit` for entities within 3 blocks (up to 9 above). fn thunder_hit(&mut self, b: &mut Bolt) { let at = b.at; diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index 29f53e053..3cb8c2d2e 100644 --- a/crates/horizon-world/src/level/tick.rs +++ b/crates/horizon-world/src/level/tick.rs @@ -1479,6 +1479,80 @@ impl Sim<'_, L> { let block = b.table.block_by_name(&format!("minecraft:{next}"))?; Some(b.table.with_properties_of(block, state)) } + /// `WeatheringCopper.getPrevious` (and `getFirst` by repeating it) by + /// registry naming: the block one oxidation step back. + fn copper_previous_name(path: &str) -> Option { + if let Some(rest) = path.strip_prefix("oxidized_") { + Some(format!("weathered_{rest}")) + } else if let Some(rest) = path.strip_prefix("weathered_") { + Some(format!("exposed_{rest}")) + } else { + path.strip_prefix("exposed_").map(|rest| { + if rest == "copper" { + "copper_block".to_owned() + } else { + rest.to_owned() + } + }) + } + } + fn copper_stepped(&self, state: BlockStateId, all_the_way: bool) -> Option { + let b = self.b; + let name = &*b.table.info(b.block(state)).name; + let mut path = Self::copper_previous_name(name.strip_prefix("minecraft:")?)?; + while all_the_way && let Some(earlier) = Self::copper_previous_name(&path) { + path = earlier; + } + let block = b.table.block_by_name(&format!("minecraft:{path}"))?; + Some(b.table.with_properties_of(block, state)) + } + /// `LightningBolt.clearCopperOnLightningStrike`: the struck copper goes + /// back to unoxidized, then 3 to 5 random walks of up to 8 steps each + /// scrape one step of oxidation off the weathering copper they land on. + /// A waxed block is left as it is but still starts the walks. + pub(crate) fn lightning_clear_copper(&mut self, struck: BlockPos) { + let b = self.b; + let state = self.state(struck); + let weathering = b + .data(state) + .implements(super::classes::Interface::WeatheringCopper); + let waxed = b.table.name(state).starts_with("minecraft:waxed_"); + if !(weathering || waxed) { + return; + } + if weathering && let Some(first) = self.copper_stepped(state, true) { + self.set_block_and_update(struck, first); + } + for _ in 0..self.rand_int(3) + 3 { + let mut at = struck; + for _ in 0..self.rand_int(8) + 1 { + // randomStepCleaningCopper: up to 10 random blocks in the + // 3x3x3 cube around the walk's position. + let mut next = None; + for _ in 0..10 { + let x = at.x - 1 + self.rand_int(3); + let y = at.y - 1 + self.rand_int(3); + let z = at.z - 1 + self.rand_int(3); + let candidate = BlockPos::new(x, y, z); + let state = self.state(candidate); + if b.data(state) + .implements(super::classes::Interface::WeatheringCopper) + { + if let Some(previous) = self.copper_stepped(state, false) { + self.set_block_and_update(candidate, previous); + } + self.level_event(3002, candidate, -1); + next = Some(candidate); + break; + } + } + match next { + Some(p) => at = p, + None => break, + } + } + } + } } /// `Biome.Precipitation` at a position. @@ -1662,6 +1736,15 @@ impl Behaviours { ) { self.sim(level, ticks).random_tick_at(pos); } + /// `LightningBolt.clearCopperOnLightningStrike` for the block at `struck`. + pub fn lightning_clear_copper( + &self, + level: &mut L, + ticks: &mut Ticks, + struck: BlockPos, + ) { + self.sim(level, ticks).lightning_clear_copper(struck); + } /// Run one scheduled block tick at `pos` immediately (no queue check). pub fn scheduled_block_tick( &self, From 53501ab94ea4ad6e91003b14e2ae37106498ce2a Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:15:55 +0100 Subject: [PATCH 014/105] Merge a mob's repeated effects like vanilla A stronger effect now replaces the old one with its own duration, instead of taking the longer duration and the higher level separately. --- crates/horizon-client/src/mobs.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 1b5dddbe7..6a220d63d 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1854,8 +1854,15 @@ impl Mob { } pub fn add_effect(&mut self, effect: &'static str, ticks: i32, amplifier: i32) { if let Some(e) = self.extra.effects.iter_mut().find(|e| e.0 == effect) { - e.1 = e.1.max(ticks); - e.2 = e.2.max(amplifier); + // MobEffectInstance.update: a stronger effect replaces with its + // own duration, an equal one only extends it; a weaker one is + // ignored (vanilla keeps it hidden behind the active one). + if amplifier > e.2 { + e.1 = ticks; + e.2 = amplifier; + } else if amplifier == e.2 && e.1 != -1 && (ticks == -1 || e.1 < ticks) { + e.1 = ticks; + } } else { self.extra.effects.push((effect, ticks, amplifier)); } From 273729aac8e7d6f6de6730688b900663efce2d8c Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:16:34 +0100 Subject: [PATCH 015/105] Count the combat statistics damage_resisted, damage_absorbed and damage_blocked_by_shield now add up when Resistance, absorption hearts or a shield take damage, and a player who lands the killing blow on another player gets player_kills. --- crates/horizon-client/src/game/combat.rs | 10 ++++++++++ crates/horizon-client/src/game/lan_pvp.rs | 22 ++++++++++++++++++++++ crates/horizon-client/src/game/shield.rs | 7 +++++++ 3 files changed, 39 insertions(+) diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index 106e0e1a1..197c77f17 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -73,6 +73,16 @@ impl Game<'_> { self.recheck_combat(); for e in events { let (name, amount) = match e { + // LivingEntity.getDamageAfterMagicAbsorb (Resistance) and + // Player.actuallyHurt (absorption hearts), in tenths. + MotionEvent::Health(HealthEvent::Statistic { name, amount }) => { + match *name { + "resisted" => self.stats.custom("damage_resisted", *amount), + "absorbed" => self.stats.custom("damage_absorbed", *amount), + _ => {} + } + continue; + } MotionEvent::Health(HealthEvent::RecordedDamage { source, amount }) => { let Some(d) = self.motion.health.damage.definition(*source) else { continue; diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index c7c6b6525..a2ff13444 100644 --- a/crates/horizon-client/src/game/lan_pvp.rs +++ b/crates/horizon-client/src/game/lan_pvp.rs @@ -253,6 +253,28 @@ impl Game<'_> { Victim::Host => land(self), Victim::Guest(conn) => self.guest_struck_by(host, conn, land).unwrap_or(false), }; + // ServerPlayer.awardKillScore: the blow that kills a player. + if hurt { + let died = match victim { + Victim::Host => self + .player + .as_ref() + .is_some_and(|p| p.health.dead_or_dying()), + Victim::Guest(conn) => host + .hub + .guest(conn) + .and_then(|g| g.motion.as_deref()) + .is_some_and(|p| p.health.dead_or_dying()), + }; + if died { + match s.attacker { + Some(conn) => { + self.as_guest(host, conn, |g| g.stats.custom("player_kills", 1)); + } + None => self.stats.custom("player_kills", 1), + } + } + } if hurt && s.crit { let target = match victim { Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)), diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs index c4f7f98d1..f4642f272 100644 --- a/crates/horizon-client/src/game/shield.rs +++ b/crates/horizon-client/src/game/shield.rs @@ -121,6 +121,13 @@ impl Game<'_> { attacker: Option, projectile: bool, ) { + // LivingEntity.hurtServer: the damage the shield took, in tenths. + if outcome.blocked > 0.0 { + self.stats.custom( + "damage_blocked_by_shield", + (outcome.blocked * 10.0).round() as i32, + ); + } let Some((slot, _)) = self.using else { return }; let Some(stack) = self.stack_in(slot).cloned() else { return; From dd3697bb4d0f6acd161fc18aaa7eeab3bafbfea5 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:16:43 +0100 Subject: [PATCH 016/105] Hopper minecarts take from the container above, one item per tick --- crates/horizon-client/src/game/machines.rs | 144 ++++++++++++++------ crates/horizon-client/src/game/minecarts.rs | 48 +------ 2 files changed, 106 insertions(+), 86 deletions(-) diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index 8742962e9..55e47aa67 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -624,46 +624,8 @@ impl Game<'_> { /// `HopperBlockEntity.suckInItems`: from the container above, or item entities. fn hopper_suck(&mut self, pos: Pos, hopper: &View) -> bool { let above = (pos.0, pos.1 + 1, pos.2); - let c = self.containers(); - if let Some(source) = c.view(above, false) { - if let Kind::Composter(level) = source.kind { - if level != 8 { - return false; - } - // tryTakeInItemFromSlot on the OutputContainer: removeItem calls - // its setChanged, which empties the composter, and so does the - // second setChanged after the move or, when the hopper has no - // room, the setItem putting the bone meal back into the detached - // container (whose bone meal is lost with it). - let bone_meal = c.bone_meal.clone(); - let at = BlockPos::new(above.0, above.1, above.2); - self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at)); - let moved = self.add_item(None, hopper, bone_meal, None).is_none(); - self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at)); - self.world.modified.insert((above.0 >> 4, above.2 >> 4)); - return moved; - } - let source_hopper = (source.kind == Kind::Hopper).then_some(above); - for slot in source.slots_for_face(Some(Direction::Down)) { - let c = self.containers(); - let Some(stack) = c.get(&source, slot) else { - continue; - }; - if !c.can_take(&source, slot, stack, Direction::Down) { - continue; - } - let Some(one) = self.take_one(&source, slot) else { - continue; - }; - match self.add_item(source_hopper, hopper, one, None) { - None => { - self.view_changed(&source); - return true; - } - Some(rest) => self.put_back(&source, slot, rest), - } - } - return false; + if let Some(took) = self.suck_from_container(above, hopper) { + return took; } let above_state = self.world.block(above.0, above.1, above.2); let blocked = self.res.facts().get(above_state).full_collision @@ -693,6 +655,56 @@ impl Game<'_> { { return false; } + self.suck_item_entities(hopper, min, max) + } + /// The container half of `HopperBlockEntity.suckInItems`: one item from the + /// container at `above`, through its bottom face. `None` when there is no + /// container there. + fn suck_from_container(&mut self, above: Pos, hopper: &View) -> Option { + let c = self.containers(); + let source = c.view(above, false)?; + if let Kind::Composter(level) = source.kind { + if level != 8 { + return Some(false); + } + // tryTakeInItemFromSlot on the OutputContainer: removeItem calls + // its setChanged, which empties the composter, and so does the + // second setChanged after the move or, when the hopper has no + // room, the setItem putting the bone meal back into the detached + // container (whose bone meal is lost with it). + let bone_meal = c.bone_meal.clone(); + let at = BlockPos::new(above.0, above.1, above.2); + self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at)); + let moved = self.add_item(None, hopper, bone_meal, None).is_none(); + self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at)); + self.world.modified.insert((above.0 >> 4, above.2 >> 4)); + return Some(moved); + } + let source_hopper = (source.kind == Kind::Hopper).then_some(above); + for slot in source.slots_for_face(Some(Direction::Down)) { + let c = self.containers(); + let Some(stack) = c.get(&source, slot) else { + continue; + }; + if !c.can_take(&source, slot, stack, Direction::Down) { + continue; + } + let Some(one) = self.take_one(&source, slot) else { + continue; + }; + match self.add_item(source_hopper, hopper, one, None) { + None => { + self.view_changed(&source); + return Some(true); + } + Some(rest) => self.put_back(&source, slot, rest), + } + } + Some(false) + } + /// The item half of `HopperBlockEntity.suckInItems` (`getItemsAtAndAbove`): + /// adds the item entities that meet the box, until one is taken whole. + fn suck_item_entities(&mut self, hopper: &View, min: [f64; 3], max: [f64; 3]) -> bool { let mut i = 0; while i < self.dropped.len() { let b = self.dropped[i].bounds(); @@ -717,6 +729,58 @@ impl Game<'_> { } false } + /// `MinecartHopper.tick`'s `tryConsumeItems` (`suckInItems`) for an enabled + /// hopper minecart: one item from the container above, else the item + /// entities over it or touching it, each tick without a cooldown. + pub(super) fn hopper_cart_suck(&mut self, cart: &mut super::minecarts::Minecart) { + // The cart's slots are edited as a container under the placeholder key + // its menu uses; when that menu is open the placeholder is the live copy. + let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, cart.id as i32); + let open = self.world.block_entities.contains_key(&key); + if !open { + let items = BlockEntity::Chest(std::mem::take(&mut cart.items)); + self.world.block_entities.insert(key, items); + } + let size = self + .world + .block_entities + .get(&key) + .map_or(0, |e| e.slots().len()); + let view = View { + parts: vec![(key, size)], + kind: Kind::Generic, + }; + let p = cart.position; + // getLevelY is the cart's y + 0.5, so the container is the block at + // y + 1.5, and Hopper.SUCK_AABB (moved by getLevel - 0.5) starts 11/16 + // above the cart. + let above = ( + p.x.floor() as i32, + (p.y + 1.5).floor() as i32, + p.z.floor() as i32, + ); + let took = match self.suck_from_container(above, &view) { + Some(took) => took, + None => self.suck_item_entities( + &view, + [p.x - 0.5, p.y + 11.0 / 16.0, p.z - 0.5], + [p.x + 0.5, p.y + 2.0, p.z + 0.5], + ), + }; + if !took { + // The cart's own box, inflated by 0.25 sideways. + let b = cart.bounds(); + let (lo, hi) = (b.min_position(), b.max_position()); + self.suck_item_entities( + &view, + [lo.x - 0.25, lo.y, lo.z - 0.25], + [hi.x + 0.25, hi.y, hi.z + 0.25], + ); + } + if !open && let Some(BlockEntity::Chest(items)) = self.world.block_entities.remove(&key) { + cart.items = items; + } + } // ---- dispensers and droppers ---- diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index a19b6df73..33e08a922 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -642,50 +642,6 @@ impl Game<'_> { self.carts.retain(|x| x.id != c.id); let _ = self.server_explode(at, power, BlockInteraction::Destroy, false); } - /// `MinecartHopper.suckInItems`: items above, into the five slots. - fn hopper_cart_pickup(&mut self, c: &mut Minecart) { - if !c.enabled { - return; - } - let p = c.position; - let zone = Aabb::new( - Vec3::new(p.x - 0.5, p.y - 0.5 + 0.0, p.z - 0.5), - Vec3::new(p.x + 0.5, p.y + 1.5, p.z + 0.5), - ); - let mut i = 0; - while i < self.dropped.len() { - let e = &self.dropped[i]; - if e.pickup_delay > 0 || !zone.contains(e.position) { - i += 1; - continue; - } - let mut stack = e.stack.clone(); - for slot in c.items.iter_mut() { - match slot { - None => { - *slot = Some(stack.clone()); - stack.count = 0; - } - Some(s) if s.same_item_same_components(&stack) => { - let max = self.res.items().get(&s.item).map_or(64, |i| i.max_stack); - let moved = stack.count.min(max.saturating_sub(s.count)); - s.count += moved; - stack.count -= moved; - } - _ => {} - } - if stack.count == 0 { - break; - } - } - if stack.count == 0 { - self.dropped.remove(i); - } else { - self.dropped[i].stack = stack; - i += 1; - } - } - } /// `AbstractMinecart.push` from each player walking into a cart /// (`LivingEntity.pushEntities`): the window's player and every server /// player (single player's own on its server thread, LAN guests). A @@ -823,8 +779,8 @@ impl Game<'_> { } let mut c = self.carts[i].clone(); let alive = self.tick_cart(&mut c, [0.0; 2]); - if c.kind == CartKind::Hopper { - self.hopper_cart_pickup(&mut c); + if c.kind == CartKind::Hopper && c.enabled { + self.hopper_cart_suck(&mut c); } let Some(i) = self.carts.iter().position(|c| c.id == id) else { continue; From ef711f8b1f356c1f1b6745b366a00c38f19076b4 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:16:44 +0100 Subject: [PATCH 017/105] Fire the brewed_potion trigger when a potion is taken from a brewing stand --- crates/horizon-client/src/game.rs | 4 +++ .../horizon-client/src/game/advancements.rs | 19 +++++++++++ .../horizon-client/src/game/lan_crafting.rs | 9 ++++++ crates/horizon-client/src/menu.rs | 32 +++++++++++++------ 4 files changed, 55 insertions(+), 9 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1d86fe990..bb8d61f09 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -6176,6 +6176,7 @@ impl Game<'_> { self.player_menu_sound(sound); } let crafted = std::mem::take(&mut menu.crafted); + let brewed = std::mem::take(&mut menu.brewed); let equipped = std::mem::take(&mut menu.equipped); for (i, stack) in after.into_iter().enumerate() { if let Some(g) = game_of[i] { @@ -6191,6 +6192,9 @@ impl Game<'_> { self.player_drop(stack); } self.award_crafted(&crafted); + for stack in &brewed { + self.trigger_brewed_potion(stack); + } if furnace_before > furnace_after && self.remote.is_none() && let (Some(pos), Some(p)) = (self.container, self.player.as_ref()) diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 0f76d0ca9..53fa282d4 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -708,6 +708,25 @@ impl Game<'_> { let it = item_view(stack); self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w)); } + /// `BrewedPotionTrigger`: the potion contents of a stack taken from a + /// brewing stand. + pub(super) fn trigger_brewed_potion(&mut self, stack: &ItemStack) { + let me = self.player_entity(); + let potion = stack.potion().map(str::to_owned); + self.trigger("minecraft:brewed_potion", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) + && (c["potion"].is_null() + || potion + .as_deref() + .is_some_and(|p| adv::id_matches(&c["potion"], "potion", p, w))) + }); + } /// `EnterBlockTrigger`: the block, its state properties and the player. pub(super) fn trigger_enter_block(&mut self, state: horizon_world::registry::BlockStateId) { let Some(definition) = self.pack.assets.registry.state(state).cloned() else { diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs index db6235c4d..f868bb957 100644 --- a/crates/horizon-client/src/game/lan_crafting.rs +++ b/crates/horizon-client/src/game/lan_crafting.rs @@ -127,9 +127,18 @@ impl Game<'_> { } let dropped = std::mem::take(&mut menu.dropped); let equipped = std::mem::take(&mut menu.equipped); + let brewed = std::mem::take(&mut menu.brewed); menu.drops.clear(); menu.crafted.clear(); store_player(menu, &mut host.hub.guests[gi]); + if !brewed.is_empty() { + let conn = host.hub.guests[gi].conn; + self.as_guest(host, conn, |g| { + for stack in &brewed { + g.trigger_brewed_potion(stack); + } + }); + } if !equipped.is_empty() { let conn = host.hub.guests[gi].conn; self.as_guest(host, conn, |g| { diff --git a/crates/horizon-client/src/menu.rs b/crates/horizon-client/src/menu.rs index 3b2b8fd31..50f90b280 100644 --- a/crates/horizon-client/src/menu.rs +++ b/crates/horizon-client/src/menu.rs @@ -288,6 +288,9 @@ pub struct Menu { pub player_sounds: Vec<&'static str>, /// Recipes whose result was taken (`awardUsedRecipes`), for the caller. pub crafted: Vec, + /// Potions taken from a brewing stand's bottle slots + /// (`PotionSlot.onTake`), for the caller. + pub brewed: Vec, /// `LivingEntity.onEquipItem` calls that change the item: the /// `EquipmentSlot` name and the new stack, in order, for the caller. pub equipped: Vec<(&'static str, Option)>, @@ -683,6 +686,7 @@ impl Menu { sounds: Vec::new(), player_sounds: Vec::new(), crafted: Vec::new(), + brewed: Vec::new(), equipped: Vec::new(), merchant: None, stone: Stonecutter::default(), @@ -1504,7 +1508,17 @@ impl Menu { } /// `ResultSlot.onTake` and the other `Slot.onTake` overrides. - fn on_take(&mut self, env: &Env, s: usize) { + fn on_take(&mut self, env: &Env, s: usize, taken: &ItemStack) { + if self.slots[s].role == Role::Potion { + // BrewingStandMenu.PotionSlot.onTake: a stack with potion contents. + if matches!( + &*taken.item, + "minecraft:potion" | "minecraft:splash_potion" | "minecraft:lingering_potion" + ) { + self.brewed.push(taken.clone()); + } + return; + } if self.slots[s].role == Role::MerchantResult { self.merchant_take(env); return; @@ -1671,7 +1685,7 @@ impl Menu { max_amount: u32, ) -> Option { let mut result = self.try_remove(env, s, amount, max_amount)?; - self.on_take(env, s); + self.on_take(env, s, &result); if self.slots[s].role == Role::CartoResult { Self::map_crafted(env, &mut result); } @@ -2346,7 +2360,7 @@ impl Menu { return None; } if after_take || matches!(self.kind, Kind::Inventory | Kind::Crafting) { - self.on_take(env, index); + self.on_take(env, index, &clicked); } // What the result slot's move left over is dropped. if (index == 0 && matches!(self.kind, Kind::Inventory | Kind::Crafting)) @@ -2594,7 +2608,7 @@ impl Menu { }; if let Some(mut taken) = self.try_remove(env, s, amount, u32::MAX) { self.carried = Some(taken.clone()); - self.on_take(env, s); + self.on_take(env, s, &taken); if self.slots[s].role == Role::CartoResult { // onTake's onCraftedBy edits the carried stack. Self::map_crafted(env, &mut taken); @@ -2628,7 +2642,7 @@ impl Menu { if let Some(c) = self.carried.as_mut() { c.count += taken.count; } - self.on_take(env, s); + self.on_take(env, s, &taken); if self.slots[s].role == Role::CartoResult { // onCraftedBy edits the taken stack, not the carried one. Self::map_crafted(env, &mut taken); @@ -2656,7 +2670,7 @@ impl Menu { if self.may_pickup(env, target) { self.containers[PLAYER][inv_slot] = Some(taken.clone()); self.set_by_player(env, target, None); - self.on_take(env, target); + self.on_take(env, target, &taken); if self.slots[target].role == Role::CartoResult && let Some(stack) = self.containers[PLAYER][inv_slot].as_mut() { @@ -2684,14 +2698,14 @@ impl Menu { let part = split(&mut source, max); self.containers[PLAYER][inv_slot] = Some(source); self.set_by_player(env, target, Some(part)); - self.on_take(env, target); + self.on_take(env, target, &taken); if !self.inventory_add(env, &mut taken) { self.drop_stack(&taken); } } else { - self.containers[PLAYER][inv_slot] = Some(taken); + self.containers[PLAYER][inv_slot] = Some(taken.clone()); self.set_by_player(env, target, Some(source)); - self.on_take(env, target); + self.on_take(env, target, &taken); } } } From 9c427dfae01619b5f02a863fe067990947d267ec Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:16:54 +0100 Subject: [PATCH 018/105] Mobs killed by a wither leave a wither rose --- crates/horizon-client/src/game/creatures.rs | 1 + crates/horizon-client/src/game/wither.rs | 42 +++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 194256040..cd211ec48 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -717,6 +717,7 @@ impl Game<'_> { self.villager_murdered(m, by_player); let pos = [m.position.x, m.position.y + 0.5, m.position.z]; self.drop_death_loot(&mut dying, by_player, consumed, pos); + self.create_wither_rose(m); if m.species() == Species::CopperGolem { // CopperGolem.dropEquipment: the preserved equipment too. self.golem_drop_equipment(&mut dying); diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs index 8084425ca..101818f68 100644 --- a/crates/horizon-client/src/game/wither.rs +++ b/crates/horizon-client/src/game/wither.rs @@ -2,11 +2,53 @@ //! its boss bar, and its skulls hitting and exploding. use super::Game; use horizon_client::{ + items::ItemStack, mobs::{Damage, DamageKind, Species, Who}, projectiles::{Projectile, ProjectileKind}, }; +use horizon_core::position::BlockPos; impl Game<'_> { + /// `LivingEntity.createWitherRose`: a mob a wither killed leaves a wither + /// rose where it stood (with mobGriefing, on air that can hold it), else + /// drops one. + pub(super) fn create_wither_rose(&mut self, m: &horizon_client::mobs::Mob) { + // getKillCredit: the player who last hurt it, else the last mob (kept + // for 100 ticks). + let by_wither = m.ai.last_hurt_by_player <= 0 + && m.age as i32 - m.ai.last_hurt_by_time <= 100 + && matches!(m.ai.last_hurt_by, Some(Who::Mob(id)) + if self.mobs.iter().any(|o| o.id == id && o.alive() && o.species() == Species::Wither)); + if !by_wither { + return; + } + let pos = [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ]; + let registry = self.pack.assets.registry; + let rose = registry.default_state("minecraft:wither_rose"); + if self.ui.rules.bool("mob_griefing") + && let Some(rose) = rose + && self + .res + .facts() + .is_air(self.world.block(pos[0], pos[1], pos[2])) + && self.with_level(|b, level, ticks| { + b.can_survive(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]), rose) + }) + { + let _ = self.level_set(pos, rose); + return; + } + self.spawn_item( + ItemStack::new("minecraft:wither_rose", 1), + [m.position.x, m.position.y, m.position.z], + super::dispenser::new_item_motion(), + 0, + ); + } fn is_wither_skull(&self, p: [i32; 3]) -> bool { let name = &*self .res From b3a499d85d720acf6d133f47f79806edfa485560 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:18:05 +0100 Subject: [PATCH 019/105] Play chest, barrel and shulker box sounds with a random pitch from the right spot --- crates/horizon-client/src/game.rs | 22 ++------------ crates/horizon-client/src/game/storage.rs | 35 +++++++++++++++++++++++ 2 files changed, 37 insertions(+), 20 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1d86fe990..147aefe36 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3077,16 +3077,7 @@ impl Game<'_> { None }; if let Some(sound) = sound { - self.audio.play( - sound, - Some([ - f64::from(key.0) + 0.5, - f64::from(key.1) + 0.5, - f64::from(key.2) + 0.5, - ]), - 0.5, - 1.0, - ); + self.container_sound(sound, key, &name); } } else if self.open_station(pos, &name) { // Workstation menus: game/stations.rs. @@ -5654,16 +5645,7 @@ impl Game<'_> { None }; if let Some(sound) = sound { - self.audio.play( - sound, - Some([ - f64::from(key.0) + 0.5, - f64::from(key.1) + 0.5, - f64::from(key.2) + 0.5, - ]), - 0.5, - 1.0, - ); + self.container_sound(sound, key, &name); } self.world.modified.insert((key.0 >> 4, key.2 >> 4)); } diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs index 1bcb6a524..3456c4ab0 100644 --- a/crates/horizon-client/src/game/storage.rs +++ b/crates/horizon-client/src/game/storage.rs @@ -3,6 +3,7 @@ //! player's `PlayerEnderChestContainer`, saved as `EnderItems`). use super::Game; use horizon_client::{containers::BlockEntity, items::ItemStack, text::Text}; +use horizon_core::random::RandomSource; pub(super) fn is_shulker_box(name: &str) -> bool { name.ends_with("shulker_box") @@ -107,6 +108,40 @@ impl Game<'_> { ); paired.then_some((other, kind == "right")) } + /// The open or close sound of a container block (`ChestBlockEntity.playSound`, + /// `BarrelBlockEntity.playSound`, `ShulkerBoxBlockEntity.startOpen`): volume + /// 0.5 and pitch 0.9 to 1.0. A double chest sounds once from the middle of + /// both halves, a barrel from the face it opens on. + pub(super) fn container_sound(&mut self, sound: &str, key: (i32, i32, i32), name: &str) { + let mut at = [ + f64::from(key.0) + 0.5, + f64::from(key.1) + 0.5, + f64::from(key.2) + 0.5, + ]; + if let Some((other, _)) = self.chest_partner(key) { + at[0] = f64::from(key.0 + other.0) / 2.0 + 0.5; + at[2] = f64::from(key.2 + other.2) / 2.0 + 0.5; + } else if name == "minecraft:barrel" + && let Some(state) = self + .pack + .assets + .registry + .state(self.world.block(key.0, key.1, key.2)) + && let Some(facing) = state.properties.get("facing") + { + let (dx, dy, dz) = match facing.as_str() { + "up" => (0.0, 0.5, 0.0), + "down" => (0.0, -0.5, 0.0), + f => { + let (x, z) = facing_step(f); + (f64::from(x) / 2.0, 0.0, f64::from(z) / 2.0) + } + }; + at = [at[0] + dx, at[1] + dy, at[2] + dz]; + } + let pitch = self.world.random.next_float() * 0.1 + 0.9; + self.audio.play(sound, Some(at), 0.5, pitch); + } /// The other half of a double chest at `key`, for neighbour updates. pub(super) fn chest_other_half(&self, key: (i32, i32, i32)) -> Option<(i32, i32, i32)> { self.chest_partner(key).map(|p| p.0) From 147e5269c76430060007b13a1dc947a99062896c Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:19:20 +0100 Subject: [PATCH 020/105] Play the rain sound the way vanilla picks it --- crates/horizon-client/src/game.rs | 35 +++---------------- crates/horizon-client/src/game/render_tick.rs | 23 +++++++++++- 2 files changed, 26 insertions(+), 32 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1d86fe990..f491b3f8f 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1382,6 +1382,8 @@ struct Game<'a> { /// `ClientAvatarState`: walked distance and view bob. avatar: horizon_client::camera::AvatarBob, flash: u32, + /// `ClientLevel.rainSoundTime`: ticks of rain since the last rain sound. + rain_sound_time: i32, /// Bolts that struck here and sky flashes they made, in total (`status`). lightning_seen: [u32; 2], /// The head of the bed while sleeping; the visual timer also survives waking. @@ -9497,37 +9499,7 @@ impl Game<'_> { if self.flash > 0 { self.flash -= 1; } - let (rain, _) = self.world.weather.levels(1.0); - let Some(eye) = self.eye_position() else { - return; - }; - // WeatherEffectRenderer.tickRainParticles: occasional rain sounds. - if rain > 0.0 && self.world.random.next_int_bound(3).unwrap_or(1) < (rain * 3.0) as i32 { - let r = &mut self.world.random; - let (dx, dz) = ( - r.next_int_bound(21).unwrap_or(10) - 10, - r.next_int_bound(21).unwrap_or(10) - 10, - ); - let (x, z) = (eye[0].floor() as i32 + dx, eye[2].floor() as i32 + dz); - let top = self.rain_height(x, z); - if self.precipitation(x, top, z) == Some(false) - && (top - eye[1] as i32).abs() < 10 - && self.world.random.next_int_bound(5).unwrap_or(1) == 0 - { - let above = f64::from(top) > eye[1] + 1.0; - let (name, volume, pitch) = if above { - ("minecraft:weather.rain.above", 0.1, 0.5) - } else { - ("minecraft:weather.rain", 0.2, 1.0) - }; - self.audio.play( - name, - Some([f64::from(x) + 0.5, f64::from(top), f64::from(z) + 0.5]), - volume, - pitch, - ); - } - } + // The rain sounds come with the rain splashes (`tick_particles`). } /// WeatherEffectRenderer: rain and snow columns within the weather radius. fn weather_geometry( @@ -12267,6 +12239,7 @@ impl<'a> Game<'a> { dragging: false, avatar: Default::default(), flash: 0, + rain_sound_time: 0, lightning_seen: [0; 2], sleeping: None, sleep_timer: 0, diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index e013c8d29..2356fbffe 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -288,11 +288,13 @@ impl Game<'_> { ]; animate_tick(self.res.animate(), &mut self.particles, &ctx, block); if rain > 0.0 { - // ClientLevel.tickWeatherEffects: rain splashes (weather radius 10). + // ClientLevel.tickWeatherEffects: rain splashes (weather radius 10) + // and the rain sound. let mut random = LegacyRandom::new(self.world.game_time.wrapping_mul(312_987_231)); let radius = 10; let diameter = 2 * radius + 1; let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32; + let mut rain_position = None; for _ in 0..count { let x = block[0] + random.next_int_bound(diameter).unwrap_or(0) - radius; let z = block[2] + random.next_int_bound(diameter).unwrap_or(0) - radius; @@ -305,6 +307,7 @@ impl Game<'_> { continue; } let below = top - 1; + rain_position = Some([x, below, z]); let (bx, bz) = (random.next_double(), random.next_double()); let state = world.block(x, below, z); let f = facts.get(state); @@ -336,6 +339,24 @@ impl Game<'_> { self.particles .add(&ParticleOptions::simple(ty), p, [0.0; 3]); } + // The last rain column of the tick makes the sound, more often the + // longer it has been quiet; indoors it is the quieter one. + if let Some(at) = rain_position { + let waited = self.rain_sound_time; + self.rain_sound_time += 1; + if random.next_int_bound(3).unwrap_or(0) < waited { + self.rain_sound_time = 0; + let roof = + motion_blocking(world, facts, block[0], block[2], MIN_Y + HEIGHT); + let (name, volume, pitch) = if at[1] > block[1] + 1 && roof > block[1] { + ("minecraft:weather.rain.above", 0.1, 0.5) + } else { + ("minecraft:weather.rain", 0.2, 1.0) + }; + let p = at.map(|c| f64::from(c) + 0.5); + self.audio.play(name, Some(p), volume, pitch); + } + } } } if let Some(r) = &self.renderer { From 2e642857fc36d4b4d2e1148dc0fedf73aead5128 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:20:03 +0100 Subject: [PATCH 021/105] Fire the levitation and using_item advancement triggers --- crates/horizon-client/src/advancements.rs | 47 +++++----- crates/horizon-client/src/game.rs | 2 + .../horizon-client/src/game/advancements.rs | 85 +++++++++++++++++++ crates/horizon-client/src/game/lan_actions.rs | 7 ++ 4 files changed, 120 insertions(+), 21 deletions(-) diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs index 6706532b7..187f88382 100644 --- a/crates/horizon-client/src/advancements.rs +++ b/crates/horizon-client/src/advancements.rs @@ -437,6 +437,8 @@ pub struct EntityView { /// mainhand, offhand, head, chest, legs, feet, body. pub equipment: [Option; 7], pub vehicle: Option>, + /// Player: what it looks at within 100 blocks (`PlayerPredicate.lookingAt`). + pub looking_at: Option>, pub effects: Vec<(String, i32, i32)>, /// Player: game mode name. pub gamemode: Option, @@ -458,7 +460,7 @@ fn range_f(v: &Value, x: f64) -> bool { _ => false, } } -fn range_i(v: &Value, x: i64) -> bool { +pub fn range_i(v: &Value, x: i64) -> bool { range_f(v, x as f64) } /// A registry id, `#tag`, or list matched against one id. @@ -614,6 +616,18 @@ fn components(expected: &Value, have: &[(String, String)]) -> bool { }) }) } +/// `DistancePredicate.matches` between two points. +pub fn distance(v: &Value, a: [f64; 3], b: [f64; 3]) -> bool { + let d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; + range_f(&v["x"], d[0].abs()) + && range_f(&v["y"], d[1].abs()) + && range_f(&v["z"], d[2].abs()) + && range_f(&v["horizontal"], (d[0] * d[0] + d[2] * d[2]).sqrt()) + && range_f( + &v["absolute"], + (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(), + ) +} /// `EntityPredicate` (26.x keyed sub-predicates). pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> bool { if v.is_null() { @@ -629,21 +643,7 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo "minecraft:stepping_on" => { location(p, [e.position[0], e.position[1] - 0.5, e.position[2]], w) } - "minecraft:distance" | "distance" => { - let d = [ - e.position[0] - origin[0], - e.position[1] - origin[1], - e.position[2] - origin[2], - ]; - range_f(&p["x"], d[0].abs()) - && range_f(&p["y"], d[1].abs()) - && range_f(&p["z"], d[2].abs()) - && range_f(&p["horizontal"], (d[0] * d[0] + d[2] * d[2]).sqrt()) - && range_f( - &p["absolute"], - (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(), - ) - } + "minecraft:distance" | "distance" => distance(p, e.position, origin), "minecraft:flags" | "flags" => { let f = |k: &str, have: bool| p[k].as_bool().is_none_or(|want| want == have); f("is_on_fire", e.on_fire) @@ -678,11 +678,16 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo }) }) }), - "minecraft:type_specific/player" => p["gamemode"].as_array().is_none_or(|modes| { - e.gamemode - .as_deref() - .is_some_and(|g| modes.iter().any(|m| m.as_str() == Some(g))) - }), + "minecraft:type_specific/player" => { + p["gamemode"].as_array().is_none_or(|modes| { + e.gamemode + .as_deref() + .is_some_and(|g| modes.iter().any(|m| m.as_str() == Some(g))) + }) && (p["looking_at"].is_null() + || e.looking_at + .as_ref() + .is_some_and(|t| entity(&p["looking_at"], t, w, origin))) + } "minecraft:type_specific/lightning" => { range_i(&p["blocks_set_on_fire"], 0) && (p["entity_struck"].is_null() diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1d86fe990..ae29abe8f 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3875,6 +3875,8 @@ impl Game<'_> { self.release_used_item(&stack, ticks, hand_changed); return; } + // ServerPlayer.updateUsingItem: USING_ITEM every tick of the use. + self.trigger_using_item(&stack); let Some(info) = self.res.items().get(&stack.item).cloned() else { self.using = None; return; diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 0f76d0ca9..67615b628 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -82,6 +82,8 @@ pub(super) struct AdvState { pub(super) quiet: bool, /// The inventory last seen by `inventory_changed`. pub(super) last_inventory: u64, + /// `ServerPlayer.levitationStartPos` and `levitationStartTime`. + pub(super) levitation: Option<([f64; 3], u64)>, /// While the game acts for a network player (`as_guest`): the /// advancements whose progress changed (`progressChanged`), the recipes /// unlocked and the announcements, for their client and everyone's. @@ -647,6 +649,28 @@ impl Game<'_> { }; adv::conditions(&c["player"], &ctx, w) }); + // ServerPlayer.onEffectAdded and onEffectsRemoved keep the start of a + // levitation; tick fires LEVITATION while there is one. + let levitating = self + .potions + .effects + .list + .iter() + .any(|e| e.id == "levitation"); + match (levitating, self.adv.levitation) { + (true, None) => { + let at = self + .player + .as_ref() + .map(|p| [p.position.x, p.position.y, p.position.z]); + self.adv.levitation = at.map(|at| (at, self.ticks)); + } + (false, Some(_)) => self.adv.levitation = None, + _ => {} + } + if let Some((start, since)) = self.adv.levitation { + self.trigger_levitation(start, (self.ticks - since) as i64); + } if self.ticks.is_multiple_of(20) { let me = self.player_entity(); self.trigger("minecraft:location", |c, w| { @@ -681,6 +705,67 @@ impl Game<'_> { adv::conditions(&c["player"], &pctx, w) && adv::conditions(&c[&key], &ectx, w) }); } + /// `LevitationTrigger`: how far the player rose from where it started + /// levitating, and for how long. + fn trigger_levitation(&mut self, start: [f64; 3], duration: i64) { + let me = self.player_entity(); + self.trigger("minecraft:levitation", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) + && (c["distance"].is_null() || adv::distance(&c["distance"], start, me.position)) + && adv::range_i(&c["duration"], duration) + }); + } + /// `ServerPlayer.updateUsingItem`: USING_ITEM for the item in use, with + /// what the player looks at (`PlayerPredicate.lookingAt`). + pub(super) fn trigger_using_item(&mut self, stack: &ItemStack) { + if self.remote.is_some() || self.no_player_here() { + return; + } + let mut me = self.player_entity(); + me.looking_at = self.looking_at_entity().map(Box::new); + let it = item_view(stack); + self.trigger("minecraft:using_item", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) && adv::item(&c["item"], &it, w) + }); + } + /// The mob a 100 block ray from the eyes meets first, if no block is in + /// the way (`ProjectileUtil.getEntityHitResult` and `hasLineOfSight`). + fn looking_at_entity(&self) -> Option { + let eye = self.eye_position()?; + let dir = super::view_vector(self.yaw, self.pitch); + let (m, _) = self + .mobs + .iter() + .filter(|m| m.alive()) + .filter_map(|m| Some((m, super::ray_box(eye, dir, 100.0, m.bounds())?))) + .min_by(|a, b| a.1.total_cmp(&b.1))?; + // Eye to the target's centre, two samples per block. + let to = m.center(); + let reach = (0..3).map(|i| (to[i] - eye[i]).powi(2)).sum::().sqrt(); + let steps = (reach * 2.0).ceil().max(1.0) as i32; + let clear = (1..steps).all(|i| { + let f = f64::from(i) / f64::from(steps); + let p = [0, 1, 2].map(|a| (eye[a] + (to[a] - eye[a]) * f).floor() as i32); + !self + .res + .facts() + .get(self.world.block(p[0], p[1], p[2])) + .full_collision + }); + clear.then(|| self.mob_entity(m)) + } /// A player condition plus one item (`item` key). pub(super) fn trigger_item(&mut self, name: &str, stack: &ItemStack) { let me = self.player_entity(); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 0ad14bbcc..d1696d19a 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -75,6 +75,8 @@ pub(super) struct GuestPlay { /// `ServerPlayer.getStats` and the inventory `inventory_changed` last saw. pub(super) stats: super::stats::Stats, last_inventory: u64, + /// `ServerPlayer.levitationStartPos` and `levitationStartTime`. + levitation: Option<([f64; 3], u64)>, /// `Entity.portalProcess` and `portalCooldown` (game/server_travel.rs). pub(super) portal: horizon_client::nether_portal::PortalState, /// `Player.takeXpDelay`: ticks until the next orb can be taken. @@ -154,6 +156,7 @@ pub(super) struct GuestSwap { host_ender: Option<(i32, i32, i32)>, adv_loaded: bool, last_inventory: u64, + levitation: Option<([f64; 3], u64)>, death_cause: Option, /// The guest's own damage record, in place while they act. combat: super::combat::CombatTracker, @@ -378,6 +381,7 @@ impl Game<'_> { std::mem::swap(&mut self.hook, &mut play.hook); let adv_loaded = std::mem::replace(&mut self.adv.loaded, true); let last_inventory = std::mem::replace(&mut self.adv.last_inventory, play.last_inventory); + let levitation = std::mem::replace(&mut self.adv.levitation, play.levitation); let death_cause = std::mem::replace(&mut self.ui.death_cause, play.death_cause.take()); let acting = ( self.lan_acting.replace(conn), @@ -442,6 +446,7 @@ impl Game<'_> { host_ender, adv_loaded, last_inventory, + levitation, death_cause, acting, packets, @@ -500,6 +505,7 @@ impl Game<'_> { host_ender, adv_loaded, last_inventory, + levitation, death_cause, combat, acting, @@ -610,6 +616,7 @@ impl Game<'_> { std::mem::swap(&mut self.hook, &mut play.hook); self.adv.loaded = adv_loaded; play.last_inventory = std::mem::replace(&mut self.adv.last_inventory, last_inventory); + play.levitation = std::mem::replace(&mut self.adv.levitation, levitation); let stat_events = std::mem::take(&mut play.stats.events); let name = g.name.clone(); self.potions.swap_player(&mut g.effects, &mut play.potions); From 70868f32087fda64a976ff027af6658e6725f69c Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:20:34 +0100 Subject: [PATCH 022/105] Give Oozing, Infested, Weaving and Wind Charged their effects These four 26.x effects only existed as potion entries. Oozing spawns two slimes, Weaving places cobwebs and Wind Charged makes a gust when the bearer dies. Infested sometimes releases silverfish when the bearer is hurt. --- crates/horizon-client/src/game/combat.rs | 4 + crates/horizon-client/src/game/creatures.rs | 26 ++++ crates/horizon-client/src/game/potions.rs | 156 +++++++++++++++++++- crates/horizon-client/src/mobs.rs | 7 + 4 files changed, 191 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index 106e0e1a1..1af22fe48 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -109,6 +109,10 @@ impl Game<'_> { attacker, }); self.combat.last_damage = now; + // InfestedMobEffect.onMobHurt. + if self.potions.effects.get("infested").is_some() { + self.player_infested(); + } } self.combat.pending.clear(); self.combat.fall_before = self.player.as_ref().map_or(0.0, |p| p.fall_distance); diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 194256040..de1cd1bee 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -501,6 +501,7 @@ impl Game<'_> { let mut events = Vec::new(); let mut mobs = std::mem::take(&mut self.mobs); let mut dead = Vec::new(); + let mut corpses = Vec::new(); let mut died = std::mem::take(&mut self.died); let ticking = self.entity_ticking_area(); // With guests on, each mob sees its nearest player (game/lan_mobs.rs). @@ -593,6 +594,11 @@ impl Game<'_> { horizon_client::mobs::apply_mob_pushes(m, &mut pushes); let from = events.len(); let kept = m.tick(&w, &mut scratch, &mut events); + // A killed mob's body is removed: its effects that act on + // death run (`LivingEntity.remove` with KILLED). + if !kept && !m.alive() && !m.removed && !m.extra.effects.is_empty() { + corpses.push(m.clone()); + } horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes); if let Some(conn) = seen_guest { // ShulkerBullet.finalTarget is the guest's entity: the @@ -661,6 +667,15 @@ impl Game<'_> { for m in dead { self.mob_died(&m); } + for m in corpses { + let names: Vec<&'static str> = m + .extra + .effects + .iter() + .map(|e| e.0.trim_start_matches("minecraft:")) + .collect(); + self.effects_on_death(&names, m.bounds(), false, Some(m.id)); + } self.handle_mob_events(events)?; self.lan_guest_mob_events(guest_events); self.tick_projectiles()?; @@ -990,6 +1005,17 @@ impl Game<'_> { } MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob), MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive), + MobEvent::Infested { mob } => { + if let Some(m) = self.mobs.iter().find(|m| m.id == mob) { + let at = [ + m.position.x, + m.position.y + f64::from(m.height()) / 2.0, + m.position.z, + ]; + let look = m.view_vector(); + self.infested_hurt(at, look); + } + } MobEvent::Gift { target, item } => { if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target) && m.saddle_item().is_none() diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index b28c2fb4d..360ed0612 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -13,7 +13,10 @@ use horizon_client::{ items::ItemStack, mesher::Vertex, }; -use horizon_core::{geometry::Vec3, random::RandomSource}; +use horizon_core::{ + geometry::{Aabb, Direction, Vec3}, + random::RandomSource, +}; /// A thrown splash or lingering potion in flight. #[derive(Clone, Debug)] @@ -45,6 +48,136 @@ fn mob_effect_id(id: &str) -> Option<&'static str> { .copied() } impl Game<'_> { + /// `LivingEntity.triggerOnDeathMobEffects` (`onMobRemoved` with the reason + /// KILLED) for what Oozing, Weaving and Wind Charged do when their bearer + /// dies. `bearer` is the dying mob's id, `player` whether it is a player. + pub(super) fn effects_on_death( + &mut self, + effects: &[&str], + bounds: Aabb, + player: bool, + bearer: Option, + ) { + let feet = bounds.bottom_center(); + if effects.contains(&"oozing") { + // OozingMobEffect.numberOfSlimesToSpawn: two, fewer when the + // slimes close by already fill the cramming limit. + let limit = self.ui.rules.int("max_entity_cramming"); + let mut count = 2; + if limit >= 1 { + let near = bounds.inflate(Vec3::new(2.0, 2.0, 2.0)); + let nearby = self + .mobs + .iter() + .filter(|m| { + m.species() == horizon_client::mobs::Species::Slime + && Some(m.id) != bearer + && m.bounds().intersects(near) + }) + .count() + .min(limit as usize) as i32; + count = (limit - nearby).clamp(0, count); + } + for _ in 0..count { + // spawnSlimeOffspring: a size 2 slime half a block up. + if let Some(id) = self.spawn_mob_for( + "minecraft:slime", + [feet.x, feet.y + 0.5, feet.z], + false, + true, + ) && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) + { + horizon_client::mobs::cube::set_size(m, 2); + } + } + } + if effects.contains(&"weaving") && (player || self.ui.rules.bool("mob_griefing")) { + self.spawn_cobwebs_around([ + feet.x.floor() as i32, + feet.y.floor() as i32, + feet.z.floor() as i32, + ]); + } + if effects.contains(&"wind_charged") { + // A burst centred at half the height, radius 3 to 5. + let center = [feet.x, feet.y + bounds.size().y / 2.0, feet.z]; + let radius = 3.0 + self.world.random.next_float() * 2.0; + let _ = self.wind_burst(center, radius, 1.0, false, false); + } + } + /// `WeavingMobEffect.spawnCobwebsRandomlyAround`: two or three cobwebs in + /// free spaces with a solid floor, picked among 15 random blocks within one + /// block of `pos`. + fn spawn_cobwebs_around(&mut self, pos: [i32; 3]) { + let wanted = 2 + self.world.random.next_int_bound(2).unwrap_or(0) as usize; + let mut chosen: Vec<[i32; 3]> = Vec::new(); + for _ in 0..15 { + let r = &mut self.world.random; + let at = [ + pos[0] - 1 + r.next_int_bound(3).unwrap_or(0), + pos[1] - 1 + r.next_int_bound(3).unwrap_or(0), + pos[2] - 1 + r.next_int_bound(3).unwrap_or(0), + ]; + let facts = self.res.facts(); + let here = facts.get(self.world.block(at[0], at[1], at[2])); + let below = facts.get(self.world.block(at[0], at[1] - 1, at[2])); + if !chosen.contains(&at) + && here.replaceable + && below.sturdy_full & (1 << Direction::Up as u8) != 0 + { + chosen.push(at); + if chosen.len() >= wanted { + break; + } + } + } + for at in chosen { + if self.set_state_named(at, "minecraft:cobweb", &[]).is_ok() { + self.level_event_at(3018, at, 0); + } + } + } + /// `InfestedMobEffect.onMobHurt` for the player: from half its height up, + /// along where it looks. + pub(super) fn player_infested(&mut self) { + if let Some(p) = self.player.as_ref() { + let at = [ + p.position.x, + p.position.y + f64::from(p.dimensions.height) / 2.0, + p.position.z, + ]; + let look = super::view_vector(self.yaw, self.pitch); + self.infested_hurt(at, look); + } + } + /// `InfestedMobEffect.onMobHurt`: a 10% chance of one or two silverfish at + /// `at` (half the bearer's height up), thrown along its look direction. + pub(super) fn infested_hurt(&mut self, at: [f64; 3], look: [f64; 3]) { + if self.world.random.next_float() > 0.1 { + return; + } + let count = 1 + self.world.random.next_int_bound(2).unwrap_or(0); + for _ in 0..count { + // Mth.randomBetween(-PI / 2, PI / 2), then the look direction + // scaled by (0.3, 0.45, 0.3) and turned about the y axis. + let half = std::f32::consts::FRAC_PI_2; + let angle = self.world.random.next_float() * (2.0 * half) - half; + let (sin, cos) = angle.sin_cos(); + let (x, z) = (look[0] * 0.3, look[2] * 0.3); + let velocity = Vec3::new( + f64::from(x as f32 * cos + z as f32 * sin), + look[1] * 0.3 * 1.5, + f64::from(-x as f32 * sin + z as f32 * cos), + ); + if let Some(id) = self.spawn_mob_for("minecraft:silverfish", at, false, true) + && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) + { + m.velocity = velocity; + } + self.audio + .play("minecraft:entity.silverfish.hurt", Some(at), 1.0, 1.0); + } + } /// A splash potion, lingering potion or experience bottle in flight (the /// player's throws and dispensers both end up here). pub(super) fn launch_thrown(&mut self, stack: ItemStack, position: Vec3, velocity: Vec3) { @@ -376,8 +509,27 @@ impl Game<'_> { return; }; if player.health.dead_or_dying() { - // LivingEntity.die → removeAllEffects. + // LivingEntity.die → removeAllEffects. Vanilla runs the effects + // that act on death (`onMobRemoved`) when the dead player is + // removed, up to 20 ticks later; here it is as the effects go. + let w = f64::from(player.dimensions.width) / 2.0; + let bounds = Aabb::new( + Vec3::new( + player.position.x - w, + player.position.y, + player.position.z - w, + ), + Vec3::new( + player.position.x + w, + player.position.y + f64::from(player.dimensions.height), + player.position.z + w, + ), + ); + let ids: Vec<&'static str> = self.potions.effects.list.iter().map(|e| e.id).collect(); self.potions.effects.clear(); + if !ids.is_empty() { + self.effects_on_death(&ids, bounds, true, None); + } } // The omens act from inside the effect tick (BadOmenMobEffect, // RaidOmenMobEffect). diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 1b5dddbe7..e4132e799 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -896,6 +896,10 @@ pub enum MobEvent { slot: usize, stack: Option, }, + /// `InfestedMobEffect.onMobHurt`: the mob was hurt while infested. + Infested { + mob: u32, + }, /// `OfferFlowerGoal.stop`: the item goes to the target's antenna (saddle) /// slot if it is empty, as a guaranteed drop. Gift { @@ -1789,6 +1793,9 @@ impl Mob { } } } + if self.has_effect("minecraft:infested") { + self.outbox.push(MobEvent::Infested { mob: self.id }); + } true } /// LivingEntity.knockback(power, xd, zd) towards the negative direction. From 7102727197458311255f1c8ccf9f903cdb611d50 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:24:26 +0100 Subject: [PATCH 023/105] Play the container close sound when a server-thread player closes it --- crates/horizon-client/src/game.rs | 21 +------------------ crates/horizon-client/src/game/lan_actions.rs | 5 ++++- crates/horizon-client/src/game/storage.rs | 21 +++++++++++++++++++ 3 files changed, 26 insertions(+), 21 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 147aefe36..d0e060c13 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -5627,26 +5627,7 @@ impl Game<'_> { Some(horizon_client::mobs::Who::Player), None, ); - let name = self - .res - .facts() - .get(self.world.block(key.0, key.1, key.2)) - .name - .clone(); - let sound = if storage::is_shulker_box(&name) { - Some("minecraft:block.shulker_box.close") - } else if &*name == "minecraft:ender_chest" { - Some("minecraft:block.ender_chest.close") - } else if name.contains("chest") { - Some("minecraft:block.chest.close") - } else if &*name == "minecraft:barrel" { - Some("minecraft:block.barrel.close") - } else { - None - }; - if let Some(sound) = sound { - self.container_sound(sound, key, &name); - } + self.container_close_sound(key); self.world.modified.insert((key.0 >> 4, key.2 >> 4)); } self.close_ender_chest(); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 0ad14bbcc..41ada973c 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -854,13 +854,16 @@ impl Game<'_> { } /// The guest's open container is closing (`AbstractContainerMenu.removed`): - /// it no longer counts among the openers of the lid. + /// it no longer counts among the openers of the lid, and the lid's close + /// sound is played for everyone around (`ChestBlockEntity.onClose`, a + /// `playSound` with no player), the guest included. pub(super) fn guest_container_closed(&mut self, host: &mut LanHost, conn: u32) { if let Some(g) = host.hub.guest(conn) && let Some(pos) = g.menu.as_ref().and_then(|m| m.pos) && !g.spectator() { self.container_openers_changed(pos, false); + self.container_close_sound(pos); } } diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs index 3456c4ab0..d733f1cca 100644 --- a/crates/horizon-client/src/game/storage.rs +++ b/crates/horizon-client/src/game/storage.rs @@ -142,6 +142,27 @@ impl Game<'_> { let pitch = self.world.random.next_float() * 0.1 + 0.9; self.audio.play(sound, Some(at), 0.5, pitch); } + /// The close sound of the container block at `key`, if it has one. + pub(super) fn container_close_sound(&mut self, key: (i32, i32, i32)) { + let name = self + .res + .facts() + .get(self.world.block(key.0, key.1, key.2)) + .name + .clone(); + let sound = if is_shulker_box(&name) { + "minecraft:block.shulker_box.close" + } else if &*name == "minecraft:ender_chest" { + "minecraft:block.ender_chest.close" + } else if name.contains("chest") { + "minecraft:block.chest.close" + } else if &*name == "minecraft:barrel" { + "minecraft:block.barrel.close" + } else { + return; + }; + self.container_sound(sound, key, &name); + } /// The other half of a double chest at `key`, for neighbour updates. pub(super) fn chest_other_half(&self, key: (i32, i32, i32)) -> Option<(i32, i32, i32)> { self.chest_partner(key).map(|p| p.0) From e71d4281acce0741804c2120bbcc6ed57dbe66d2 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:04:35 +0100 Subject: [PATCH 024/105] Spawn a baby when a spawn egg is used on its own mob kind Mob.checkAndHandleImportantInteractions: a spawn egg of the clicked mob's kind spawns a baby at the mob's position (SpawnEggItem.spawnOffspringFromSpawnEgg), inheriting the parent's variant, and uses one egg outside creative. Fixes #2269. --- crates/horizon-client/src/game/creatures.rs | 40 +++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 194256040..3ebf9ef49 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2447,6 +2447,10 @@ impl Game<'_> { if self.name_mob(index) { return Ok(true); } + if self.spawn_egg_offspring(index) { + self.swing_arm(); + return Ok(true); + } { let item = self.held().map(|h| h.item.to_string()).unwrap_or_default(); if self.interact_leash(index, &item) { @@ -2953,6 +2957,42 @@ impl Game<'_> { } Ok(true) } + /// `Mob.checkAndHandleImportantInteractions` with a spawn egg of mob + /// `index`'s own kind (`SpawnEggItem.spawnOffspringFromSpawnEgg`): a baby + /// at the mob's feet, taking the parent's variant as `getBreedOffspring` + /// does, and one egg used. False (PASS) when the mob has no baby form. + fn spawn_egg_offspring(&mut self, index: usize) -> bool { + let Some(stack) = self.held().cloned() else { + return false; + }; + let parent = &self.mobs[index]; + if !parent.alive() + || stack.item.strip_suffix("_spawn_egg") != Some(parent.kind.id.as_str()) + || !horizon_client::mobs::drops::can_be_baby(parent.species()) + { + return false; + } + let (kind, at) = ( + parent.kind.id.clone(), + [parent.position.x, parent.position.y, parent.position.z], + ); + let (species, variant, color) = + (parent.species(), parent.extra.variant, parent.extra.color); + let target = self.mob_entity(&self.mobs[index]); + let Some(id) = self.spawn_mob(&kind, at, true) else { + return false; + }; + if let Some(child) = self.mobs.iter_mut().find(|m| m.id == id) { + horizon_client::mobs::finalize::set_baby(child, true); + child.extra.variant = variant; + if species == Species::Sheep { + child.extra.color = color; + } + } + self.trigger_item_entity("minecraft:player_interacted_with_entity", &stack, &target); + self.consume_held(); + true + } fn use_spawn_egg(&mut self, stack: &ItemStack) -> Result { let Some(hit) = self.pick() else { return Ok(false); From af6faa88e51f6d7632191124b6e49f5a9ceaff8f Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:06:30 +0100 Subject: [PATCH 025/105] Report the hook's open-water flag to the fishing_rod_hooked trigger --- crates/horizon-client/src/game/fishing.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs index 33d93fb82..a2c3dcf1d 100644 --- a/crates/horizon-client/src/game/fishing.rs +++ b/crates/horizon-client/src/game/fishing.rs @@ -241,6 +241,7 @@ impl Game<'_> { kind: "minecraft:fishing_bobber".into(), position: [hook.position.x, hook.position.y, hook.position.z], on_ground: hook.on_ground, + fishing_open_water: Some(hook.open_water), ..Default::default() }; self.trigger_fishing_rod_hooked(rod, &bobber, &caught); From af49fd7dc3b7248f47b7f2cf066df183abee353e Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:07:14 +0100 Subject: [PATCH 026/105] Use a collision-shape raycast for the spyglass line-of-sight check --- .../horizon-client/src/game/advancements.rs | 20 +++++++------------ 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 67615b628..5908926a1 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -9,6 +9,7 @@ use horizon_client::{ text::{self, Style, Text}, toasts::Slide, }; +use horizon_core::geometry::Vec3; use serde_json::Value; use std::{ collections::{BTreeMap, BTreeSet, VecDeque}, @@ -751,19 +752,12 @@ impl Game<'_> { .filter(|m| m.alive()) .filter_map(|m| Some((m, super::ray_box(eye, dir, 100.0, m.bounds())?))) .min_by(|a, b| a.1.total_cmp(&b.1))?; - // Eye to the target's centre, two samples per block. - let to = m.center(); - let reach = (0..3).map(|i| (to[i] - eye[i]).powi(2)).sum::().sqrt(); - let steps = (reach * 2.0).ceil().max(1.0) as i32; - let clear = (1..steps).all(|i| { - let f = f64::from(i) / f64::from(steps); - let p = [0, 1, 2].map(|a| (eye[a] + (to[a] - eye[a]) * f).floor() as i32); - !self - .res - .facts() - .get(self.world.block(p[0], p[1], p[2])) - .full_collision - }); + // `LivingEntity.hasLineOfSight`: eye to the target's eye height, + // `ClipContext.Block.COLLIDER`, no fluids, within 128 blocks. + let from = Vec3::new(eye[0], eye[1], eye[2]); + let to = Vec3::new(m.position.x, m.eye_y(), m.position.z); + let world = self.mob_world_base(&[]); + let clear = to.distance(from) <= 128.0 && world.clear_between(from, to, false); clear.then(|| self.mob_entity(m)) } /// A player condition plus one item (`item` key). From 47654b62a3b3f64ff163590ec1c29d16c341d50d Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:24:26 +0100 Subject: [PATCH 027/105] Save the armadillo scute timer and reset it only when a scute can drop --- .../examples/probe/mob_ai_probe.rs | 1 + crates/horizon-client/src/entity_nbt.rs | 10 +++++++ crates/horizon-client/src/game/creatures.rs | 29 +++++++++---------- crates/horizon-client/src/mobs.rs | 2 ++ crates/horizon-client/src/mobs/ai.rs | 27 ++++++++--------- 5 files changed, 41 insertions(+), 28 deletions(-) diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index ecdf02901..81c739464 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -1097,6 +1097,7 @@ pub fn main() -> horizon_client::Result<()> { block_tags: &items.block_tags, biomes: &biomes, mob_griefing: true, + mob_drops: true, difficulty: LocalDifficulty::new(s.difficulty, world.day_time, 0, 0.0), end: false, world_seed: 0, diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 00576ea02..91ede9110 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -445,6 +445,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.insert("anger".into(), Tag::compound(Vec::<(&str, Tag)>::new())); } } + // Armadillo.addAdditionalSaveData: the time left to the next scute. + "minecraft:armadillo" => { + map.insert("scute_time".into(), Tag::Int(m.extra.egg_time)); + } "minecraft:ravager" => { map.insert("AttackTick".into(), Tag::Int(m.extra.counter)); map.insert("StunTick".into(), Tag::Int(m.extra.counter2)); @@ -876,6 +880,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - st.vibration = crate::sculk::Data::from_nbt(listener); } } + // Armadillo.readAdditionalSaveData: keeps the constructor's time when absent. + if m.species() == crate::mobs::Species::Armadillo + && let Some(t) = number(tag.get("scute_time")) + { + m.extra.egg_time = t as i32; + } if m.species() == crate::mobs::Species::Ravager { m.extra.counter = number(tag.get("AttackTick")).unwrap_or(0) as i32; m.extra.counter2 = number(tag.get("StunTick")).unwrap_or(0) as i32; diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 9a78bc2e5..56215fe9c 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -416,6 +416,7 @@ impl Game<'_> { block_tags: &self.res.items().block_tags, biomes: self.res.biomes(), mob_griefing: self.ui.rules.bool("mob_griefing"), + mob_drops: self.ui.rules.bool("mob_drops"), end: self.dim == Dim::End, world_seed: self.level.seed, sea_level: if self.dim == Dim::Nether { 32 } else { 63 }, @@ -1222,22 +1223,20 @@ impl Game<'_> { } } MobEvent::ShedScute { mob, at, pitch } => { - // shouldDropLoot: the `mob_drops` rule. - if self.ui.rules.bool("mob_drops") { - let table = "minecraft:gameplay/armadillo_shed"; - let drops = self.sequence_loot(table, table, None); - for d in drops { - self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d); - } - self.audio.play( - "minecraft:entity.armadillo.scute_drop", - Some(at), - 1.0, - pitch, - ); - let ctx = self.who_context(Some(Who::Mob(mob)), None); - self.post_game_event("minecraft:entity_place", at, ctx); + // The mob already checked `shouldDropLoot` (a baby, `mob_drops`). + let table = "minecraft:gameplay/armadillo_shed"; + let drops = self.sequence_loot(table, table, None); + for d in drops { + self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d); } + self.audio.play( + "minecraft:entity.armadillo.scute_drop", + Some(at), + 1.0, + pitch, + ); + let ctx = self.who_context(Some(Who::Mob(mob)), None); + self.post_game_event("minecraft:entity_place", at, ctx); } MobEvent::GiftLoot { table, at } => { let drops = diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 315bfdce2..c276c1e66 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1501,6 +1501,8 @@ pub struct MobWorld<'a> { pub biomes: &'a crate::biome::Biomes, /// The `mob_griefing` game rule. pub mob_griefing: bool, + /// The `mob_drops` game rule (`shouldDropLoot`). + pub mob_drops: bool, /// `getCurrentDifficultyAt` near the player. pub difficulty: spawning::LocalDifficulty, /// The End (its dimension type's monster spawn light rules). diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 8259ddccb..90337e416 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -938,26 +938,27 @@ fn server_ai_step( fn next_scute_time(m: &mut Mob) -> i32 { m.random.next_int_bound(20 * 60 * 5).unwrap_or(0) + 20 * 60 * 5 } -/// `Armadillo.customServerAiStep`: the scute timer. A baby only resets it -/// (`shouldDropLoot`); the game checks the `mob_drops` rule. -fn armadillo_server_ai_step(m: &mut Mob, events: &mut Vec) { +/// `Armadillo.customServerAiStep`: the scute timer keeps counting down and is +/// only reset once `shouldDropLoot` (not a baby, `mob_drops` on) lets it shed. +fn armadillo_server_ai_step(m: &mut Mob, mob_drops: bool, events: &mut Vec) { + if !m.alive() { + return; + } m.extra.egg_time -= 1; - if m.alive() && m.extra.egg_time <= 0 { - if !m.is_baby() { - let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0; - events.push(MobEvent::ShedScute { - mob: m.id, - at: [m.position.x, m.position.y, m.position.z], - pitch, - }); - } + if m.extra.egg_time <= 0 && !m.is_baby() && mob_drops { + let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0; + events.push(MobEvent::ShedScute { + mob: m.id, + at: [m.position.x, m.position.y, m.position.z], + pitch, + }); m.extra.egg_time = next_scute_time(m); } } fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { match m.species() { Species::Rabbit => super::rabbit::server_ai_step(m), - Species::Armadillo => armadillo_server_ai_step(m, cx.events), + Species::Armadillo => armadillo_server_ai_step(m, cx.w.mob_drops, cx.events), Species::Sheep => {} Species::Zombie | Species::Husk From 18f4dd92aea541b501a154f341b36135210ac4d1 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:24:42 +0100 Subject: [PATCH 028/105] Play container open and close sounds only when the opener count crosses zero --- crates/horizon-client/src/game.rs | 33 ++++++------------ .../src/game/block_entity_anims.rs | 34 +++++++++++-------- crates/horizon-client/src/game/lan_actions.rs | 7 ++-- crates/horizon-client/src/game/storage.rs | 30 ++++++++++++---- 4 files changed, 58 insertions(+), 46 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index d0e060c13..73dcfc455 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3019,15 +3019,9 @@ impl Game<'_> { self.craft_table = Some(pos); } else if &*name == "minecraft:ender_chest" { self.open_ender_chest(key); - self.container_opener_event(key, true); - let at = [ - f64::from(key.0) + 0.5, - f64::from(key.1) + 0.5, - f64::from(key.2) + 0.5, - ]; - let pitch = self.world.random.next_float() * 0.1 + 0.9; - self.audio - .play("minecraft:block.ender_chest.open", Some(at), 0.5, pitch); + if self.container_opener_event(key, true) { + self.container_edge_sound(key, true); + } } else if &*name == "minecraft:beacon" && self.open_station(pos, &name) { self.world.block_entities.get_or_insert_with(key, || { BlockEntity::for_block(&name).unwrap_or(BlockEntity::Chest(Vec::new())) @@ -3043,7 +3037,7 @@ impl Game<'_> { ]; self.resolve_container_maps(key, centre); self.container = Some(key); - self.container_opener_event(key, true); + let first = self.container_opener_event(key, true); self.post_block_game_event( "minecraft:container_open", [key.0, key.1, key.2], @@ -3067,17 +3061,8 @@ impl Game<'_> { if self.guarded_by_piglins(&name) { self.anger_piglins(true); } - let sound = if storage::is_shulker_box(&name) { - Some("minecraft:block.shulker_box.open") - } else if name.contains("chest") { - Some("minecraft:block.chest.open") - } else if &*name == "minecraft:barrel" { - Some("minecraft:block.barrel.open") - } else { - None - }; - if let Some(sound) = sound { - self.container_sound(sound, key, &name); + if first { + self.container_edge_sound(key, true); } } else if self.open_station(pos, &name) { // Workstation menus: game/stations.rs. @@ -5620,14 +5605,16 @@ impl Game<'_> { if let Some(key) = self.container.take() { // A cart's or chest boat's items go back to it. self.close_cart_container(key); - self.container_opener_event(key, false); + let last = self.container_opener_event(key, false); self.post_block_game_event( "minecraft:container_close", [key.0, key.1, key.2], Some(horizon_client::mobs::Who::Player), None, ); - self.container_close_sound(key); + if last { + self.container_edge_sound(key, false); + } self.world.modified.insert((key.0 >> 4, key.2 >> 4)); } self.close_ender_chest(); diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs index 3d452596e..4d48b0874 100644 --- a/crates/horizon-client/src/game/block_entity_anims.rs +++ b/crates/horizon-client/src/game/block_entity_anims.rs @@ -71,23 +71,24 @@ impl Game<'_> { /// A player opened (`open`) or closed the container at `key`: the opener /// count block event (`ContainerOpenersCounter` / `ShulkerBoxBlockEntity` /// `startOpen`/`stopOpen`) for chests, ender chests and shulker boxes, - /// on both halves of a double chest (`CompoundContainer`). - pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) { + /// on both halves of a double chest (`CompoundContainer`). True when the + /// count went from 0 to 1 or back to 0: the only moments the container + /// plays its open or close sound. + pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) -> bool { // Spectators never count as openers. - if !self.spectator() { - self.container_openers_changed(key, open); - } + !self.spectator() && self.container_openers_changed(key, open) } /// `container_opener_event` for a player who is not a spectator (a guest). - pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) { + pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool { let pos = [key.0, key.1, key.2]; let state = self.world.block(pos[0], pos[1], pos[2]).0; match self.be_anims.ticker(state) { Some(Ticker::Lid) => { - self.lid_openers_changed(key, open); + let edge = self.lid_openers_changed(key, open); if let Some(other) = self.chest_other_half(key) { self.lid_openers_changed(other, open); } + edge } _ if self .res @@ -97,26 +98,27 @@ impl Game<'_> { .as_ref() == "minecraft:barrel" => { - self.barrel_openers_changed(key, open); + self.barrel_openers_changed(key, open) } Some(Ticker::Shulker { .. }) => { let shulker = self.be_anims.shulkers.entry(pos).or_default(); - let (count, _) = if open { + let (count, edge) = if open { shulker.start_open() } else { shulker.stop_open() }; self.block_entity_event(pos, 1, count); self.lan_block_event(pos, 1, count); + edge } - _ => {} + _ => false, } } /// `ContainerOpenersCounter.incrementOpeners` / `decrementOpeners` of the /// chest at `key` (the host and the guests are counted), then /// `ChestBlockEntity.signalOpenCount`: block event 1 with the count, here - /// and for the guests. - fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) { + /// and for the guests. True when the count crossed zero. + fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool { let (before, count) = self.count_opener(key, open); let pos = [key.0, key.1, key.2]; self.block_entity_event(pos, 1, count); @@ -134,12 +136,15 @@ impl Game<'_> { b.update_neighbors_at(level, ticks, p.offset(0, -1, 0), block); }); } + (before == 0) != (count == 0) } /// `BarrelBlockEntity.openersCounter`: the first opener opens the barrel /// (`open=true`), the last one to leave closes it (`updateBlockState`). - fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) { + /// True when the count crossed zero. + fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool { let (before, count) = self.count_opener(key, open); - if (before == 0) != (count == 0) { + let edge = (before == 0) != (count == 0); + if edge { self.set_bool_prop( key, "open", @@ -147,6 +152,7 @@ impl Game<'_> { horizon_world::level::flags::UPDATE_ALL, ); } + edge } /// One opener more (`open`) or less at `key`: the count before and after /// (`ContainerOpenersCounter.incrementOpeners` / `decrementOpeners`). diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 41ada973c..796e5f89c 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -856,14 +856,15 @@ impl Game<'_> { /// The guest's open container is closing (`AbstractContainerMenu.removed`): /// it no longer counts among the openers of the lid, and the lid's close /// sound is played for everyone around (`ChestBlockEntity.onClose`, a - /// `playSound` with no player), the guest included. + /// `playSound` with no player), the guest included, once the last opener + /// has left. pub(super) fn guest_container_closed(&mut self, host: &mut LanHost, conn: u32) { if let Some(g) = host.hub.guest(conn) && let Some(pos) = g.menu.as_ref().and_then(|m| m.pos) && !g.spectator() + && self.container_openers_changed(pos, false) { - self.container_openers_changed(pos, false); - self.container_close_sound(pos); + self.container_edge_sound(pos, false); } } diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs index d733f1cca..7db0ce82c 100644 --- a/crates/horizon-client/src/game/storage.rs +++ b/crates/horizon-client/src/game/storage.rs @@ -142,8 +142,10 @@ impl Game<'_> { let pitch = self.world.random.next_float() * 0.1 + 0.9; self.audio.play(sound, Some(at), 0.5, pitch); } - /// The close sound of the container block at `key`, if it has one. - pub(super) fn container_close_sound(&mut self, key: (i32, i32, i32)) { + /// The open or close sound of the container block at `key`, if it has one. + /// Callers play it only when the opener count crosses zero + /// (`ContainerOpenersCounter.onOpen` / `onClose`). + pub(super) fn container_edge_sound(&mut self, key: (i32, i32, i32), open: bool) { let name = self .res .facts() @@ -151,13 +153,29 @@ impl Game<'_> { .name .clone(); let sound = if is_shulker_box(&name) { - "minecraft:block.shulker_box.close" + if open { + "minecraft:block.shulker_box.open" + } else { + "minecraft:block.shulker_box.close" + } } else if &*name == "minecraft:ender_chest" { - "minecraft:block.ender_chest.close" + if open { + "minecraft:block.ender_chest.open" + } else { + "minecraft:block.ender_chest.close" + } } else if name.contains("chest") { - "minecraft:block.chest.close" + if open { + "minecraft:block.chest.open" + } else { + "minecraft:block.chest.close" + } } else if &*name == "minecraft:barrel" { - "minecraft:block.barrel.close" + if open { + "minecraft:block.barrel.open" + } else { + "minecraft:block.barrel.close" + } } else { return; }; From f364c4f9c6fdb28e114ef5b7a84d1f62e5a988d5 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:28:28 +0100 Subject: [PATCH 029/105] Leave wandering traders out of the spawn egg baby check --- crates/horizon-client/src/game/creatures.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 3ebf9ef49..420509900 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2969,6 +2969,9 @@ impl Game<'_> { if !parent.alive() || stack.item.strip_suffix("_spawn_egg") != Some(parent.kind.id.as_str()) || !horizon_client::mobs::drops::can_be_baby(parent.species()) + // WanderingTrader.getBreedOffspring returns null: no offspring, the + // click carries on to trading. + || parent.species() == Species::WanderingTrader { return false; } From c50557ea0ba2abb0c1476aa65faf12ee090478c7 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:29:05 +0100 Subject: [PATCH 030/105] Credit the projectile owner for explosion damage to mobs --- crates/horizon-client/src/game/combat.rs | 3 +++ crates/horizon-client/src/game/creatures.rs | 5 ++++- crates/horizon-client/src/game/explosion.rs | 6 +++++- crates/horizon-client/src/game/wither.rs | 5 ++++- 4 files changed, 16 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index 106e0e1a1..3d0c34ff2 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -31,6 +31,9 @@ pub(super) struct CombatTracker { /// The mob exploding now (`ServerExplosion.source`): its team's friendly /// fire decides whom the blast may hurt. pub(super) explosion_source: Option, + /// The mob that owns the projectile exploding now (`getIndirectSourceEntity`): + /// the mobs the blast hurts record it as their attacker. + pub(super) explosion_owner: Option, /// The player's fall distance before this tick's movement (as of the /// end of the last one). fall_before: f64, diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index cd211ec48..48e029381 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2283,7 +2283,10 @@ impl Game<'_> { if let Some(owner) = self.combat.projectile_owner { self.note_attacker("minecraft:explosion", owner); } - self.explode(atp, *power as f32)?; + self.combat.explosion_owner = self.combat.projectile_owner; + let result = self.explode(atp, *power as f32); + self.combat.explosion_owner = None; + result?; } ( ProjectileKind::Potion { diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs index 6ecba3a54..675203517 100644 --- a/crates/horizon-client/src/game/explosion.rs +++ b/crates/horizon-client/src/game/explosion.rs @@ -393,7 +393,11 @@ impl Game<'_> { ); let source = horizon_client::mobs::Damage { kind: horizon_client::mobs::DamageKind::Explosion, - attacker: None, + attacker: self + .combat + .explosion_owner + .filter(|&o| o != m.id) + .map(horizon_client::mobs::Who::Mob), from: Some(center), }; if hurtable && !m.damage(damage(dist, exposure), source) { diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs index 101818f68..996f55d1c 100644 --- a/crates/horizon-client/src/game/wither.rs +++ b/crates/horizon-client/src/game/wither.rs @@ -172,7 +172,10 @@ impl Game<'_> { if let Some(id) = owner { self.note_attacker("minecraft:explosion", id); } - self.explode(at, 1.0) + self.combat.explosion_owner = owner; + let result = self.explode(at, 1.0); + self.combat.explosion_owner = None; + result } } /// Wither skulls drawn as the skull model, blue when dangerous. From b28108128d23ac61783b160a922f00b320133d98 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:33:08 +0100 Subject: [PATCH 031/105] Keep a hopper minecart's items in sync with a leftover menu copy --- crates/horizon-client/src/game/machines.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index 55e47aa67..0562af8cd 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -777,7 +777,15 @@ impl Game<'_> { [hi.x + 0.25, hi.y, hi.z + 0.25], ); } - if !open && let Some(BlockEntity::Chest(items)) = self.world.block_entities.remove(&key) { + // The cart's own items stay the one source of truth: a menu copy that + // is still around (open, or left by a guest's close) gets the pulled + // items back into `cart.items`, so reopening never restores a stale copy. + let slots = if open { + self.world.block_entities.get(&key).cloned() + } else { + self.world.block_entities.remove(&key) + }; + if let Some(BlockEntity::Chest(items)) = slots { cart.items = items; } } From 3842d851d8f088a138e5a09bd42cb054ac88ffa9 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:38:07 +0100 Subject: [PATCH 032/105] Match the brewed_potion trigger's potion condition as a PotionsPredicate --- crates/horizon-client/src/advancements.rs | 45 +++++++++++++++++++ .../horizon-client/src/game/advancements.rs | 5 +-- 2 files changed, 46 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs index 6706532b7..531116ab6 100644 --- a/crates/horizon-client/src/advancements.rs +++ b/crates/horizon-client/src/advancements.rs @@ -473,6 +473,51 @@ pub fn id_matches(v: &Value, registry: &str, id: &str, w: &dyn World) -> bool { _ => false, } } +/// `PotionsPredicate`: the potion in a `HolderSet`, plus a `CollectionPredicate` +/// over the potion's effects (`contains`, `count`, `size`). +pub fn potions(v: &Value, potion: Option<&str>, w: &dyn World) -> bool { + if v.is_null() { + return true; + } + if !v["potions"].is_null() && !potion.is_some_and(|p| id_matches(&v["potions"], "potion", p, w)) + { + return false; + } + let c = &v["effects"]; + if c.is_null() { + return true; + } + let effects: Vec<(String, i32, i32)> = potion + .and_then(crate::brewing::potion) + .map(|d| { + d.effects + .iter() + .map(|(id, dur, amp)| (format!("minecraft:{id}"), *amp, *dur)) + .collect() + }) + .unwrap_or_default(); + // `MobEffectsPredicate.test`: the one listed effect, amplifier and duration. + let test = |pred: &Value, e: &(String, i32, i32)| { + pred.as_object().is_some_and(|m| { + m.get(&e.0).is_some_and(|want| { + range_i(&want["amplifier"], i64::from(e.1)) + && range_i(&want["duration"], i64::from(e.2)) + && want["ambient"].as_bool().is_none_or(|b| !b) + && want["visible"].as_bool().is_none_or(|b| b) + }) + }) + }; + c["contains"] + .as_array() + .is_none_or(|l| l.iter().all(|p| effects.iter().any(|e| test(p, e)))) + && c["count"].as_array().is_none_or(|l| { + l.iter().all(|entry| { + let n = effects.iter().filter(|e| test(&entry["test"], e)).count(); + range_i(&entry["count"], n as i64) + }) + }) + && range_i(&c["size"], effects.len() as i64) +} /// `ItemPredicate`. pub fn item(v: &Value, it: &ItemView, w: &dyn World) -> bool { if v.is_null() { diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 53fa282d4..a58066751 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -721,10 +721,7 @@ impl Game<'_> { block_pos: None, }; adv::conditions(&c["player"], &pctx, w) - && (c["potion"].is_null() - || potion - .as_deref() - .is_some_and(|p| adv::id_matches(&c["potion"], "potion", p, w))) + && adv::potions(&c["potion"], potion.as_deref(), w) }); } /// `EnterBlockTrigger`: the block, its state properties and the player. From 49ad61035b285c0d24bca0cde1027fd3bf60b41e Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:47:11 +0100 Subject: [PATCH 033/105] Count shield damage only for accepted hits and skip kills saved by a totem --- crates/horizon-client/src/game/combat.rs | 5 ++++- crates/horizon-client/src/game/lan_pvp.rs | 4 +++- crates/horizon-client/src/game/shield.rs | 7 ------- 3 files changed, 7 insertions(+), 9 deletions(-) diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index 197c77f17..fee887f97 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -74,11 +74,14 @@ impl Game<'_> { for e in events { let (name, amount) = match e { // LivingEntity.getDamageAfterMagicAbsorb (Resistance) and - // Player.actuallyHurt (absorption hearts), in tenths. + // Player.actuallyHurt (absorption hearts) and + // LivingEntity.hurtServer (the shield, only for an accepted + // hit), in tenths. MotionEvent::Health(HealthEvent::Statistic { name, amount }) => { match *name { "resisted" => self.stats.custom("damage_resisted", *amount), "absorbed" => self.stats.custom("damage_absorbed", *amount), + "blocked" => self.stats.custom("damage_blocked_by_shield", *amount), _ => {} } continue; diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index a2ff13444..276a33c83 100644 --- a/crates/horizon-client/src/game/lan_pvp.rs +++ b/crates/horizon-client/src/game/lan_pvp.rs @@ -256,10 +256,12 @@ impl Game<'_> { // ServerPlayer.awardKillScore: the blow that kills a player. if hurt { let died = match victim { + // A totem that fired is applied on the next tick_totem, so the + // host is still at zero health but is not dying. Victim::Host => self .player .as_ref() - .is_some_and(|p| p.health.dead_or_dying()), + .is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used), Victim::Guest(conn) => host .hub .guest(conn) diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs index f4642f272..c4f7f98d1 100644 --- a/crates/horizon-client/src/game/shield.rs +++ b/crates/horizon-client/src/game/shield.rs @@ -121,13 +121,6 @@ impl Game<'_> { attacker: Option, projectile: bool, ) { - // LivingEntity.hurtServer: the damage the shield took, in tenths. - if outcome.blocked > 0.0 { - self.stats.custom( - "damage_blocked_by_shield", - (outcome.blocked * 10.0).round() as i32, - ); - } let Some((slot, _)) = self.using else { return }; let Some(stack) = self.stack_in(slot).cloned() else { return; From 36ef05b0b9470051b8a5e9e01ce0ba4811a30e0a Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:51:22 +0100 Subject: [PATCH 034/105] Keep infinite mob effects through the effect tick --- crates/horizon-client/src/mobs/ai.rs | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 8335cb745..68d5caee5 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -1455,25 +1455,31 @@ fn tick_effects(m: &mut Mob) { let mut effects = std::mem::take(&mut m.extra.effects); for (effect, ticks, amp) in &mut effects { let interval = |base: i32| (base >> (*amp).max(0)).max(1); + // MobEffectInstance.tickServer: an infinite (-1) effect times its + // ticks by the mob's tickCount and never counts down. + let infinite = *ticks == -1; + let count = if infinite { m.age as i32 } else { *ticks }; match *effect { "minecraft:poison" - if *ticks % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 => + if count % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 => { m.damage(1.0, Damage::of(DamageKind::Magic)); } - "minecraft:wither" if *ticks % interval(40) == 0 => { + "minecraft:wither" if count % interval(40) == 0 => { m.damage(1.0, Damage::of(DamageKind::Magic)); } "minecraft:regeneration" - if *ticks % interval(50) == 0 && !m.kind.flags.undead && m.alive() => + if count % interval(50) == 0 && !m.kind.flags.undead && m.alive() => { m.health = (m.health + 1.0).min(m.attrs.max_health); } _ => {} } - *ticks -= 1; + if !infinite { + *ticks -= 1; + } } - effects.retain(|e| e.1 > 0); + effects.retain(|e| e.1 > 0 || e.1 == -1); m.extra.effects = effects; } From 5d3e9d218dc9a74b712a91d0fe504b0ca532852d Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 17:05:35 +0100 Subject: [PATCH 035/105] Clean copper for a skeleton trap's visual lightning too --- crates/horizon-client/src/game/lightning.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 55e867f87..7daab2ef8 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -221,6 +221,12 @@ impl Game<'_> { if !b.visual_only { self.bolt_fire(b.at, 4); self.strike_rod(b.at); + } + // LightningBolt.tick runs clearCopperOnLightningStrike for + // every server bolt, a skeleton trap's visual one included; + // a client's copy of a server bolt (spawn_remote_bolt) only + // flashes. + if self.remote.is_none() { self.bolt_clear_copper(b.at); } } From ba3b567f54ef63c6c3d00d93b9a81c04e80a411e Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 17:15:29 +0100 Subject: [PATCH 036/105] Predict a full beehive reacting to shears and glass bottles on the client --- crates/horizon-client/src/game/remote.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 857f955da..b0a466d9d 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -4084,6 +4084,16 @@ impl Game<'_> { if self.keys.contains(&KeyCode::ShiftLeft) && hands_full { return (false, DryUse::default()); } + // BeehiveBlock.useItemOn: shears or a glass bottle on a full hive + // (honey level 5) is SUCCESS, so the click ends after UseItemOn and + // no UseItem follows (the server does the harvest, see `use_beehive`). + if held.is_some_and(|s| matches!(&*s.item, "minecraft:shears" | "minecraft:glass_bottle")) + && self + .hive_state(hit.pos) + .is_some_and(|(honey, _)| honey == Some(5)) + { + return (true, DryUse::default()); + } use horizon_core::geometry::Direction; let face = match hit.face { [0, 1, 0] => Direction::Up, From b62095dfcb58d5bd3b77bd40b1cdea70e4766de4 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 17:25:37 +0100 Subject: [PATCH 037/105] Run the trident player_hurt_entity trigger as the thrower --- crates/horizon-client/src/game/trident.rs | 27 ++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs index 04a1be415..74525e69a 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -30,6 +30,8 @@ pub(super) struct ThrownTrident { pub(super) no_physics: bool, returning: u32, creative_only: bool, + /// The guest that threw it (`Projectile.getOwner`); `None` for the host. + guest: Option, } impl ThrownTrident { /// A trident a server sent (`handleAddEntity`): placed and moved by it. @@ -49,6 +51,7 @@ impl ThrownTrident { no_physics: false, returning: 0, creative_only: false, + guest: None, } } /// One tick of a server's client: the previous position, then `step`. @@ -240,11 +243,33 @@ impl Game<'_> { no_physics: false, returning: 0, creative_only: self.creative, + guest: self.lan_acting, }); self.player_projectile_shot(); self.audio .play("minecraft:item.trident.throw", at, 1.0, 1.0); } + /// The thrower's `PLAYER_HURT_ENTITY` for a trident hit: run as the + /// guest that threw it, and not at all once they have left. + fn thrower_hit( + &mut self, + guest: Option, + victim: &horizon_client::advancements::EntityView, + direct: horizon_client::advancements::EntityView, + damage: f32, + ) { + let Some(conn) = guest.filter(|c| self.lan_acting != Some(*c)) else { + self.player_hit(victim, "minecraft:trident", Some(direct), damage); + return; + }; + let Some(mut host) = self.lan.take() else { + return; + }; + self.as_guest(&mut host, conn, |g| { + g.player_hit(victim, "minecraft:trident", Some(direct), damage) + }); + self.lan = Some(host); + } pub(super) fn tick_tridents(&mut self) { let Some(eye) = self.eye_position() else { return; @@ -331,7 +356,7 @@ impl Game<'_> { position: [t.position.x, t.position.y, t.position.z], ..Default::default() }; - self.player_hit(&victim, "minecraft:trident", Some(direct), damage); + self.thrower_hit(t.guest, &victim, direct, damage); } self.audio.play( "minecraft:item.trident.hit", From e50eb7c71f5e5e7e7b27e2d8047f136e90f0ddc7 Mon Sep 17 00:00:00 2001 From: Carlos Nunez Date: Mon, 26 Oct 2026 12:36:46 -0400 Subject: [PATCH 038/105] Count leave_game for every player who leaves, owner included Vanilla's PlayerList.remove awards Stats.LEAVE_GAME to a player before saving them, and PlayerList.removeAll does it for everyone when the server stops. Horizon only counted it in the in-frame path, so on the default server thread the owner never got it, and guests who left or were removed at shutdown did not either. LanHost::award_leave_game counts it once per guest (a guest is saved more than once on the way out) and runs where a guest leaves, when the integrated server stops, and when LAN closes. Part of #2095 (item 4 of the report). The signal handling and the remote-world disconnect are #2116's. Co-Authored-By: Claude Sonnet 5.5 --- crates/horizon-client/src/game/integrated.rs | 2 ++ crates/horizon-client/src/game/lan.rs | 31 +++++++++++++++++++ crates/horizon-client/src/game/lan_actions.rs | 3 ++ 3 files changed, 36 insertions(+) diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index dd1c04e23..6758c7c89 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -408,6 +408,8 @@ impl Game<'_> { s.flags.published.store(0, Ordering::Relaxed); } if let Some(mut host) = self.lan.take() { + // PlayerList.removeAll: the owner and every guest leave the game. + host.award_leave_game_to_all(); for g in &host.hub.guests { self.save_guest(&host, g); } diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 9f468db9f..9226240bd 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -78,6 +78,33 @@ pub(super) struct LanHost { states: lan::entity::States, } +impl LanHost { + /// `PlayerList.remove`: `player.awardStat(Stats.LEAVE_GAME)` before the + /// player is saved. Once per guest, however often they are saved. + pub(super) fn award_leave_game(&mut self, conn: u32) { + if let Some(play) = self.play.get_mut(&conn) + && !play.left_game + { + play.left_game = true; + play.stats.custom("leave_game", 1); + } + } + + /// `PlayerList.removeAll`: every player who joined leaves with the world. + pub(super) fn award_leave_game_to_all(&mut self) { + let conns: Vec = self + .hub + .guests + .iter() + .filter(|g| g.placed) + .map(|g| g.conn) + .collect(); + for conn in conns { + self.award_leave_game(conn); + } + } +} + /// The player who owns an integrated server's world: a guest whose state is /// the world's own player (`players/data/.dat`), as in /// single player. @@ -634,6 +661,7 @@ impl Game<'_> { let Some(mut host) = self.lan.take() else { return; }; + host.award_leave_game_to_all(); for g in &host.hub.guests { self.save_guest(&host, g); } @@ -1016,6 +1044,9 @@ impl Game<'_> { } } self.lan_crafting_left(&mut host, &mut guest); + if guest.placed { + host.award_leave_game(guest.conn); + } self.save_guest(&host, &guest); host.models.remove(&guest.conn); host.play.remove(&guest.conn); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index e1a13881c..dffb0177e 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -74,6 +74,9 @@ pub(super) struct GuestPlay { potions: super::potions::BodyPotions, /// `ServerPlayer.getStats` and the inventory `inventory_changed` last saw. pub(super) stats: super::stats::Stats, + /// `Stats.LEAVE_GAME` is counted: a guest is saved more than once on the + /// way out, the statistic is awarded once (`LanHost::award_leave_game`). + pub(super) left_game: bool, last_inventory: u64, /// `Entity.portalProcess` and `portalCooldown` (game/server_travel.rs). pub(super) portal: horizon_client::nether_portal::PortalState, From e8ae26c27016790f088eb6b4eeb1650ac5dffee5 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:09:01 +0100 Subject: [PATCH 039/105] Carry the exploding mob's kind with its blast and anger bees at guests too --- .../examples/probe/mob_ai_probe.rs | 2 +- crates/horizon-client/src/game/beehives.rs | 34 ++++++++++++++++--- crates/horizon-client/src/game/creatures.rs | 9 +++-- crates/horizon-client/src/mobs.rs | 4 ++- crates/horizon-client/src/mobs/hostile.rs | 1 + crates/horizon-client/src/mobs/sulfur_cube.rs | 1 + crates/horizon-client/src/mobs/wither.rs | 1 + 7 files changed, 41 insertions(+), 11 deletions(-) diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index ecdf02901..2f3cc70da 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -580,7 +580,7 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool { match e { MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0, // ServerExplosion.hurtEntities: within twice the radius every hit does damage. - MobEvent::Explode(at, radius) => { + MobEvent::Explode(at, radius, _) => { let d = Vec3::new(at[0], at[1], at[2]) .distance_squared(p.position) .sqrt(); diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs index 258610f5e..1335377c5 100644 --- a/crates/horizon-client/src/game/beehives.rs +++ b/crates/horizon-client/src/game/beehives.rs @@ -195,7 +195,8 @@ impl Game<'_> { self.anger_nearby_bees(at); } /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down) - /// without a target go for a player in the same box. + /// without a target go for a random player in the same box, the window's + /// own or a guest (`None` is the window's player). pub(super) fn anger_nearby_bees(&mut self, at: [i32; 3]) { let min = Vec3::new( f64::from(at[0]) - 8.0, @@ -203,10 +204,24 @@ impl Game<'_> { f64::from(at[2]) - 8.0, ); let area = Aabb::new(min, Vec3::new(min.x + 17.0, min.y + 13.0, min.z + 17.0)); - if !self + let mut players: Vec> = Vec::new(); + if self .player_view() .is_some_and(|p| p.bounds.intersects(area)) { + players.push(None); + } + if let Some(host) = self.lan.as_ref() { + players.extend( + host.hub + .guests + .iter() + .filter(|g| host.hub.here(g) && g.loaded && !g.dead) + .filter(|g| super::lan_mobs::guest_bounds(g).intersects(area)) + .map(|g| Some(g.conn)), + ); + } + if players.is_empty() { return; } let mut bees: Vec = (0..self.mobs.len()) @@ -219,9 +234,20 @@ impl Game<'_> { .collect(); bees.retain(|&i| self.mobs[i].ai.target.is_none()); for i in bees { - // Util.getRandom over the one player. - let _ = self.world.random.next_int_bound(1); + // Util.getRandom over the players. + let pick = self + .world + .random + .next_int_bound(players.len() as i32) + .unwrap_or(0) as usize; self.mobs[i].ai.target = Some(Who::Player); + // The player a mob sees is its guest binding, else the window's. + if let Some(host) = self.lan.as_mut() { + match players[pick] { + Some(conn) => host.mob_players.insert(self.mobs[i].id, conn), + None => host.mob_players.remove(&self.mobs[i].id), + }; + } } } } diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 6e6610dcc..fd0f5f5de 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -901,7 +901,7 @@ impl Game<'_> { owner, } => self.add_fangs(at, yaw, delay, owner), MobEvent::Shoot(..) => {} - MobEvent::Explode(at, radius) => { + MobEvent::Explode(at, radius, species) => { // The exploding mob causes the damage (Creeper.explodeCreeper). let source_mob = self .mobs @@ -916,10 +916,9 @@ impl Game<'_> { } self.combat.explosion_source = source_mob; // Only a creeper or a wither empties the hives it blows up. - let empties_hives = source_mob - .and_then(|id| self.mobs.iter().find(|m| m.id == id)) - .is_some_and(|m| matches!(m.species(), Species::Creeper | Species::Wither)); - let result = if empties_hives { + // The creeper is already gone from the list, so the event + // carries its kind. + let result = if matches!(species, Species::Creeper | Species::Wither) { self.with_hive_emptying_blast(|g| g.explode(at, radius)) } else { self.explode(at, radius) diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 1b5dddbe7..a97d3514e 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -965,7 +965,9 @@ pub enum MobEvent { owner: u32, }, Shoot([f64; 3], [f64; 3]), - Explode([f64; 3], f32), + /// The centre, the radius and the kind of the mob blowing up (it may be + /// gone from the list by the time the blast is handled). + Explode([f64; 3], f32, Species), /// Melee or ranged damage to another mob. AttackMob { target: u32, diff --git a/crates/horizon-client/src/mobs/hostile.rs b/crates/horizon-client/src/mobs/hostile.rs index 0d3feaa6c..8ad69b030 100644 --- a/crates/horizon-client/src/mobs/hostile.rs +++ b/crates/horizon-client/src/mobs/hostile.rs @@ -180,6 +180,7 @@ pub fn creeper_tick(m: &mut Mob, events: &mut Vec) { events.push(MobEvent::Explode( [m.position.x, m.position.y, m.position.z], radius, + m.species(), )); m.removed = true; } diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs index 00b846b86..2af0d7362 100644 --- a/crates/horizon-client/src/mobs/sulfur_cube.rs +++ b/crates/horizon-client/src/mobs/sulfur_cube.rs @@ -370,6 +370,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { events.push(MobEvent::Explode( [m.position.x, m.position.y + 0.0625, m.position.z], power, + m.species(), )); m.removed = true; return; diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs index 6702686c5..7f1fc0db2 100644 --- a/crates/horizon-client/src/mobs/wither.rs +++ b/crates/horizon-client/src/mobs/wither.rs @@ -221,6 +221,7 @@ pub fn custom_server_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec Date: Mon, 26 Oct 2026 18:13:33 +0100 Subject: [PATCH 040/105] Keep the current attack target regardless of invisibility --- crates/horizon-client/src/mobs/goals.rs | 27 +++++++++++++++---- .../horizon-client/src/mobs/monster_brain.rs | 3 +++ 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs index c44614571..2341c11d4 100644 --- a/crates/horizon-client/src/mobs/goals.rs +++ b/crates/horizon-client/src/mobs/goals.rs @@ -588,21 +588,38 @@ impl Mob { if p.creative || p.allies.contains(&self.id) { return false; } - self.player_in_range(w, range, check_sight) + self.player_in_range(w, range, check_sight, true) + } + /// forCombat().ignoreInvisibilityTesting() for the player: the check for + /// a target the mob already has, which ignores the visibility scaling. + pub fn can_keep_target_player(&mut self, w: &MobWorld, range: f64) -> bool { + let Some(p) = &w.player else { return false }; + if p.creative || p.allies.contains(&self.id) { + return false; + } + self.player_in_range(w, range, true, false) } /// TargetingConditions.forNonCombat().range(range).test for the player /// (seen by anyone, within range scaled by visibility, in sight). pub fn can_see_player(&mut self, w: &MobWorld, range: f64) -> bool { - self.player_in_range(w, range, true) + self.player_in_range(w, range, true, true) } - fn player_in_range(&mut self, w: &MobWorld, range: f64, check_sight: bool) -> bool { + /// `scale` is `TargetingConditions.testInvisible`: scale the range by + /// the player's visibility. + fn player_in_range( + &mut self, + w: &MobWorld, + range: f64, + check_sight: bool, + scale: bool, + ) -> bool { let Some(p) = &w.player else { return false }; if !p.alive || p.spectator { return false; } // LivingEntity.getVisibilityPercent - let mut visibility = p.visibility_percent(); - if let Some(head) = &p.head { + let mut visibility = if scale { p.visibility_percent() } else { 1.0 }; + if let Some(head) = p.head.as_ref().filter(|_| scale) { let skull = match self.species() { Species::Zombie | Species::Husk | Species::Drowned | Species::ZombieVillager => { "minecraft:zombie_head" diff --git a/crates/horizon-client/src/mobs/monster_brain.rs b/crates/horizon-client/src/mobs/monster_brain.rs index 9456c00a1..4990913eb 100644 --- a/crates/horizon-client/src/mobs/monster_brain.rs +++ b/crates/horizon-client/src/mobs/monster_brain.rs @@ -359,11 +359,14 @@ fn can_attack(m: &Mob, w: &MobWorld, who: Who) -> bool { /// `Sensor.isEntityAttackable`: `TargetingConditions.forCombat()` within the /// follow range, in sight. fn attackable(m: &mut Mob, w: &MobWorld, who: Who) -> bool { + // The current ATTACK_TARGET is tested with ignoreInvisibilityTesting. + let current = mem_ref(m).attack_target.value() == Some(who); let range = m.attrs.follow_range; if !can_attack(m, w, who) { return false; } match who { + Who::Player if current => m.can_keep_target_player(w, range), Who::Player => m.can_target_player(w, range, true), Who::Mob(id) => { let Some(s) = w.seen(id) else { return false }; From a6d2eb9d6421d1bbf54c4fb366438a70682946de Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:17:27 +0100 Subject: [PATCH 041/105] Shulkers keep their body still while the head turns --- crates/horizon-client/src/mobs/control.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs index 3df557362..70a40b23f 100644 --- a/crates/horizon-client/src/mobs/control.rs +++ b/crates/horizon-client/src/mobs/control.rs @@ -389,6 +389,13 @@ impl Mob { } /// BodyRotationControl.clientTick (Mob.tickHeadTurn). pub fn body_rotation_tick(&mut self) { + // Shulker.ShulkerBodyRotationControl.clientTick is empty: the body + // stays at 0 (recreateFromPacket), only the head turns. + if self.species() == super::Species::Shulker { + self.body_yaw = 0.0; + self.previous_body_yaw = 0.0; + return; + } let dx = self.position.x - self.previous.x; let dz = self.position.z - self.previous.z; let max = self.kind.max_head_y_rot; From 1862395e4b72d7ed7d5e6ee1769727ac38964031 Mon Sep 17 00:00:00 2001 From: Carlos Nunez Date: Mon, 26 Oct 2026 13:32:44 -0400 Subject: [PATCH 042/105] Keep a leaving guest's play state until their statistics are saved lan_crafting_left removed the guest's GuestPlay from host.play before the leave_game award and save_guest_records ran, so a normal guest disconnect awarded nothing and wrote no statistics. It now takes the crafting table and workstation state out of the entry and leaves the entry for HostEvent::Left to remove after saving. New lan_e2e check `leave`: a guest leaves twice and the host's saved statistics show leave_game 1, then 2. It fails on the previous commit (0, then [0, 0]) and passes here. Co-Authored-By: Claude Sonnet 5.5 --- .../horizon-client/src/game/lan_crafting.rs | 10 +++--- tools/lan_e2e.py | 35 +++++++++++++++++-- 2 files changed, 38 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs index db6235c4d..839390529 100644 --- a/crates/horizon-client/src/game/lan_crafting.rs +++ b/crates/horizon-client/src/game/lan_crafting.rs @@ -576,16 +576,18 @@ impl Game<'_> { /// A guest left: what their crafting grids and workstation held goes back into their /// inventory before it is saved (dropped where they stood if full). pub(super) fn lan_crafting_left(&mut self, host: &mut LanHost, g: &mut Guest) { - let play = host.play.remove(&g.conn); + // The guest's play state stays: their statistics are awarded and saved + // after this (`HostEvent::Left`), which removes it. + let play = host.play.get_mut(&g.conn); let mut grid: Vec = g.craft_grid.iter_mut().filter_map(Option::take).collect(); g.craft_result = None; if let Some(play) = play { - if let Some((_, _, menu, _)) = play.crafting.table { + if let Some((_, _, menu, _)) = play.crafting.table.take() { grid.extend((1..10).filter_map(|s| menu.slot(s).cloned())); } // A workstation's inputs too. - if let Some(station) = &play.station { - grid.extend(super::lan_stations::station_inputs(station)); + if let Some(station) = play.station.take() { + grid.extend(super::lan_stations::station_inputs(&station)); } } if grid.is_empty() { diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 866602c9b..2c8885b81 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -22,7 +22,7 @@ address. The script then checks, from both sides, what a guest's game used to ge - pvp: the guest and the host hit each other with a sword; with the pvp game rule off, or on one team without friendly fire, nothing; - kills: a pig the guest kills counts in the guest's killed statistic, not the host's (#484); - +- leave: a guest who leaves has leave_game in their saved statistics, and again after the next leave; - arrows: the guest and the host shoot each other with a bow; with the pvp game rule off, nothing (#484); - looks: mobs look on both sides as the server has them (their synched data): a calf is a @@ -290,7 +290,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # Match normal single player; --in-frame is the comparison path. SERVER_THREAD = True -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'leave', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] class Game: @@ -1134,6 +1134,35 @@ def check_pvp(host, guest, out): return hits +def leave_game_total(host): + """The leave_game statistic summed over the stats files the host's world holds.""" + total = 0 + for path in (host.work / 'saves' / 'Lan' / 'players' / 'stats').glob('*.json'): + custom = json.loads(path.read_text()).get('stats', {}).get('minecraft:custom', {}) + total += custom.get('minecraft:leave_game', 0) + return total + + +def check_leave(host, guest, out): + # PlayerList.remove awards Stats.LEAVE_GAME before it saves the player: a guest who leaves has it in + # their saved statistics, and it counts again the next time they leave. + port = host.raw('lan', 'status')['port'] + before = leave_game_total(host) + counts = [] + for _ in range(2): + guest.raw('disconnect') + for _ in range(20): + time.sleep(0.5) + if leave_game_total(host) > (counts[-1] if counts else before): + break + counts.append(leave_game_total(host)) + guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME) + guest.raw('wait-for', 'loaded', '--timeout', 300) + guest.wait(20) + assert counts == [before + 1, before + 2], f'leave_game was {before}, then {counts} after two leaves' + return {'leave_game': counts} + + def check_kills(host, guest, out): # A mob the guest kills is the guest's kill (#484): LivingEntity.die credits lastHurtByPlayer, so the # killed statistic (and its scoreboard criterion) counts for the guest, not the host. @@ -4616,7 +4645,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, 'time': check_time, 'growth': check_growth, 'doors': check_doors, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, - 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, + 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'leave': check_leave, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'hands': check_hands, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts, From e92937d956f8f2d5bb57bd945f80de91cece120c Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:44:23 +0100 Subject: [PATCH 043/105] Apply Slowness with Bane of Arthropods Post-attack effects only handled ignite, so the apply_mob_effect effect of Bane of Arthropods never did anything. Handle apply_mob_effect like vanilla. --- .../src/game/enchant_effects.rs | 80 ++++++++++++++----- crates/horizon-client/src/game/potions.rs | 2 +- 2 files changed, 63 insertions(+), 19 deletions(-) diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs index 7cdb3e526..ac194dcba 100644 --- a/crates/horizon-client/src/game/enchant_effects.rs +++ b/crates/horizon-client/src/game/enchant_effects.rs @@ -153,8 +153,10 @@ impl Game<'_> { items: Some(self.res.items()), ..Default::default() }; - // minecraft:post_attack ignite effects of the attacker's weapon (fire aspect). + // minecraft:post_attack effects of the attacker's weapon on the victim: + // ignite (fire aspect) and apply_mob_effect (bane of arthropods). let mut ignite = 0.0f32; + let mut mob_effects = Vec::new(); for (id, level) in held.enchantments() { let Some(def) = self.res.stations().enchantments.get(id) else { continue; @@ -164,24 +166,33 @@ impl Game<'_> { .into_iter() .flatten() { - if effect["enchanted"] == "attacker" - && effect["affected"] == "victim" - && effect["effect"]["type"] == "minecraft:ignite" + let e = &effect["effect"]; + let kind_of = e["type"].as_str(); + if effect["enchanted"] != "attacker" + || effect["affected"] != "victim" + || !matches!( + kind_of, + Some("minecraft:ignite" | "minecraft:apply_mob_effect") + ) { - let mut random = self.world.random.clone(); - let ok = effect.get("requirements").is_none_or(|r| { - self.res - .stations() - .enchantments - .condition(r, *level, &ctx, &mut random) - }); - self.world.random = random; - if ok { - ignite = ignite.max(horizon_client::enchant::level_value( - &effect["effect"]["duration"], - *level, - )); - } + continue; + } + let mut random = self.world.random.clone(); + let ok = effect.get("requirements").is_none_or(|r| { + self.res + .stations() + .enchantments + .condition(r, *level, &ctx, &mut random) + }); + self.world.random = random; + if !ok { + continue; + } + if kind_of == Some("minecraft:ignite") { + ignite = + ignite.max(horizon_client::enchant::level_value(&e["duration"], *level)); + } else { + mob_effects.push((e.clone(), *level)); } } } @@ -191,8 +202,41 @@ impl Game<'_> { { m.ignite_for_ticks((ignite * 20.0) as i32); } + for (effect, level) in mob_effects { + self.apply_mob_effect(mob, &effect, level); + } self.post_attack_bursts(&held, &kind); } + /// `ApplyMobEffect.apply`: one of `to_apply` (a single id or a list) for a + /// random duration and amplifier between the level-based bounds. + fn apply_mob_effect(&mut self, mob: usize, effect: &serde_json::Value, level: u32) { + use horizon_client::enchant::level_value; + let Some(m) = self.mobs.get_mut(mob) else { + return; + }; + let ids: Vec<&str> = match &effect["to_apply"] { + serde_json::Value::String(id) => vec![id.as_str()], + serde_json::Value::Array(list) => list.iter().filter_map(|v| v.as_str()).collect(), + _ => Vec::new(), + }; + if ids.is_empty() { + return; + } + // HolderSet.getRandomElement, then Mth.randomBetween for both values. + let pick = m.random.next_int_bound(ids.len() as i32).unwrap_or(0) as usize; + let mut between = |min: &str, max: &str| { + let (lo, hi) = ( + level_value(&effect[min], level), + level_value(&effect[max], level), + ); + m.random.next_float() * (hi - lo) + lo + }; + let ticks = (between("min_duration", "max_duration") * 20.0).round() as i32; + let amplifier = (between("min_amplifier", "max_amplifier").round() as i32).max(0); + if let Some(id) = super::potions::mob_effect_id(ids[pick]) { + m.add_effect(id, ticks, amplifier); + } + } /// `minecraft:post_attack` explode effects on the attacker (wind burst): /// a burst at the player's feet that only knocks back and triggers /// blocks (`ExplodeEffect` with `block_interaction: trigger`). diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index 13eae7d3e..834f6f708 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -28,7 +28,7 @@ pub(super) struct ThrownPotion { age: u32, } /// A mob's effect ids carry the `minecraft:` namespace. -fn mob_effect_id(id: &str) -> Option<&'static str> { +pub(super) fn mob_effect_id(id: &str) -> Option<&'static str> { use std::{collections::HashMap, sync::OnceLock}; static IDS: OnceLock> = OnceLock::new(); let id = id.trim_start_matches("minecraft:"); From 555ddb94bf8a20bf241dde847137fea335f2b2eb Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:45:13 +0100 Subject: [PATCH 044/105] Use the impaling entity tag for thrown tridents The bonus went to every swimming or water-breathing mob, including undead, blazes, ghasts and iron golems. Read the damage from the enchantment data so only #sensitive_to_impaling mobs take it. --- crates/horizon-client/src/game/trident.rs | 29 +++++++++++++++++++---- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs index c31094596..9e7f9f65d 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -5,6 +5,7 @@ use super::{Game, view_vector}; use horizon_client::{ collisions::SceneCollisions, + enchant::EffectContext, items::ItemStack, mesher::Vertex, mobs::{Damage, DamageKind, Who, anim::Poses}, @@ -305,11 +306,29 @@ impl Game<'_> { } } if let Some((id, _)) = hit_mob { - let impaling = t.stack.enchantment_level("minecraft:impaling") as f32; - let aquatic = self.mobs.iter().find(|m| m.id == id).is_some_and(|m| { - m.kind.flags.aquatic_swimmer || m.kind.flags.breathes_water - }); - let damage = 8.0 + if aquatic { 2.5 * impaling } else { 0.0 }; + // ThrownTrident.getDamage: `EnchantmentHelper.modifyDamage` on 8 + // (impaling hits `#sensitive_to_impaling`, the aquatic tag). + let victim = self + .mobs + .iter() + .find(|m| m.id == id) + .map(|m| m.kind.id.clone()); + let ctx = EffectContext { + this: victim.as_deref(), + attacker: Some("minecraft:player"), + direct_attacker: Some("minecraft:trident"), + is_direct: true, + damage_type: Some("minecraft:trident"), + items: Some(self.res.items()), + ..Default::default() + }; + let damage = self.res.stations().enchantments.modify_value( + Some(&t.stack), + "minecraft:damage", + &ctx, + &mut self.world.random, + 8.0, + ); t.dealt_damage = true; if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { let from = Some([t.position.x, t.position.y, t.position.z]); From 564b230ab168a3be7c0e468ae546acd72fd8dc7e Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:45:13 +0100 Subject: [PATCH 045/105] Make a warden's hit disable the player's shield A warden holds no weapon, so its blows never put the shield on cooldown. Warden.getSecondsToDisableBlocking is a flat 5 seconds, so use that when the attacker is a warden. --- crates/horizon-client/src/game/shield.rs | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs index c4f7f98d1..a26bc5d75 100644 --- a/crates/horizon-client/src/game/shield.rs +++ b/crates/horizon-client/src/game/shield.rs @@ -182,12 +182,17 @@ impl Game<'_> { return; }; let (mx, mz) = (m.position.x, m.position.z); - let disable = m - .extra - .main_hand - .as_deref() - .and_then(|item| self.res.items().get(item)) - .map_or(0.0, |i| i.disable_blocking_seconds); + // LivingEntity.getSecondsToDisableBlocking: the held weapon's value; + // Warden overrides it with a flat 5 seconds. + let disable = if m.species() == horizon_client::mobs::Species::Warden { + 5.0 + } else { + m.extra + .main_hand + .as_deref() + .and_then(|item| self.res.items().get(item)) + .map_or(0.0, |i| i.disable_blocking_seconds) + }; // Ravager.blockedByItem: stunned half the time (the defender pushed // apart), else the defender flung away; no roar in progress. if m.species() == horizon_client::mobs::Species::Ravager { From dbef78bcb82f2b123f17c3358aa65aa7953a4f41 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:45:54 +0100 Subject: [PATCH 046/105] Apply Unbreaking to armor wear from Thorns Thorns always cost the worn piece 2 durability. Run it through the same durability loss as other wear so Unbreaking can cancel points. --- crates/horizon-client/src/game/enchant_effects.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs index 7cdb3e526..4417f0df8 100644 --- a/crates/horizon-client/src/game/enchant_effects.rs +++ b/crates/horizon-client/src/game/enchant_effects.rs @@ -303,8 +303,10 @@ impl Game<'_> { continue; } hits.push(1.0 + self.world.random.next_float() * 4.0); + // ChangeItemDamage -> ItemStack.hurtAndBreak: unbreaking applies. + let loss = self.durability_loss(&stack, 2); if let Some(s) = self.armor[slot].as_mut() { - s.damage += 2; + s.damage += loss; if self .res .items() From bf527e7a13ccf3b6477dbc49004086c44a8832a7 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:46:36 +0100 Subject: [PATCH 047/105] Apply knockback resistance to Punch arrows --- crates/horizon-client/src/game/creatures.rs | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2b65a3289..38dd455c8 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2123,10 +2123,24 @@ impl Game<'_> { hurt } }; - // doKnockback: Punch pushes along the flight. + // doKnockback: Punch pushes along the flight, less the target's + // knockback resistance. let flight = (p.velocity.x * p.velocity.x + p.velocity.z * p.velocity.z).sqrt(); - if hurt && p.bonus.punch > 0 && flight > 1e-6 { - let k = f64::from(p.bonus.punch) * 0.6 / flight; + let resistance = match who { + Who::Player => self + .player + .as_mut() + .and_then(|pl| pl.attribute("minecraft:knockback_resistance").ok()) + .unwrap_or(0.0), + Who::Mob(id) => self + .mobs + .iter() + .find(|m| m.id == id) + .map_or(0.0, |m| m.attrs.knockback_resistance), + }; + let push = f64::from(p.bonus.punch) * 0.6 * (1.0 - resistance).max(0.0); + if hurt && push > 0.0 && flight > 1e-6 { + let k = push / flight; self.handle_mob_events(vec![MobEvent::Push { target: who, velocity: [p.velocity.x * k, 0.1, p.velocity.z * k], From c1844dfe57e5b3f02b90f9fabad813753aa7e7a4 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:46:37 +0100 Subject: [PATCH 048/105] Let mobs trample farmland when they land on it A cow dropped onto farmland left it untouched. A landing mob now turns farmland to dirt with chance fall distance - 0.5, when mob griefing is on and the mob is big enough, and is lifted onto the dirt. --- crates/horizon-client/src/mobs/living.rs | 25 ++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs index 394821ace..afd0c26db 100644 --- a/crates/horizon-client/src/mobs/living.rs +++ b/crates/horizon-client/src/mobs/living.rs @@ -440,11 +440,36 @@ impl Mob { } if self.on_ground { if self.fall_distance > 0.0 { + self.trample_farmland(w, events); self.cause_fall_damage(events); } self.fall_distance = 0.0; } } + /// `FarmlandBlock.fallOn`: a landing on farmland turns it to dirt with + /// chance `fallDistance - 0.5`, if mobs may grief and the mob's + /// `width * width * height` is over 0.512. `Block.pushEntitiesUp` lifts + /// the mob onto the dirt, which is a full block. + fn trample_farmland(&mut self, w: &MobWorld, events: &mut Vec) { + let p = self.block_on_legacy(w); + if w.block_name(p[0], p[1], p[2]) != "minecraft:farmland" { + return; + } + let roll = f64::from(self.random.next_float()); + let Some(dirt) = w.registry.default_state("minecraft:dirt") else { + return; + }; + if roll < self.fall_distance - 0.5 + && w.mob_griefing + && self.width() * self.width() * self.height() > 0.512 + { + events.push(MobEvent::SetBlock { + pos: p, + state: dirt, + }); + self.position.y = self.position.y.max(f64::from(p[1]) + 1.0); + } + } /// Entity.updateFluidInteraction: the fluid state, then touching water /// resets the fall and entering it (after the first tick) splashes. pub(super) fn update_fluids(&mut self, w: &MobWorld, events: &mut Vec) { From 90501f9ab4ab5cb04e85d6aa5d032d25e8e6bda2 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:46:46 +0100 Subject: [PATCH 049/105] Keep leashed mobs and carrying endermen from despawning Mob.requiresCustomPersistence also covers a leashed mob and an enderman holding a block, and the spawn caps skip such mobs. Gather the existing cases in one helper, add the missing ones, and use it for both the despawn check and the cap count. --- .../src/game/natural_spawning.rs | 3 ++- crates/horizon-client/src/mobs/ai.rs | 20 +++++++++++++------ 2 files changed, 16 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/game/natural_spawning.rs b/crates/horizon-client/src/game/natural_spawning.rs index 0035f5082..5afa72416 100644 --- a/crates/horizon-client/src/game/natural_spawning.rs +++ b/crates/horizon-client/src/game/natural_spawning.rs @@ -504,7 +504,8 @@ impl<'a> Game<'a> { m.position.z.floor() as i32, ], is_mob: true, - persistent: m.persistent, + persistent: m.persistent + || horizon_client::mobs::ai::requires_custom_persistence(m), }) .collect(); let players = players diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 2676c3a37..3b9a8ed04 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -1017,6 +1017,19 @@ pub fn despawn_check(m: &mut Mob, w: &MobWorld) -> bool { } true } +/// `Mob.requiresCustomPersistence` and its overrides: a passenger or a leashed +/// mob, a raider in a raid, an enderman carrying a block, a tame nautilus, a +/// sulfur cube holding a block or let out of a bucket. The spawn caps do not +/// count these mobs either (`NaturalSpawner.createState`). +pub fn requires_custom_persistence(m: &Mob) -> bool { + super::riders::keeps_alive(m) + || m.extra.leash.is_some() + || super::raider::state(m).is_some_and(|s| s.raid_id.is_some()) + || m.species() == Species::Enderman && m.extra.carried.is_some() + || super::nautilus::is_nautilus(m.species()) && m.extra.tame + || m.species() == Species::SulfurCube + && (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0) +} /// Mob.checkDespawn, before the tick (players are the only despawn /// reference). Returns false when the mob is discarded. fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool { @@ -1032,12 +1045,7 @@ fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool { return true; }; let d = m.distance_sqr(p); - // requiresCustomPersistence: raiders in a raid, a tame nautilus, a sulfur - // cube holding a block or let out of a bucket. - let persistent = m.persistent - || super::nautilus::is_nautilus(m.species()) && m.extra.tame - || m.species() == Species::SulfurCube - && (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0); + let persistent = m.persistent || requires_custom_persistence(m); // removeWhenFarAway: animals, villagers, golems, patrols and raiders, // zombie villagers being cured and ridden mobs stay. let creature = m.kind.category == "creature"; From 7569f9615a193b50443eaff428e126651a647ce2 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:47:58 +0100 Subject: [PATCH 050/105] Treat unbreakable items as undamageable in the anvil and grindstone --- crates/horizon-client/src/stations.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs index a307b35cf..3fa480656 100644 --- a/crates/horizon-client/src/stations.rs +++ b/crates/horizon-client/src/stations.rs @@ -151,8 +151,12 @@ pub struct AnvilResult { pub repair_item_count_cost: u32, pub only_renaming: bool, } +/// `ItemStack.isDamageableItem`: durability, and not `minecraft:unbreakable`. pub fn is_damageable(items: &Items, stack: &ItemStack) -> bool { items.get(&stack.item).is_some_and(|i| i.max_damage > 0) + && stack + .data() + .is_none_or(|d| d.other("minecraft:unbreakable").is_none()) } fn max_damage(items: &Items, stack: &ItemStack) -> i32 { items.get(&stack.item).map_or(0, |i| i.max_damage as i32) From 2277c85fc3e486fa36ef6f4569a826a73db0cbd4 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:07:02 +0100 Subject: [PATCH 051/105] Run neighbour updates when a mob trampling farmland places dirt --- crates/horizon-client/src/game/creatures.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2b65a3289..f08f41d01 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1037,9 +1037,9 @@ impl Game<'_> { [0.0, 0.2, 0.0], 10, ), - MobEvent::SetBlock { pos, state } => { - self.world.set(pos[0], pos[1], pos[2], state)? - } + // `Level.setBlockAndUpdate`: neighbour and shape updates, so a crop + // above trampled farmland breaks and drops. + MobEvent::SetBlock { pos, state } => self.level_set(pos, state)?, MobEvent::SetDoorOpen { pos, open } => { let pos = BlockPos::new(pos[0], pos[1], pos[2]); self.with_level(|b, level, ticks| b.set_door_open(level, ticks, pos, open)); From e6587dce6a005413b2617d281826dde4ca6663f0 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:17:05 +0100 Subject: [PATCH 052/105] Respawn at once without a death screen when immediate_respawn is on --- crates/horizon-client/src/game.rs | 11 ++- crates/horizon-client/src/game/lan.rs | 2 + crates/horizon-client/src/game/remote.rs | 29 ++++++-- crates/horizon-client/src/game/screens.rs | 86 ++++++++++++----------- crates/horizon-client/src/lan/hub.rs | 17 ++++- 5 files changed, 95 insertions(+), 50 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 8448f0837..2d0efc34d 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4614,9 +4614,14 @@ impl Game<'_> { if let Some(host) = &self.lan { host.hub.entity_event(host.host_entity, 3, feet); } - self.screen = Screen::Dead; - self.capture(false); - self.ui.death_time = 0; + if self.ui.rules.bool("immediate_respawn") { + // Gui.setScreen: without the death screen the player respawns at once. + self.respawn_player()?; + } else { + self.screen = Screen::Dead; + self.capture(false); + self.ui.death_time = 0; + } } else if dead { // LivingEntity.tickDeath: 20 ticks after dying the player is // removed, and Player.remove's inventoryMenu.removed drops what diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 5292cd31b..9b52cc46e 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -974,6 +974,8 @@ impl Game<'_> { self.ui.rules.bool("player_movement_check"), self.ui.rules.bool("elytra_movement_check"), ); + host.hub + .set_immediate_respawn(self.ui.rules.bool("immediate_respawn")); // A server with several levels runs a pass for each // (`tick_server`): the network is read once, before the first. let pass = self.level_pass; diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3cfbd15e3..1a684cb75 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -192,6 +192,8 @@ pub(super) struct Remote { stop_mining: bool, placing: Option<([i32; 3], u64)>, death_message: Option, + /// `LocalPlayer.showDeathScreen`: off with `immediate_respawn`. + show_death_screen: bool, player_type: Option>, /// Inventory as last synchronised, for creative-mode slot updates. synced: Vec>, @@ -476,6 +478,7 @@ impl Game<'_> { stop_mining: false, placing: None, death_message: None, + show_death_screen: true, player_type, synced: vec![None; 36], decode_errors: 0, @@ -1623,6 +1626,7 @@ impl Game<'_> { r.online_mode = p.online_mode; r.entity_id = p.player_id; r.view_distance = p.chunk_radius; + r.show_death_screen = p.show_death_screen; } self.streaming.radius = self.settings.render_distance.min(p.chunk_radius + 1).max(2); @@ -2182,7 +2186,11 @@ impl Game<'_> { pl.health.flash_health_change(p.health); } self.apply_remote_health(); - if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() { + // The death screen opens (or the respawn is asked for) with the + // death packet when the rule hides it. + let shown = self.remote.as_ref().is_none_or(|r| r.show_death_screen); + if p.health <= 0.0 && shown && self.screen != Screen::Dead && self.player.is_some() + { self.screen = Screen::Dead; self.ui.death_time = 0; self.capture(false); @@ -2198,11 +2206,16 @@ impl Game<'_> { r.death_message = Some(message); } // ClientPacketListener.handlePlayerCombatKill: the death - // screen, whatever health was last sent. + // screen, whatever health was last sent, or `respawn()` at + // once when it is hidden. if me && self.screen != Screen::Dead && self.player.is_some() { - self.screen = Screen::Dead; - self.ui.death_time = 0; - self.capture(false); + if self.remote.as_ref().is_none_or(|r| r.show_death_screen) { + self.screen = Screen::Dead; + self.ui.death_time = 0; + self.capture(false); + } else { + self.respawn_player()?; + } } } C::TrackedWaypoint(p) => self.handle_waypoint(&p), @@ -2278,6 +2291,12 @@ impl Game<'_> { r.game_mode = mode; } } + // IMMEDIATE_RESPAWN: LocalPlayer.setShowDeathScreen. + 11 => { + if let Some(r) = self.remote.as_mut() { + r.show_death_screen = p.param == 0.0; + } + } 7 => { self.world.weather.rain_level = (p.param, p.param); self.world.weather.raining = p.param > 0.0; diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index f8885f83a..3a2c3deda 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -286,6 +286,50 @@ impl Game<'_> { ); } } + /// LocalPlayer.respawn: the player comes back (the death screen's + /// button, or at once with `immediate_respawn`). + pub(super) fn respawn_player(&mut self) -> Result<()> { + if self.remote.is_none() { + let keep = self.ui.rules.bool("keep_inventory") || self.spectator(); + self.experience.respawn(keep); + // The guests are sent the respawned host as a new entity, not the dead body. + if let Some(host) = self.lan.as_mut() { + let id = host.host_entity; + host.hub.respawned(id); + } + // Autosaves keep a login position; death must resolve the respawn point instead. + self.level.position = None; + } + if self.remote.is_some() { + self.ui.death_text = None; + self.toggles.respawn(); + self.remote_respawn(); + } else if self.respawn_config.is_some() { + // LocalPlayer.respawn: KeyMapping.resetToggleKeys. + self.toggles.respawn(); + // PlayerList.respawn at the respawn anchor, once it is loaded. + self.begin_anchor_respawn()?; + self.screen = Screen::Playing; + self.ui.death_text = None; + self.spawn_player()?; + self.capture(true); + } else { + // LocalPlayer.respawn: KeyMapping.resetToggleKeys. + self.toggles.respawn(); + self.respawn_out_of_end()?; + self.player = None; + self.screen = Screen::Playing; + self.ui.death_text = None; + self.spawn_player()?; + self.capture(true); + } + // ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's + // respawned player only watches. + if self.remote.is_none() && self.level.hardcore { + self.set_mode(GameMode::Spectator); + } + Ok(()) + } pub(super) fn death_click(&mut self) -> Result<()> { if self .ui @@ -303,51 +347,11 @@ impl Game<'_> { .into_iter() .find(|d| ui::hovered(self.cursor, d.0, d.1, 200.0, 20.0)) .map(|d| d.3); - if hit == Some(0) && self.remote.is_none() { - let keep = self.ui.rules.bool("keep_inventory") || self.spectator(); - self.experience.respawn(keep); - // The guests are sent the respawned host as a new entity, not the dead body. - if let Some(host) = self.lan.as_mut() { - let id = host.host_entity; - host.hub.respawned(id); - } - // Autosaves keep a login position; death must resolve the respawn point instead. - self.level.position = None; - } match hit { - Some(0) if self.remote.is_some() => { - self.ui.death_text = None; - self.toggles.respawn(); - self.remote_respawn(); - } - Some(0) if self.respawn_config.is_some() => { - // LocalPlayer.respawn: KeyMapping.resetToggleKeys. - self.toggles.respawn(); - // PlayerList.respawn at the respawn anchor, once it is loaded. - self.begin_anchor_respawn()?; - self.screen = Screen::Playing; - self.ui.death_text = None; - self.spawn_player()?; - self.capture(true); - } - Some(0) => { - // LocalPlayer.respawn: KeyMapping.resetToggleKeys. - self.toggles.respawn(); - self.respawn_out_of_end()?; - self.player = None; - self.screen = Screen::Playing; - self.ui.death_text = None; - self.spawn_player()?; - self.capture(true); - } + Some(0) => self.respawn_player()?, Some(1) => self.close_world()?, _ => {} } - // ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's - // respawned player only watches. - if hit == Some(0) && self.remote.is_none() && self.level.hardcore { - self.set_mode(GameMode::Spectator); - } if hit.is_some() { self.audio.play_button_click(); } diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index b1a8cbc62..8c60dc75f 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -43,6 +43,7 @@ pub mod game_event { pub const RAIN_LEVEL: u8 = 7; pub const THUNDER_LEVEL: u8 = 8; pub const GUARDIAN_ELDER_EFFECT: u8 = 10; + pub const IMMEDIATE_RESPAWN: u8 = 11; pub const LEVEL_CHUNKS_LOAD_START: u8 = 13; } @@ -149,6 +150,8 @@ pub struct Hub { /// The `player_movement_check` and `elytra_movement_check` game rules, /// set by the game before each tick. pub movement_checks: (bool, bool), + /// The `immediate_respawn` game rule, as the players were last told. + immediate_respawn: bool, /// An integrated server's owner (`MinecraftServer.isSingleplayerOwner`), /// whose moves are never checked. pub singleplayer_owner: Option, @@ -324,6 +327,7 @@ impl Hub { guests: Vec::new(), sync, ticks: 0, + immediate_respawn: false, movement_checks: (true, true), singleplayer_owner: None, riding: Default::default(), @@ -399,6 +403,17 @@ impl Hub { g.sender.send(body.clone()); } } + /// MinecraftServer.onGameRuleChanged: every player is told when + /// `immediate_respawn` changes; a joining player's Login carries it. + pub fn set_immediate_respawn(&mut self, on: bool) { + if self.immediate_respawn != on { + self.immediate_respawn = on; + self.broadcast(&C::GameEvent(play::GameEvent { + event: game_event::IMMEDIATE_RESPAWN, + param: if on { 1.0 } else { 0.0 }, + })); + } + } /// PlayerList.setViewDistance: every player is told the new radius, /// and each one's chunks follow it, up to what they asked for /// (ChunkMap.getPlayerViewDistance). @@ -633,7 +648,7 @@ impl Hub { chunk_radius: self.config.view_distance, simulation_distance: self.config.simulation_distance, reduced_debug_info: false, - show_death_screen: true, + show_death_screen: !self.immediate_respawn, limited_crafting: false, spawn: self.spawn_info(mode), // MinecraftServer.usesAuthentication, enforceSecureProfile. From 97f8bca9daf9eb3f18b4bab27c3bd36cc8ca56e2 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:32:41 +0100 Subject: [PATCH 053/105] Raiders skip ominous banners they cannot reach A captainless raider walked towards the nearest fallen ominous banner even when no path led to it. Check that a path reaches the banner before going for it, and skip a banner without one for 600 ticks, like vanilla. --- crates/horizon-client/src/game/raids.rs | 17 +++++++---- crates/horizon-client/src/mobs/raider.rs | 37 ++++++++++++++++++------ 2 files changed, 39 insertions(+), 15 deletions(-) diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs index bedca5708..e34d9feed 100644 --- a/crates/horizon-client/src/game/raids.rs +++ b/crates/horizon-client/src/game/raids.rs @@ -762,7 +762,7 @@ impl Game<'_> { } positions.push((m.id, m.position, s.active_raid)); } - let banners: Vec<(usize, Vec3)> = self + let banners: Vec<(usize, u32, Vec3)> = self .dropped .iter() .enumerate() @@ -771,7 +771,7 @@ impl Game<'_> { && e.stack.data().is_some_and(|d| d.ominous_banner) && e.pickup_delay == 0 }) - .map(|(i, e)| (i, e.position)) + .map(|(i, e)| (i, e.id, e.position)) .collect(); let mut taken: Vec = Vec::new(); let mut collectors: Vec<(usize, u32)> = Vec::new(); @@ -858,18 +858,23 @@ impl Game<'_> { { let near = banners .iter() - .filter(|(i, p)| { + .filter(|(i, item, p)| { !taken.contains(i) + && !s + .unreachable_banners + .iter() + .any(|&(b, until)| b == *item && now < until) && (p.x - position.x).abs() <= range && (p.z - position.z).abs() <= range && (p.y - position.y).abs() <= 8.0 }) .min_by(|a, b| { - a.1.distance_squared(position) - .total_cmp(&b.1.distance_squared(position)) + a.2.distance_squared(position) + .total_cmp(&b.2.distance_squared(position)) }); - if let Some((i, p)) = near { + if let Some((i, item, p)) = near { s.banner_at = Some([p.x, p.y, p.z]); + s.banner_item = *item; if p.distance_squared(position) < 1.414 * 1.414 { // pickUpItem: the banner becomes the wave's leader. taken.push(*i); diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs index 6c3ab9b64..a2c3ffe33 100644 --- a/crates/horizon-client/src/mobs/raider.rs +++ b/crates/horizon-client/src/mobs/raider.rs @@ -38,6 +38,11 @@ pub struct State { pub in_village: bool, /// A dropped ominous banner this raider may fetch. pub banner_at: Option<[f64; 3]>, + /// The item entity of `banner_at`. + pub banner_item: u32, + /// Banners with no path to them, and until when (game time): + /// `unreachableBannerCache`. + pub unreachable_banners: Vec<(u32, i64)>, /// Beds around the raid's centre. pub homes: Option>>, /// A ravager carrying a raider, set every tick from `Extra::rider`. @@ -113,7 +118,7 @@ pub fn register(m: &mut Mob) { } m.extra.raider = Some(Box::default()); m.ai.goals.add(4, LongDistancePatrol::new(0.7, 0.595)); - m.ai.goals.add(1, ObtainBanner); + m.ai.goals.add(1, ObtainBanner::default()); m.ai.goals.add(3, PathfindToRaid); m.ai.goals.add(4, MoveThroughVillage::new(1.05, 1.0)); m.ai.goals.add(5, Celebration); @@ -336,23 +341,37 @@ fn close_to_center(p: [i32; 3], at: Vec3, distance: f64) -> bool { /// `Raider.ObtainRaidLeaderBannerGoal`: walk to a fallen ominous banner when /// the wave has no living leader (the game finds the banner and picks it up). -#[derive(Clone, Debug)] -pub struct ObtainBanner; +#[derive(Clone, Debug, Default)] +pub struct ObtainBanner { + path_to_banner: Option, +} impl Goal for ObtainBanner { goal_clone!(); fn flags(&self) -> u8 { MOVE } - fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { - state(m).is_some_and(|s| s.banner_at.is_some()) + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let Some((at, item)) = state(m).and_then(|s| s.banner_at.map(|at| (at, s.banner_item))) + else { + return false; + }; + // A banner with no path to it is skipped for 600 ticks. + let path = m.create_path_to_entity(cx.w, at, 1); + if path.as_ref().is_some_and(|p| p.reached) { + self.path_to_banner = path; + return true; + } + let now = cx.w.game_time; + let s = state_mut(m); + s.unreachable_banners.retain(|&(_, until)| now < until); + s.unreachable_banners.push((item, now + 600)); + false } fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { !m.ai.nav.is_done() && state(m).is_some_and(|s| s.banner_at.is_some()) } - fn start(&mut self, m: &mut Mob, cx: &mut Cx) { - if let Some(at) = state(m).and_then(|s| s.banner_at) { - m.nav_move_to(cx.w, at, 1.15); - } + fn start(&mut self, m: &mut Mob, _cx: &mut Cx) { + m.nav_move_to_path(self.path_to_banner.take(), 1.15); } } From c74626448c544dae0101e005eafa4c23fab19981 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:40:06 +0100 Subject: [PATCH 054/105] Show the crosshair to spectators over containers, stations and portals --- crates/horizon-client/src/game.rs | 6 ++- crates/horizon-client/src/game/hand.rs | 56 +++++++++++++++++++++++++- 2 files changed, 60 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 58b89a140..91d953722 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -5141,7 +5141,11 @@ impl Game<'_> { let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed()); let strength = self.hand_strength.scale(0.0, self.main_hand_attack_speed()); // The 3D crosshair (F3) takes the 2D one's place. - if self.camera_type.first_person() && !spectator && !self.debug_crosshair() { + // Hud.extractCrosshair: a spectator only sees it over something to open. + if self.camera_type.first_person() + && (!spectator || self.spectator_crosshair()) + && !self.debug_crosshair() + { let attack = (indicator == 1).then_some(strength); let full = attack.is_some_and(|a| { hud_layout::full_attack_indicator(a, delay, self.crosshair_living()) diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs index d91d3b979..c3fd78310 100644 --- a/crates/horizon-client/src/game/hand.rs +++ b/crates/horizon-client/src/game/hand.rs @@ -3,7 +3,7 @@ //! `continueAttack`, `MultiPlayerGameMode` block breaking), the arm swing //! (`LivingEntity.SwingState`) and the first-person equip heights //! (`FirstPersonHandsAndItems`) with the item swap ticker they read. -use super::{Game, Mining, Screen}; +use super::{Game, Mining, Screen, minecarts::CartKind}; use horizon_client::{ Result, attack_strength::HeldStack, @@ -289,6 +289,60 @@ impl Game<'_> { // Only alive mobs are hit, so a picked living entity is alive. Some(true) } + /// `Hud.canRenderCrosshairForSpectator` for the nearest hit in reach: an + /// entity that is a `MenuProvider` (a chest or hopper minecart, a chest + /// boat), or a block whose `showAsInteractableInSpectatorMode` holds. + pub(super) fn spectator_crosshair(&self) -> bool { + let cart = self.cart_hit().map(|(i, d)| { + let kind = &self.carts[i].kind; + (d, matches!(kind, CartKind::Chest | CartKind::Hopper)) + }); + let boat = self.boat_hit().map(|(i, d)| (d, self.boats[i].chest)); + let others = [ + self.mob_hit().map(|h| h.1), + self.armor_stand_hit().map(|h| h.1), + self.cushion_hit().map(|h| h.1), + self.painting_hit().map(|h| h.1), + self.frame_hit().map(|h| h.1), + self.dragon_hit().map(|h| h.1), + ]; + let nearest = cart + .into_iter() + .chain(boat) + .chain(others.into_iter().flatten().map(|d| (d, false))) + .min_by(|a, b| a.0.total_cmp(&b.0)); + if let Some((distance, menu)) = nearest + && self.before_block(distance) + { + return menu; + } + let Some(hit) = self.pick() else { + return false; + }; + let name = &*self + .res + .facts() + .get(self.world.block(hit.pos[0], hit.pos[1], hit.pos[2])) + .name; + let name = name.trim_start_matches("minecraft:"); + match name { + // BlockBehaviour.getMenuProvider and `instanceof Portal`. + "crafting_table" | "enchanting_table" | "anvil" | "chipped_anvil" | "damaged_anvil" + | "stonecutter" | "loom" | "cartography_table" | "grindstone" | "smithing_table" + | "barrel" | "furnace" | "blast_furnace" | "smoker" | "brewing_stand" | "hopper" + | "dispenser" | "dropper" | "crafter" | "lectern" | "beacon" | "nether_portal" + | "end_portal" | "end_gateway" => true, + // ChestBlock.getMenuProvider: none while a redstone conductor + // sits on top (a sitting cat aside). + "chest" | "trapped_chest" => { + let above = self.world.block(hit.pos[0], hit.pos[1] + 1, hit.pos[2]); + self.res.behaviours().facts(above).flags + & horizon_world::level::data::state_flags::CONDUCTOR + == 0 + } + _ => name.ends_with("shulker_box"), + } + } /// `Attributes.ATTACK_SPEED` with the main-hand item's modifier. pub(super) fn main_hand_attack_speed(&self) -> f64 { horizon_client::attack_strength::BASE_ATTACK_SPEED From 752138e866916b5f116b7fbb933f07bee2138144 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:43:27 +0100 Subject: [PATCH 055/105] Cats sit on a chest only while nobody has it open, and on a bed's foot only --- crates/horizon-client/examples/probe/mob_ai_probe.rs | 3 +++ crates/horizon-client/src/game/creatures.rs | 1 + crates/horizon-client/src/mobs.rs | 2 ++ crates/horizon-client/src/mobs/tame.rs | 7 +++++-- 4 files changed, 11 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index ecdf02901..2fdb12ce9 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -1069,6 +1069,8 @@ pub fn main() -> horizon_client::Result<()> { for (i, m) in mobs.iter().enumerate() { print(&mut out, 0, i, m, s.creative, world.game_time); } + // No player has a chest open in the scenarios. + let lid_openers = std::collections::HashMap::new(); // The MobWorld every step sees, over a snapshot of the mobs. macro_rules! mob_world { ($snapshot:expr) => { @@ -1103,6 +1105,7 @@ pub fn main() -> horizon_client::Result<()> { // FlatLevelSource.getSeaLevel. sea_level: -63, items: Some(&items), + lid_openers: &lid_openers, } }; } diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 845d2aee6..88f3fd669 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -422,6 +422,7 @@ impl Game<'_> { sea_level: if self.dim == Dim::Nether { 32 } else { 63 }, teams: std::sync::Arc::new(self.mob_teams()), items: Some(self.res.items()), + lid_openers: &self.lid_openers, difficulty: self.local_difficulty( self.player .as_ref() diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 6b1e16f5c..06930be93 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1529,6 +1529,8 @@ pub struct MobWorld<'a> { pub teams: std::sync::Arc>, /// Item data (max stack sizes), when the host has it. pub items: Option<&'a crate::items::Items>, + /// `ChestBlockEntity.getOpenCount`: the players with each chest open. + pub lid_openers: &'a HashMap<(i32, i32, i32), i32>, } /// `Entity.getTeam` of the player and of the mobs on a team. #[derive(Clone, Debug, Default)] diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index 1e725df80..30ac762b9 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -835,7 +835,7 @@ impl Goal for CatLieOnBlock { m.extra.flag = self.0.reached; } } -/// `CatSitOnBlockGoal`: chests, lit furnaces and beds. +/// `CatSitOnBlockGoal`: unopened chests, lit furnaces and the foot of beds. #[derive(Clone, Debug)] struct CatSitOnBlock(super::goals::MoveToBlock); fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool { @@ -846,7 +846,10 @@ fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool { match f.name.as_ref() { // The lit state is the only light source a furnace has. "minecraft:furnace" => f.emission > 0, - _ => true, + // `ChestBlockEntity.getOpenCount(level, pos) < 1`. + "minecraft:chest" => !w.lid_openers.contains_key(&(p[0], p[1], p[2])), + // A bed's foot only (`BedBlock.PART != HEAD`). + _ => w.prop(p[0], p[1], p[2], "part") != Some("head"), } } impl Goal for CatSitOnBlock { From 8aad511579676fa39072a685482a9ed3b9a1bacc Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:46:01 +0100 Subject: [PATCH 056/105] Drop the cursor stack when the dead player respawns --- crates/horizon-client/src/game/screens.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index 3a2c3deda..69ae69633 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -290,6 +290,14 @@ impl Game<'_> { /// button, or at once with `immediate_respawn`). pub(super) fn respawn_player(&mut self) -> Result<()> { if self.remote.is_none() { + // PlayerList.respawn removes the dead player, and Player.remove's + // inventoryMenu.removed drops what the cursor held, whatever + // keep_inventory says (the 20-tick branch handles a later respawn). + if let Some(stack) = self.carried.take() + && let Some(eye) = self.eye_position() + { + self.throw_from_eyes(stack, eye); + } let keep = self.ui.rules.bool("keep_inventory") || self.spectator(); self.experience.respawn(keep); // The guests are sent the respawned host as a new entity, not the dead body. From 2b2aecd9757305af6e124daeaf55b5327440c02e Mon Sep 17 00:00:00 2001 From: mahirsn Date: Mon, 26 Oct 2026 21:40:03 +0300 Subject: [PATCH 057/105] fix(client): send sign editor text like vanilla A new editor or a removed sign closes the open editor (Minecraft.setScreen, AbstractSignEditScreen.tick), and closing sends ServerboundSignUpdatePacket with the lines it opened with when the sign is gone. Sign lines resolve key binds and translations (Component.getString) instead of keeping only plain text. --- crates/horizon-client/src/game/remote.rs | 9 +++++++ crates/horizon-client/src/game/sign_edit.rs | 29 +++++++++++++++------ crates/horizon-client/src/signs.rs | 8 +++--- 3 files changed, 34 insertions(+), 12 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3cfbd15e3..4e279de6c 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3129,6 +3129,15 @@ impl Game<'_> { fn tick_remote_level(&mut self) -> Result<()> { self.ticks += 1; + // AbstractSignEditScreen.tick: the editor closes once its sign is removed. + if let Some(edit) = &self.sign_edit + && !matches!( + self.world.block_entities.get(&edit.pos), + Some(BlockEntity::Sign(_)) + ) + { + self.close_sign_editor(); + } 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), diff --git a/crates/horizon-client/src/game/sign_edit.rs b/crates/horizon-client/src/game/sign_edit.rs index 2d010f1f5..529e511f2 100644 --- a/crates/horizon-client/src/game/sign_edit.rs +++ b/crates/horizon-client/src/game/sign_edit.rs @@ -20,6 +20,9 @@ pub(super) struct SignEditor { pub line: usize, /// The line being edited (`AbstractSignEditScreen`'s text field). edit: EditBox, + /// `AbstractSignEditScreen.messages`: the lines when it opened, sent if + /// the sign is gone by the time the editor closes. + lines: [String; 4], } fn sign_box() -> EditBox { @@ -33,11 +36,19 @@ fn sign_box() -> EditBox { impl Game<'_> { /// `SignBlock.openTextEdit` for the front side after placement. pub(super) fn open_sign_editor(&mut self, pos: (i32, i32, i32), front: bool) { + // Minecraft.setScreen: the editor already open is removed first. + self.close_sign_editor(); + let lines = match self.world.block_entities.get(&pos) { + Some(BlockEntity::Sign(sign)) if front => sign.front.lines.clone(), + Some(BlockEntity::Sign(sign)) => sign.back.lines.clone(), + _ => Default::default(), + }; self.sign_edit = Some(SignEditor { pos, front, line: 0, edit: sign_box(), + lines, }); self.sign_load(); self.keys.clear(); @@ -50,14 +61,16 @@ impl Game<'_> { pub(super) fn close_sign_editor(&mut self) { if let Some(edit) = self.sign_edit.take() { if self.remote.is_some() { - if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&edit.pos) { - let side = if edit.front { &sign.front } else { &sign.back }; - self.send(S::SignUpdate(play::SignUpdate { - pos: [edit.pos.0, edit.pos.1, edit.pos.2], - lines: side.lines.clone(), - front: edit.front, - })); - } + let lines = match self.world.block_entities.get(&edit.pos) { + Some(BlockEntity::Sign(sign)) if edit.front => sign.front.lines.clone(), + Some(BlockEntity::Sign(sign)) => sign.back.lines.clone(), + _ => edit.lines, + }; + self.send(S::SignUpdate(play::SignUpdate { + pos: [edit.pos.0, edit.pos.1, edit.pos.2], + lines, + front: edit.front, + })); } else { self.mark_block_entity_updated(edit.pos); } diff --git a/crates/horizon-client/src/signs.rs b/crates/horizon-client/src/signs.rs index 07217ed79..799210797 100644 --- a/crates/horizon-client/src/signs.rs +++ b/crates/horizon-client/src/signs.rs @@ -147,10 +147,10 @@ fn component_text(tag: &Tag) -> String { _ => s, } } - Tag::Compound(_) => match tag.get("text") { - Some(Tag::String(t)) => t.to_string_lossy(), - _ => String::new(), - }, + // Component.getString: translations and key binds resolved. + Tag::Compound(_) => { + crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(tag)).plain() + } _ => String::new(), } } From cf6b91a710eb52fa1b856d11da197514694eb243 Mon Sep 17 00:00:00 2001 From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com> Date: Tue, 27 Oct 2026 00:29:02 +0800 Subject: [PATCH 058/105] Items: draw the enchantment glint from enchanted_glint_item Horizon invented the glint: the GUI drew sine bands in screen space and the entity shader layered the same over held and dropped items. Vanilla 26.3 samples `misc/enchanted_glint_item` through `GLINT_TEXTURING` (`item.vsh`/`item.fsh`, `TextureTransform.setupGlintTexturing`), so items now carry the real texture: - `ItemQuad.foil_uv` keeps the model UV the glint samples; `Glint` turns it into the atlas UV with the 26.3 transform (translation(-o0, o1) * rotateZ(PI/18) * scale) and `WorldSink` gives foil quads overlay 7 and the per-corner glint UV. - The GUI glint is a separate additive HUD pass masked by the item's texture alpha (`item.fsh`'s ALPHA_CUTOUT 0.1 and GLINT path). - `entity.wgsl` samples the glint at overlay 7/8 like vanilla's `color.rgb += glintColor.rgb * glintColor.rgb`. - The Accessibility options Glint Speed and Glint Strength work: both sliders persist to `options.txt` (they were hidden placeholders), the GUI pass takes them per draw, and `Frame.glint_alpha` feeds the entity shader every frame instead of whatever the last HUD item set. - GUI items use `GLINT_TEXTURING`'s scale 8, world items `ENTITY_GLINT_TEXTURING`'s scale 0.5. Co-Authored-By: ZCode --- .../horizon-client/src/block_entity_render.rs | 7 ++ crates/horizon-client/src/breaking.rs | 2 + crates/horizon-client/src/clouds.rs | 2 + crates/horizon-client/src/entity.wgsl | 24 +++--- crates/horizon-client/src/entity_culling.rs | 2 + crates/horizon-client/src/fire_render.rs | 2 + crates/horizon-client/src/game.rs | 6 ++ .../horizon-client/src/game/armor_stands.rs | 1 + crates/horizon-client/src/game/creatures.rs | 4 + crates/horizon-client/src/game/dragon.rs | 6 ++ crates/horizon-client/src/game/end.rs | 4 + crates/horizon-client/src/game/fishing.rs | 2 + crates/horizon-client/src/game/frames.rs | 2 + crates/horizon-client/src/game/item_draw.rs | 19 +++++ crates/horizon-client/src/game/leads.rs | 2 + crates/horizon-client/src/game/maps.rs | 6 ++ crates/horizon-client/src/game/minecarts.rs | 1 + crates/horizon-client/src/game/mob_blocks.rs | 2 + crates/horizon-client/src/game/names.rs | 1 + crates/horizon-client/src/game/paintings.rs | 2 + crates/horizon-client/src/game/perspective.rs | 2 + .../horizon-client/src/game/text_displays.rs | 2 + crates/horizon-client/src/game/tnt.rs | 2 + crates/horizon-client/src/gfx.rs | 11 ++- crates/horizon-client/src/gfx/end_sky.rs | 2 + .../horizon-client/src/gfx/end_sky/tests.rs | 16 ++-- crates/horizon-client/src/gfx/entity_batch.rs | 2 + crates/horizon-client/src/gfx/lightning.rs | 2 + .../src/gfx/lightning/tests/mod.rs | 2 + crates/horizon-client/src/gfx/pack_weather.rs | 2 + crates/horizon-client/src/hud.rs | 38 ++++++++- crates/horizon-client/src/hud.wgsl | 14 ++-- crates/horizon-client/src/item_render.rs | 50 ++++++++++- crates/horizon-client/src/item_render/gui.rs | 83 ++++++++++--------- .../src/item_render/gui/depth.rs | 5 ++ .../horizon-client/src/item_render/special.rs | 1 + crates/horizon-client/src/mesher.rs | 2 + crates/horizon-client/src/mobs.rs | 3 +- crates/horizon-client/src/mobs/guardian.rs | 2 + crates/horizon-client/src/mobs/render.rs | 1 + crates/horizon-client/src/options_ui.rs | 12 +-- crates/horizon-client/src/particles.rs | 2 + crates/horizon-client/src/shadows.rs | 2 + 43 files changed, 280 insertions(+), 75 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 28a876d80..19af406e1 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -149,6 +149,8 @@ pub fn draw_part( layer: 0, color, light, + + glint_uv: [0.0, 0.0], }); } } @@ -648,6 +650,8 @@ fn draw_text(scene: &Scene, call: &TextCall, out: &mut Vec) { layer: 0, color: c, light: call.light, + + glint_uv: [0.0, 0.0], }); } } @@ -1714,6 +1718,8 @@ impl BeamPart { layer: 6, color, light: self.wrap, + + glint_uv: [0.0, 0.0], }); } } @@ -1784,6 +1790,7 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec) layer, color: 0, light: 0, + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/breaking.rs b/crates/horizon-client/src/breaking.rs index 84eedae75..df6d0f33b 100644 --- a/crates/horizon-client/src/breaking.rs +++ b/crates/horizon-client/src/breaking.rs @@ -49,6 +49,8 @@ pub fn geometry( color: 0xffff_ffff, light: stage_light(stage), normal: [0; 4], + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/clouds.rs b/crates/horizon-client/src/clouds.rs index 70f29c132..5e9bb731a 100644 --- a/crates/horizon-client/src/clouds.rs +++ b/crates/horizon-client/src/clouds.rs @@ -179,6 +179,8 @@ impl Mesh { layer: 4, color: u32::MAX, light: shade, + + glint_uv: [0.0, 0.0], }); } }; diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index 79e11719f..307f3fbba 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -44,6 +44,8 @@ struct Out { // entity.vsh's lightMapColor, multiplied in after the overlay. @location(9) light_color: vec4, @location(10) @interpolate(flat) weather_rect: vec4, + // The `GLINT_TEXTURING` sample for overlay 7 (item foil). + @location(11) glint_uv: vec2, } // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed. fn entity_light(normal: vec3, nether: bool) -> f32 { @@ -103,12 +105,16 @@ fn entity_vertex(position: vec3, uv: vec2, out.spherical = select(length(position), 0.0, overlay >= 2u && overlay <= 4u); out.cylindrical = select(max(length(position.xz), abs(position.y)), 0.0, overlay >= 2u && overlay <= 4u); out.overlay = overlay; + out.glint_uv = vec2(0.0); if overlay == 4u { out.spherical = length(position); } return out; } @vertex fn vs_entity(@location(0) position: vec3, @location(1) uv: vec2, - @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, @location(5) normal: vec4) -> Out { - return entity_vertex(position, uv, overlay, color, light, normal); + @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, + @location(5) normal: vec4, @location(6) glint_uv: vec2) -> Out { + var out = entity_vertex(position, uv, overlay, color, light, normal); + out.glint_uv = glint_uv; + return out; } // Retained bolt-local geometry, translated using the same f64 camera // subtraction as the former CPU path before adding each local f32 position. @@ -204,15 +210,11 @@ fn crumbling_uv(uv: vec2, packed_origin: vec2, sprite_size: vec2, color = vec4(mix(in.overlay_color.rgb, color.rgb, in.overlay_color.a), color.a); color *= in.light_color; if in.overlay == 7u || in.overlay == 8u { - // Enchantment glint (overlay 7, 8 with the hurt tint): the purple - // enchanted_glint sheen drifting diagonally over the item's shape. - let px = in.uv * vec2(textureDimensions(atlas)); - let t = globals.misc.y * 0.05; - let band = sin((px.x + px.y) * 0.9 - t * 6.0) * 0.5 + 0.5; - let band2 = sin((px.x - px.y) * 0.6 + t * 4.0) * 0.5 + 0.5; - let shimmer = pow(band * 0.6 + band2 * 0.4, 2.0); - let glint = vec3(0.50, 0.25, 0.80) * (0.25 + 0.75 * shimmer); - color = vec4(min(color.rgb + glint * 0.6, vec3(1.0)), color.a); + // Enchantment glint: item.fsh's GLINT path, sampled from + // enchanted_glint_item at the `GLINT_TEXTURING` UV. + let alpha = globals.fog_ends.w; + let glint = alpha * textureSample(atlas, atlas_sampler, in.glint_uv); + color = vec4(color.rgb + glint.rgb * glint.rgb, max(color.a, alpha)); } let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y), linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)); diff --git a/crates/horizon-client/src/entity_culling.rs b/crates/horizon-client/src/entity_culling.rs index 16de17465..0c309041a 100644 --- a/crates/horizon-client/src/entity_culling.rs +++ b/crates/horizon-client/src/entity_culling.rs @@ -186,6 +186,8 @@ mod tests { color: u32::MAX, light: 0, normal: [0; 4], + + glint_uv: [0.0, 0.0], }; let prior = vertex([0.0; 3]); let body = [vertex([8.0, -1.0, -1.0]), vertex([10.0, 1.0, 1.0])]; diff --git a/crates/horizon-client/src/fire_render.rs b/crates/horizon-client/src/fire_render.rs index c3a9f6a92..98eff6f9d 100644 --- a/crates/horizon-client/src/fire_render.rs +++ b/crates/horizon-client/src/fire_render.rs @@ -48,6 +48,8 @@ pub fn flames( color: 0xffff_ffff, light: 0xf000 | (u32::from(scene_light >> 4) * 16), normal: [0; 4], + + glint_uv: [0.0, 0.0], }); } remaining -= 0.45; diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 45fe3a8b1..91045ada5 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -7380,6 +7380,8 @@ impl Game<'_> { layer: 0, color, light: packed, + + glint_uv: [0.0, 0.0], }); } } @@ -7999,6 +8001,8 @@ impl Game<'_> { layer: 2, color, light: 0, + + glint_uv: [0.0, 0.0], }); } }; @@ -10801,6 +10805,7 @@ impl Game<'_> { debug_lines_on_top: &debug_lines_on_top, debug_crosshair: &debug_crosshair, hud: &hud, + glint_alpha: self.settings.file.double("glintStrength") as f32, clouds: (!title && self.dim == Dim::Overworld && horizon_client::clouds::visible(&self.settings.clouds, sky.cloud_color[3])) @@ -13478,6 +13483,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> { debug_lines_on_top: &[], debug_crosshair: &[], hud, + glint_alpha: 0.75, nether_lighting: false, entities: &[], entity_spans: &[], diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs index f175af401..92080b70c 100644 --- a/crates/horizon-client/src/game/armor_stands.rs +++ b/crates/horizon-client/src/game/armor_stands.rs @@ -872,6 +872,7 @@ impl Game<'_> { lights: Some(horizon_client::block_entity_render::diffuse_lights( self.dim == super::Dim::Nether, )), + glint: self.glint(), }; let profile = stack .extra diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 86a7954e9..366420557 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -145,6 +145,8 @@ fn flame_geometry( layer: 0, color: 0xFFFF_FFFF, light: packed, + + glint_uv: [0.0, 0.0], }); } h -= 0.45; @@ -3316,6 +3318,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light: packed, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index fff03ef1c..9cea0f48a 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -2482,6 +2482,8 @@ impl Game<'_> { layer: 2, color: c, light: 0, + + glint_uv: [0.0, 0.0], }); } } @@ -2547,6 +2549,8 @@ impl Game<'_> { layer: 6, color: c, light: wrap_light, + + glint_uv: [0.0, 0.0], }); } (last_sin, last_cos, last_u) = (sin, cos, uu); @@ -2592,6 +2596,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light: 240 | 240 << 8, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index 32d5113b0..6d845c259 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -247,6 +247,8 @@ impl Game<'_> { layer: 2, color, light: 0, + + glint_uv: [0.0, 0.0], }); } } @@ -1240,6 +1242,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light: full, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs index 39f9e5ffe..55c1d46fd 100644 --- a/crates/horizon-client/src/game/fishing.rs +++ b/crates/horizon-client/src/game/fishing.rs @@ -643,6 +643,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light: packed, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs index d08c5f283..b9ba0b1cc 100644 --- a/crates/horizon-client/src/game/frames.rs +++ b/crates/horizon-client/src/game/frames.rs @@ -377,6 +377,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light, + + glint_uv: [0.0, 0.0], }); } }; diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index b6b7e2fb7..580701ccd 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -296,8 +296,25 @@ impl Game<'_> { x, y, self.started.elapsed().as_secs_f32(), + self.settings.file.double("glintSpeed") as f32, + self.settings.file.double("glintStrength") as f32, ); } + /// The `GLINT_TEXTURING` inputs the atlas and options provide. + pub(super) fn glint(&self) -> Option { + self.gui + .atlas + .sprites + .get("misc/enchanted_glint_item") + .copied() + .map(|rect| item_render::Glint { + rect, + speed: self.settings.file.double("glintSpeed") as f32, + alpha: self.settings.file.double("glintStrength") as f32, + millis: self.started.elapsed().as_secs_f32() * 1000.0, + scale: 0.5, + }) + } /// Submit a resolved item under `pose` (camera-relative) at `light` /// (packed lightmap coordinates). pub(super) fn submit_item_world( @@ -311,6 +328,7 @@ impl Game<'_> { out, light, lights: Some(diffuse_lights(self.dim == Dim::Nether)), + glint: self.glint(), }; state.submit( &self.pack.item_renderer, @@ -332,6 +350,7 @@ impl Game<'_> { out, light, lights: None, + glint: self.glint(), }; state.submit( &self.pack.item_renderer, diff --git a/crates/horizon-client/src/game/leads.rs b/crates/horizon-client/src/game/leads.rs index 8867157ee..b14cc351a 100644 --- a/crates/horizon-client/src/game/leads.rs +++ b/crates/horizon-client/src/game/leads.rs @@ -381,6 +381,8 @@ impl Game<'_> { layer: 0, color, light: packed, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/maps.rs b/crates/horizon-client/src/game/maps.rs index 6da65c592..97e7996d0 100644 --- a/crates/horizon-client/src/game/maps.rs +++ b/crates/horizon-client/src/game/maps.rs @@ -1133,6 +1133,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light, + + glint_uv: [0.0, 0.0], }); } }; @@ -1180,6 +1182,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light, + + glint_uv: [0.0, 0.0], }); } }; @@ -1251,6 +1255,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 072059e49..eeedbc9f5 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -1297,6 +1297,7 @@ impl Game<'_> { layer: 0, color, light, + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/mob_blocks.rs b/crates/horizon-client/src/game/mob_blocks.rs index 083c96a66..5b26cd615 100644 --- a/crates/horizon-client/src/game/mob_blocks.rs +++ b/crates/horizon-client/src/game/mob_blocks.rs @@ -203,6 +203,8 @@ impl Game<'_> { layer: overlay, color, light, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index 9f7561e53..9bc3200ec 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -377,6 +377,7 @@ impl Game<'_> { layer, color, light, + glint_uv: [0.0, 0.0], }); } }; diff --git a/crates/horizon-client/src/game/paintings.rs b/crates/horizon-client/src/game/paintings.rs index 321e59f7d..1c0a74a47 100644 --- a/crates/horizon-client/src/game/paintings.rs +++ b/crates/horizon-client/src/game/paintings.rs @@ -308,6 +308,8 @@ impl Game<'_> { layer: 0, color, light: packed, + + glint_uv: [0.0, 0.0], }); } }; diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index caf49883b..a558dede2 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -710,6 +710,8 @@ mod preview_tests { color: u32::MAX, light: 0, normal: [0; 4], + + glint_uv: [0.0, 0.0], }) }; // A shield and arm can intersect: neither average depth orders both ends. diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs index 45bd64fa7..226046fec 100644 --- a/crates/horizon-client/src/game/text_displays.rs +++ b/crates/horizon-client/src/game/text_displays.rs @@ -268,6 +268,8 @@ impl Game<'_> { light, layer: if through { 2 } else { 0 }, normal: [0; 4], + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/tnt.rs b/crates/horizon-client/src/game/tnt.rs index 6bd2ae956..2e87fa185 100644 --- a/crates/horizon-client/src/game/tnt.rs +++ b/crates/horizon-client/src/game/tnt.rs @@ -332,6 +332,8 @@ impl Game<'_> { layer: if lit { 5 } else { 0 }, color, light: packed, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 70d882a98..bd3c0b59c 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -172,7 +172,8 @@ struct Globals { inverse_view: [[f32; 4]; 4], sunrise: [f32; 4], sun: [f32; 4], - /// x: sky fog end, y: cloud fog end, z: dark disc (camera below the horizon), w: unused. + /// x: sky fog end, y: cloud fog end, z: dark disc (camera below the horizon), + /// w: the glint strength (`GlintAlpha`). fog_ends: [f32; 4], /// Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png. end_portal_sprites: [[f32; 4]; 2], @@ -256,6 +257,9 @@ pub struct Frame<'a> { /// drawn after the hand at its projection, without the bob or fog. pub debug_crosshair: &'a [[f32; 8]], pub hud: &'a HudBatch, + /// `GlintAlpha` (accessibility Glint Strength); the entity shader uses it + /// for held/world items, independent of what the HUD batch last drew. + pub glint_alpha: f32, /// CardinalLighting.Type.NETHER, otherwise DEFAULT. pub nether_lighting: bool, /// Camera-relative entity geometry textured from the shared atlas. @@ -1724,7 +1728,7 @@ impl Renderer { usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); - let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; + let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2]; let entity_vertex = [Some(wgpu::VertexBufferLayout { array_stride: std::mem::size_of::() as u64, step_mode: wgpu::VertexStepMode::Vertex, @@ -3475,7 +3479,7 @@ impl Renderer { frame.fog.map_or(frame.distance.min(512.0), |f| f.sky_end), frame.fog.map_or(2048.0, |f| f.cloud_end), if frame.dark_disc { 1.0 } else { 0.0 }, - 0.0, + frame.glint_alpha, ], end_portal_sprites: frame.end_portal_sprites, crumbling_sprite: frame.crumbling_sprite, @@ -5222,6 +5226,7 @@ mod tests { color: 0xffff_ffff, light: id, normal: [0; 4], + glint_uv: [0.0, 0.0], }; 4] }; let entities: Vec<_> = [ diff --git a/crates/horizon-client/src/gfx/end_sky.rs b/crates/horizon-client/src/gfx/end_sky.rs index 15e9001fc..d74e053df 100644 --- a/crates/horizon-client/src/gfx/end_sky.rs +++ b/crates/horizon-client/src/gfx/end_sky.rs @@ -72,6 +72,8 @@ fn vertices(uv: [f32; 4]) -> Vec { layer: 2, color: 0xFF28_2828, light: 0, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/gfx/end_sky/tests.rs b/crates/horizon-client/src/gfx/end_sky/tests.rs index 61266003d..5cd2bcf7f 100644 --- a/crates/horizon-client/src/gfx/end_sky/tests.rs +++ b/crates/horizon-client/src/gfx/end_sky/tests.rs @@ -12,15 +12,15 @@ fn geometry_matches_pre_residency_vertex_snapshots() { for (uv, expected) in [ ( [0.0, 0.0, 1.0, 1.0], - "f7ee23457fc557b33ecf09c9afaf858f3d8907e108abf06055f627523f733536", + "82a9be3f3ed1f733017df2c81dc6dff163f67bf739c768e3fd0f90f00c7802f6", ), ( [0.125, 0.25, 0.375, 0.5], - "f74c4b8d23ec2b7c11b5752821d0733851bf11358f1b26f9448226ff62a6a318", + "05a058bd8e70cff900c8e1c81061892ed27866d86498ebe1e8ae5af4c3b770ef", ), ( [0.13, 0.27, 0.41, 0.59], - "f0aaa39c5b22168bdc7c6c329acb4d3598a2feb61ff7b6f2850b644682749b39", + "93064b9fd2e745da46b927b2625edc8a381bb8c6e20b0f0880e816c4c1745ec1", ), ] { let mut mesh = vertices(uv); @@ -31,10 +31,8 @@ fn geometry_matches_pre_residency_vertex_snapshots() { if n == 0.0 { 0.0 } else { n } }); } - assert_eq!( - format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh))), - expected - ); + let hash = format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh))); + assert_eq!(hash, expected); } } @@ -95,7 +93,7 @@ fn separate_draws_match_combined_celestial_pixels() { label: Some("End sky differential shader"), source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()), }); - let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2]; let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("End sky differential pipeline"), layout: None, @@ -305,6 +303,8 @@ fn separate_draws_match_combined_celestial_pixels() { color: level * 0x01010101, light: 0, normal: [0; 4], + + glint_uv: [0.0, 0.0], }) .to_vec() }; diff --git a/crates/horizon-client/src/gfx/entity_batch.rs b/crates/horizon-client/src/gfx/entity_batch.rs index 8153699fc..9d6c4bf65 100644 --- a/crates/horizon-client/src/gfx/entity_batch.rs +++ b/crates/horizon-client/src/gfx/entity_batch.rs @@ -130,6 +130,8 @@ mod tests { color: index as u32, light: (index * 3) as u32, normal: [1, 2, 3, 4], + + glint_uv: [0.0, 0.0], }) .collect() } diff --git a/crates/horizon-client/src/gfx/lightning.rs b/crates/horizon-client/src/gfx/lightning.rs index 251dbf00e..d979bb368 100644 --- a/crates/horizon-client/src/gfx/lightning.rs +++ b/crates/horizon-client/src/gfx/lightning.rs @@ -77,6 +77,8 @@ fn geometry(seed: i64, uv: [f32; 2]) -> Vec { layer: 2, color, light: 240 | 240 << 8, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/gfx/lightning/tests/mod.rs b/crates/horizon-client/src/gfx/lightning/tests/mod.rs index f89f402de..ccaf963a5 100644 --- a/crates/horizon-client/src/gfx/lightning/tests/mod.rs +++ b/crates/horizon-client/src/gfx/lightning/tests/mod.rs @@ -60,6 +60,8 @@ fn reference(seed: i64, at: [f64; 3], camera: DVec3, uv: [f32; 2]) -> Vec self.capacity { diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 2b6acda41..41eae1ec7 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -554,6 +554,8 @@ pub struct HudVertex { pub uv: [f32; 2], pub color: u32, pub depth: f32, + /// The glint sprite UV (`GLINT_TEXTURING`), unused unless `uv.x >= 2`. + pub glint_uv: [f32; 2], } /// The GUI Scale option (0 = auto). pub static GUI_SCALE: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0); @@ -569,6 +571,8 @@ pub struct HudBatch { pub blends: Vec<(std::ops::Range, Blend)>, /// The textures and time of the `Blend::EndPortal` runs. pub end_portal: EndPortalFill, + /// `options.glintStrength` for the glint pass (`GlintAlpha`). + pub glint_alpha: f32, /// Screen's first vertex: the preceding HUD is part of its blurred background. pub blur_at: u32, } @@ -620,6 +624,7 @@ impl HudBatch { patches: Vec::new(), blends: Vec::new(), end_portal: EndPortalFill::default(), + glint_alpha: 0.75, blur_at: 0, } } @@ -695,6 +700,26 @@ impl HudBatch { uv: uv[i], color, depth: 0.0, + glint_uv: [0.0, 0.0], + }); + } + } + /// A quad whose texture is the `GLINT_TEXTURING` sample at `glint_uv`; + /// `uv` is the item's atlas UV, which the shader masks by. + pub fn quad_glint( + &mut self, + p: [[f32; 2]; 4], + uv: [[f32; 2]; 4], + glint_uv: [[f32; 2]; 4], + color: u32, + ) { + for i in [0, 1, 2, 0, 2, 3] { + self.vertices.push(HudVertex { + pos: p[i], + uv: uv[i], + color, + depth: 0.0, + glint_uv: glint_uv[i], }); } } @@ -705,6 +730,7 @@ impl HudBatch { uv: uv[i], color, depth: p[i][2], + glint_uv: [0.0, 0.0], }); } } @@ -875,6 +901,7 @@ impl HudBatch { uv, color: c[i], depth: 0.0, + glint_uv: [0.0, 0.0], }); } } @@ -1122,7 +1149,8 @@ impl HudRenderer { bind_group_layouts: &[Some(&layout)], ..Default::default() }); - let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32]; + let attributes = + wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32,4=>Float32x2]; let create = |label, blend, fragment_entry, depth: bool| { device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some(label), @@ -1337,7 +1365,12 @@ impl HudRenderer { &self.uniform, 0, bytemuck::bytes_of(&HudUniform::new( - [size[0] as f32, size[1] as f32, batch.scale, 0.0], + [ + size[0] as f32, + size[1] as f32, + batch.scale, + batch.glint_alpha, + ], batch.end_portal, )), ); @@ -1787,6 +1820,7 @@ mod tests { patches: Vec::new(), blends: Vec::new(), end_portal: EndPortalFill::default(), + glint_alpha: 0.75, blur_at: 0, }; for (image_width, image_height) in [(195, 136), (176, 166), (176, 222)] { diff --git a/crates/horizon-client/src/hud.wgsl b/crates/horizon-client/src/hud.wgsl index ebb6dc2cb..1f6d5797e 100644 --- a/crates/horizon-client/src/hud.wgsl +++ b/crates/horizon-client/src/hud.wgsl @@ -13,22 +13,26 @@ struct Out { @location(1) color: vec4, // projection_from_position(gl_Position): the End portal's texProj0. @location(2) proj: vec4, + @location(3) glint_uv: vec2, } -@vertex fn vs_main(@location(0) pos: vec2, @location(1) uv: vec2, @location(2) color: vec4, @location(3) depth: f32) -> Out { +@vertex fn vs_main(@location(0) pos: vec2, @location(1) uv: vec2, @location(2) color: vec4, @location(3) depth: f32, @location(4) glint_uv: vec2) -> Out { let pixels = pos * hud.size.z; var out: Out; out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, depth, 1.0); out.uv = uv; out.color = color; out.proj = vec4(out.clip.xy * 0.5 + 0.5, out.clip.zw); + out.glint_uv = glint_uv; return out; } @fragment fn fs_main(in: Out) -> @location(0) vec4 { - // u >= 2: flat vertex colour masked by the texture's alpha (enchantment glint). + // u >= 2: the GLINT_TEXTURING sample over the item, masked by the item's + // texture alpha (item.fsh's ALPHA_CUTOUT and GLINT path). if in.uv.x >= 2.0 { - let m = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a * in.color.a; - if m < 0.004 { discard; } - return vec4(in.color.rgb, m); + let mask = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a; + if mask < 0.1 { discard; } + let glint = hud.size.w * textureSample(atlas, atlas_sampler, in.glint_uv); + return vec4(glint.rgb * glint.rgb, mask); } let c = textureSample(atlas, atlas_sampler, in.uv) * in.color; if c.a < 0.004 { discard; } diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs index 4f981b874..0a72b2ecc 100644 --- a/crates/horizon-client/src/item_render.rs +++ b/crates/horizon-client/src/item_render.rs @@ -41,12 +41,48 @@ use std::{ pub struct ItemQuad { pub pos: [Vec3; 4], pub uv: [[f32; 2]; 4], + /// The model UVs `GLINT_TEXTURING` scrolls for the glint (vanilla's UV0, + /// or UV3 for a special model). + pub foil_uv: [[f32; 2]; 4], pub normal: Vec3, pub color: u32, pub foil: Foil, /// `MaterialInfo.lightEmission` (block light floor). pub light_emission: u8, } +/// `TextureTransform.setupGlintTexturing`'s inputs and the glint sprite. +#[derive(Clone, Copy, Debug)] +pub struct Glint { + pub rect: crate::hud::Rect, + /// `options.glintSpeed` (vanilla default 0.5). + pub speed: f32, + /// `options.glintStrength` / shader `GlintAlpha` (vanilla default 0.75). + pub alpha: f32, + /// `Util.getMillis()`. + pub millis: f32, + /// The transform's scale: `GLINT_TEXTURING`'s 8.0 for GUI items, + /// `ENTITY_GLINT_TEXTURING`'s 0.5 for items in the world. + pub scale: f32, +} +impl Glint { + /// `TextureTransform.setupGlintTexturing(scale)`: translation(-o0, o1) * + /// rotateZ(PI/18) * scale, wrapped and mapped into the glint sprite. + pub fn atlas_uv(&self, model: [f32; 2]) -> [f32; 2] { + let millis = (f64::from(self.millis) * f64::from(self.speed) * 8.0) as i64; + let offset0 = (millis % 110000) as f32 / 110000.0; + let offset1 = (millis % 30000) as f32 / 30000.0; + let angle = std::f32::consts::PI / 18.0; + let (sin, cos) = angle.sin_cos(); + let x = model[0] * self.scale * cos - model[1] * self.scale * sin - offset0; + let y = model[0] * self.scale * sin + model[1] * self.scale * cos + offset1; + let u = (x - x.floor()).clamp(0.5 / self.rect.w as f32, 1.0 - 0.5 / self.rect.w as f32); + let v = (y - y.floor()).clamp(0.5 / self.rect.h as f32, 1.0 - 0.5 / self.rect.h as f32); + [ + self.rect.u0 + u * (self.rect.u1 - self.rect.u0), + self.rect.v0 + v * (self.rect.v1 - self.rect.v0), + ] + } +} /// Which glint render type a quad uses. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Foil { @@ -242,6 +278,7 @@ fn submit_quads( sink.quad(ItemQuad { pos, uv, + foil_uv: q.uv, normal: transform_normal(m, direction_vector(q.facing)), color: argb(color), foil, @@ -679,6 +716,8 @@ pub struct WorldSink<'a> { pub light: u32, /// The level's diffuse lights; `None` leaves the colour unshaded. pub lights: Option<(Vec3, Vec3)>, + /// The `GLINT_TEXTURING` sample for foil quads (`None` leaves them unglinted). + pub glint: Option, } impl ItemSink for WorldSink<'_> { fn quad(&mut self, q: ItemQuad) { @@ -693,8 +732,14 @@ impl ItemSink for WorldSink<'_> { } else { self.light }; - let overlay = if q.foil == Foil::None { 0 } else { 7 }; - for (p, uv) in q.pos.iter().zip(q.uv) { + let glint = if q.foil == Foil::None { + None + } else { + self.glint + }; + let overlay = if glint.is_some() { 7 } else { 0 }; + for (i, (p, uv)) in q.pos.iter().zip(q.uv).enumerate() { + let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.atlas_uv(q.foil_uv[i])); self.out.push(Vertex { normal: [0; 4], pos: p.to_array(), @@ -702,6 +747,7 @@ impl ItemSink for WorldSink<'_> { layer: overlay, color, light, + glint_uv, }); } } diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs index ff25fff1d..87dfb354e 100644 --- a/crates/horizon-client/src/item_render/gui.rs +++ b/crates/horizon-client/src/item_render/gui.rs @@ -5,7 +5,7 @@ //! drawn far to near, and clipped to the item's 16x16 slot unless the model //! is oversized in the GUI (`GuiItemAtlas` draws each item into a scissored //! 16x16 slot; oversized items get a picture-in-picture of their bounds). -use super::{Foil, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost}; +use super::{Foil, Glint, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost}; use crate::hud::{HudBatch, Rect}; use glam::{EulerRot, Mat4, Vec2, Vec3}; use std::{collections::HashMap, f32::consts::PI, sync::Arc}; @@ -43,6 +43,7 @@ pub fn items_3d_lights() -> (Vec3, Vec3) { struct Point { p: Vec2, uv: [f32; 2], + glint_uv: [f32; 2], } fn lerp(a: Point, b: Point, t: f32) -> Point { Point { @@ -51,6 +52,10 @@ fn lerp(a: Point, b: Point, t: f32) -> Point { a.uv[0] + (b.uv[0] - a.uv[0]) * t, a.uv[1] + (b.uv[1] - a.uv[1]) * t, ], + glint_uv: [ + a.glint_uv[0] + (b.glint_uv[0] - a.glint_uv[0]) * t, + a.glint_uv[1] + (b.glint_uv[1] - a.glint_uv[1]) * t, + ], } } /// Sutherland-Hodgman against one half plane `dot(p, n) <= limit`. @@ -97,37 +102,25 @@ pub fn lit_color(q: &ItemQuad, lights: (Vec3, Vec3)) -> u32 { let c = |v: u8| (f32::from(v) * light) as u8; crate::hud::rgba(c(r), c(g), c(b), a) } -/// The glint's moving sheen at a GUI position (a stand-in for the -/// `GLINT_TEXTURING`-scrolled `enchanted_glint_item` texture added on top). -fn glint_color(p: Vec2, time: f32) -> u32 { - let d = ((p.x + p.y) / 32.0 - time * 0.35).rem_euclid(1.0); - let band = (1.0 - (d - 0.5).abs() * 6.0).max(0.0); - crate::hud::rgba( - (170.0 + 70.0 * band) as u8, - (90.0 + 110.0 * band) as u8, - 255, - (45.0 + 110.0 * band) as u8, - ) -} - -fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: bool) { - let shift = if glint { 2.0 } else { 0.0 }; +fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: Option<&Glint>) { for i in 1..fan.len().saturating_sub(1) { let (a, b, c) = (fan[0], fan[i], fan[i + 1]); let corners = [a, b, c, c]; - // `HudBatch.quad` draws (0, 1, 2) and (0, 2, 3): the second is empty. - batch.quad( - corners.map(|v| v.p.to_array()), - corners.map(|v| [v.uv[0] + shift, v.uv[1]]), - color(a.p), - ); - if glint { - // Per-vertex colours are flat per quad in the HUD batch: use the - // fan centre for the sheen. - let n = batch.vertices.len(); - for v in &mut batch.vertices[n - 6..] { - v.color = color(Vec2::from(v.pos)); - } + if let Some(glint) = glint { + let start = batch.vertices.len(); + batch.quad_glint( + corners.map(|v| v.p.to_array()), + corners.map(|v| [v.uv[0] + 2.0, v.uv[1]]), + corners.map(|v| glint.atlas_uv(v.glint_uv)), + u32::MAX, + ); + batch.blend_since(start, crate::hud::Blend::Additive); + } else { + batch.quad( + corners.map(|v| v.p.to_array()), + corners.map(|v| v.uv), + color(a.p), + ); } } } @@ -144,6 +137,8 @@ pub fn draw( x: f32, y: f32, time: f32, + glint_speed: f32, + glint_alpha: f32, ) { if state.is_empty() { return; @@ -256,7 +251,18 @@ fn draw_now( } else { [x, y, x + 16.0, y + 16.0] }; - draw_quads(&quads, lights, batch, rect, time); + let glint = sprites + .get("misc/enchanted_glint_item") + .copied() + .map(|rect| Glint { + rect, + speed: glint_speed, + alpha: glint_alpha, + millis: time * 1000.0, + scale: 8.0, + }); + batch.glint_alpha = glint_alpha; + draw_quads(&quads, lights, batch, rect, glint.as_ref()); } /// Lights, culls, sorts far to near and clips `quads` (GUI positions) to @@ -266,7 +272,7 @@ fn draw_quads( lights: (Vec3, Vec3), batch: &mut HudBatch, rect: [f32; 4], - time: f32, + glint: Option<&Glint>, ) { for face in depth::sort(quads) { let q = &quads[face.quad]; @@ -276,6 +282,7 @@ fn draw_quads( .map(|v| Point { p: v.pos.truncate(), uv: v.uv, + glint_uv: v.glint_uv, }) .collect(); let color = lit_color(q, lights); @@ -285,9 +292,9 @@ fn draw_quads( if fan.len() < 3 { continue; } - emit(batch, &fan, |_| color, false); + emit(batch, &fan, |_| color, None); if q.foil != Foil::None { - emit(batch, &fan, |p| glint_color(p, time), true); + emit(batch, &fan, |_| color, glint); } } } @@ -342,7 +349,7 @@ pub fn draw_banner_result( items_flat_lights(), batch, [x0, y0, x0 + 20.0, y0 + 40.0], - 0.0, + None, ); } @@ -354,6 +361,7 @@ mod tests { ItemQuad { pos: [(0.0, y0), (0.0, y1), (8.0, y1), (8.0, y0)].map(|(x, y)| Vec3::new(x, y, z(y))), uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]], + foil_uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]], normal: Vec3::Z, color, foil: Foil::None, @@ -394,7 +402,7 @@ mod tests { (Vec3::Z, Vec3::Z), &mut batch, [0.0, 0.0, 16.0, 16.0], - 0.0, + None, ); assert_eq!(color_at(&batch, Vec2::new(4.0, 0.5)), Some(u32::MAX)); } @@ -410,7 +418,7 @@ mod tests { (Vec3::Z, Vec3::Z), &mut batch, [0.0, 0.0, 16.0, 16.0], - 0.0, + None, ); assert_eq!( color_at(&batch, Vec2::new(4.0, 2.0)), @@ -442,7 +450,7 @@ mod tests { (Vec3::Z, Vec3::Z), &mut batch, [0.0, 0.0, 16.0, 16.0], - 0.0, + None, ); for y in [0.5, 6.0] { assert_eq!( @@ -468,6 +476,7 @@ mod tests { let p = |x: f32, y: f32| Point { p: Vec2::new(x, y), uv: [x, y], + glint_uv: [0.0, 0.0], }; let fan = clip_triangle( [p(-4.0, 0.0), p(8.0, 0.0), p(8.0, 8.0)], diff --git a/crates/horizon-client/src/item_render/gui/depth.rs b/crates/horizon-client/src/item_render/gui/depth.rs index 9fecfdee7..aaaa0c55d 100644 --- a/crates/horizon-client/src/item_render/gui/depth.rs +++ b/crates/horizon-client/src/item_render/gui/depth.rs @@ -10,6 +10,7 @@ use glam::{Vec3, Vec4}; pub(super) struct Corner { pub pos: Vec3, pub uv: [f32; 2], + pub glint_uv: [f32; 2], } pub(super) struct Face { @@ -38,6 +39,9 @@ fn split(face: Face, distances: &[f32]) -> (Face, Face) { let corner = Corner { pos: a.pos.lerp(b.pos, t), uv: std::array::from_fn(|k| a.uv[k] + (b.uv[k] - a.uv[k]) * t), + glint_uv: std::array::from_fn(|k| { + a.glint_uv[k] + (b.glint_uv[k] - a.glint_uv[k]) * t + }), }; back.push(corner); front.push(corner); @@ -73,6 +77,7 @@ pub(super) fn sort(quads: &[ItemQuad]) -> Vec { corners: std::array::from_fn::<_, 4, _>(|k| Corner { pos: q.pos[k], uv: q.uv[k], + glint_uv: q.foil_uv[k], }) .to_vec(), }) diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs index d42378db1..6d8477ead 100644 --- a/crates/horizon-client/src/item_render/special.rs +++ b/crates/horizon-client/src/item_render/special.rs @@ -115,6 +115,7 @@ fn draw( sprite.v0 + (sprite.v1 - sprite.v0) * v[4], ] }), + foil_uv: poly.map(|v| [v[3], v[4]]), normal, color, foil, diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index 48d2f08bd..7594e7e31 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -38,6 +38,8 @@ pub struct Vertex { pub light: u32, /// RGBA8_SNORM face normal; w = -127 for two-sided lighting, 0 to keep baked/unlit colour. pub normal: [i8; 4], + /// The `GLINT_TEXTURING` atlas UV for a foil item quad; zero elsewhere. + pub glint_uv: [f32; 2], } /// A section vertex: vanilla's `DefaultVertexFormat.BLOCK` (position, colour, /// UV0, UV2) with the sprite's array layer beside the light, in 24 bytes diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 6b1e16f5c..61db8c909 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -2013,6 +2013,7 @@ pub fn render_model( layer: overlay, color: 0xFFFF_FFFF, light, + glint_uv: [0.0, 0.0], }); } } @@ -2147,7 +2148,7 @@ mod lighting_tests { #[test] fn packed_normal_uses_native_snorm_bytes_without_changing_vertex_offsets() { assert_eq!(std::mem::offset_of!(Vertex, normal), 32); - assert_eq!(std::mem::size_of::(), 36); + assert_eq!(std::mem::size_of::(), 44); let part = plane([0.0, 1.0, 0.0]); assert_eq!( part.polygons[0].vertex_normal(ModelNormals::new(Mat4::from_scale(Vec3::ZERO))), diff --git a/crates/horizon-client/src/mobs/guardian.rs b/crates/horizon-client/src/mobs/guardian.rs index 9704de044..e57e6ee9f 100644 --- a/crates/horizon-client/src/mobs/guardian.rs +++ b/crates/horizon-client/src/mobs/guardian.rs @@ -396,6 +396,8 @@ pub fn beam_geometry( layer: 0, color, light: 240 | 240 << 8, + + glint_uv: [0.0, 0.0], }); }; // Sides: one quad per texture repeat. diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 077fd38a6..8620d88f5 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -968,6 +968,7 @@ fn draw_normals( layer: overlay, color, light, + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 61fda9878..cd26f2203 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -167,8 +167,6 @@ impl Opt { | Opt::NarratorHotkey | Opt::ChatDelay | Opt::DistortionEffects - | Opt::GlintSpeed - | Opt::GlintStrength | Opt::MonochromeLogo | Opt::RotateWithMinecarts | Opt::HighContrastBlockOutlines @@ -625,10 +623,12 @@ impl Opt { self.file_key().unwrap(), crate::options_file::V::Double(f64::from(v).powi(2)), ), - Opt::DamageTilt | Opt::PanoramaSpeed => s.file.set( - self.file_key().unwrap(), - crate::options_file::V::Double(f64::from(v)), - ), + Opt::DamageTilt | Opt::PanoramaSpeed | Opt::GlintSpeed | Opt::GlintStrength => { + s.file.set( + self.file_key().unwrap(), + crate::options_file::V::Double(f64::from(v)), + ) + } Opt::Fov => s.fov = step(30.0, 110.0), Opt::RenderDistance => s.render_distance = step(2.0, 64.0) as i32, Opt::SimulationDistance => s.simulation_distance = step(5.0, 32.0) as i32, diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs index fa9dc9c6e..23679cfb7 100644 --- a/crates/horizon-client/src/particles.rs +++ b/crates/horizon-client/src/particles.rs @@ -3946,6 +3946,8 @@ impl ParticleEngine { }, color, light, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/shadows.rs b/crates/horizon-client/src/shadows.rs index dece7f726..613eb0bb1 100644 --- a/crates/horizon-client/src/shadows.rs +++ b/crates/horizon-client/src/shadows.rs @@ -119,6 +119,8 @@ pub fn shadow( layer: crate::gfx::SHADOW_OVERLAY, color, light: 240 | 240 << 8, + + glint_uv: [0.0, 0.0], }); } } From a1761dcb658b8ac5401251320e3d18237067e42d Mon Sep 17 00:00:00 2001 From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com> Date: Tue, 27 Oct 2026 00:57:16 +0800 Subject: [PATCH 059/105] Lightning: move the bolt offset to vertex attribute 7 The retained bolt offset and the entity vertex's new glint UV were both declared at attribute location 6, and the lightning pipeline builds its vertex buffers from the entity layout plus the bolt-offset instance buffer, so Device::create_render_pipeline rejected the location clash and the client crashed at startup. Co-Authored-By: ZCode --- crates/horizon-client/src/entity.wgsl | 3 ++- crates/horizon-client/src/gfx.rs | 3 ++- crates/horizon-client/src/gfx/lightning/tests/mod.rs | 5 +++-- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index 307f3fbba..2e7abda21 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -118,9 +118,10 @@ fn entity_vertex(position: vec3, uv: vec2, } // Retained bolt-local geometry, translated using the same f64 camera // subtraction as the former CPU path before adding each local f32 position. +// The bolt offset is instance attribute 7: 6 is the entity vertex's glint UV. @vertex fn vs_lightning(@location(0) position: vec3, @location(1) uv: vec2, @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, @location(5) normal: vec4, - @location(6) offset: vec3) -> Out { + @location(7) offset: vec3) -> Out { return entity_vertex(offset + position, uv, overlay, color, light, normal); } struct CloudInfo { diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index bd3c0b59c..bd2b932f0 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -1869,7 +1869,8 @@ impl Renderer { alpha_blend, false, ); - let lightning_attributes = wgpu::vertex_attr_array![6=>Float32x3]; + // Attribute 7: 6 is the entity vertex buffer's glint UV. + let lightning_attributes = wgpu::vertex_attr_array![7=>Float32x3]; let lightning_vertex = [ entity_vertex[0].clone(), Some(wgpu::VertexBufferLayout { diff --git a/crates/horizon-client/src/gfx/lightning/tests/mod.rs b/crates/horizon-client/src/gfx/lightning/tests/mod.rs index ccaf963a5..66959ce54 100644 --- a/crates/horizon-client/src/gfx/lightning/tests/mod.rs +++ b/crates/horizon-client/src/gfx/lightning/tests/mod.rs @@ -227,8 +227,9 @@ fn retained_gpu_draw_matches_transient_additive_draw() { label: Some("Lightning differential shader"), source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()), }); - let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; - let offsets = wgpu::vertex_attr_array![6=>Float32x3]; + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2]; + // Attribute 7: 6 is the entity vertex buffer's glint UV. + let offsets = wgpu::vertex_attr_array![7=>Float32x3]; let vertices = [Some(wgpu::VertexBufferLayout { array_stride: std::mem::size_of::() as u64, step_mode: wgpu::VertexStepMode::Vertex, From 1c6c6c0b97ae6144bf476d76962d744c6d29a815 Mon Sep 17 00:00:00 2001 From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com> Date: Tue, 27 Oct 2026 01:45:23 +0800 Subject: [PATCH 060/105] Items: sample the glint from its own repeating texture Vanilla's GlintSampler repeats enchanted_glint_item per pixel, and the GLINT transform's scale 8 spans about 8 repeats across an item. Folding the UV per vertex into the shared atlas could only interpolate between the four corners, so the pattern rendered as one wide diagonal band instead of the texture's fine weave. The glint now binds as its own 128x128 texture with a repeat, linear, mip-free sampler (the texture's mcmeta: clamp false, blur true) in the HUD and entity pipelines, and `Glint` passes the unwrapped `GLINT_TEXTURING` UV through. Co-Authored-By: ZCode --- crates/horizon-client/src/entity.wgsl | 5 +- crates/horizon-client/src/game.rs | 7 ++ crates/horizon-client/src/game/item_draw.rs | 3 +- crates/horizon-client/src/gfx.rs | 71 +++++++++++++++++++- crates/horizon-client/src/hud.rs | 43 +++++++++++- crates/horizon-client/src/hud.wgsl | 5 +- crates/horizon-client/src/item_render.rs | 21 +++--- crates/horizon-client/src/item_render/gui.rs | 23 +++++-- 8 files changed, 154 insertions(+), 24 deletions(-) diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index 2e7abda21..993f86947 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -27,6 +27,9 @@ struct Globals { @group(0) @binding(2) var atlas_sampler: sampler; @group(0) @binding(3) var lightmap: texture_2d; @group(0) @binding(4) var lightmap_sampler: sampler; +// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler). +@group(0) @binding(5) var glint_tex: texture_2d; +@group(0) @binding(6) var glint_sampler: sampler; struct Out { @builtin(position) clip: vec4, @location(0) uv: vec2, @@ -214,7 +217,7 @@ fn crumbling_uv(uv: vec2, packed_origin: vec2, sprite_size: vec2, // Enchantment glint: item.fsh's GLINT path, sampled from // enchanted_glint_item at the `GLINT_TEXTURING` UV. let alpha = globals.fog_ends.w; - let glint = alpha * textureSample(atlas, atlas_sampler, in.glint_uv); + let glint = alpha * textureSample(glint_tex, glint_sampler, in.glint_uv); color = vec4(color.rgb + glint.rgb * glint.rgb, max(color.a, alpha)); } let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y), diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 91045ada5..f4663c844 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -13385,6 +13385,7 @@ fn build_renderer( &assets.sprite_mips, &assets.animations, (&atlas.pixels, atlas.width, atlas.height), + (&atlas.glint.0, atlas.glint.1, atlas.glint.2), (&pack.forcefield.2, pack.forcefield.0), &gui.panorama, prepared, @@ -13411,6 +13412,7 @@ fn loading_renderer( ) -> Result { static FORCEFIELD: [u8; 4] = [0; 4]; static EMPTY_HUD: [u8; 4] = [0, 0, 0, 255]; + static EMPTY_GLINT: [u8; 4] = [0; 4]; let empty_panorama = horizon_client::gfx::panorama::Faces { size: 1, pixels: [0u8; 4].repeat(6), @@ -13421,6 +13423,10 @@ fn loading_renderer( Some(atlas) => (atlas.pixels.as_slice(), atlas.width, atlas.height), None => (EMPTY_HUD.as_slice(), 1, 1), }; + let (glint_pixels, glint_width, glint_height) = match atlas { + Some(atlas) => (atlas.glint.0.as_slice(), atlas.glint.1, atlas.glint.2), + None => (EMPTY_GLINT.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`). @@ -13437,6 +13443,7 @@ fn loading_renderer( &[], &[], (pixels, width, height), + (glint_pixels, glint_width, glint_height), (&FORCEFIELD[..], 1), panorama, None, diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index 580701ccd..2dac91f77 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -307,8 +307,7 @@ impl Game<'_> { .sprites .get("misc/enchanted_glint_item") .copied() - .map(|rect| item_render::Glint { - rect, + .map(|_| item_render::Glint { speed: self.settings.file.double("glintSpeed") as f32, alpha: self.settings.file.double("glintStrength") as f32, millis: self.started.elapsed().as_secs_f32() * 1000.0, diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index bd2b932f0..339f7e7c2 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -1023,6 +1023,7 @@ impl Renderer { sprite_mips: &[crate::mipmap::Settings], animations: &[SpriteAnimation], hud_atlas: (&[u8], u32, u32), + glint: (&[u8], u32, u32), forcefield: (&[u8], u32), panorama_faces: &panorama::Faces, prepared: Option, @@ -1576,7 +1577,45 @@ impl Renderer { atlas_pixels, ); let atlas_view = atlas.create_view(&Default::default()); - let mut hud = HudRenderer::new(&device, config.format.remove_srgb_suffix(), &atlas_view)?; + // vanilla's `GlintSampler`: enchanted_glint_item as its own texture, + // repeated per pixel (`clamp: false`), linear without mipmaps + // (`blur: true`). + let (glint_pixels, glint_width, glint_height) = glint; + let glint_texture = device.create_texture_with_data( + &queue, + &wgpu::TextureDescriptor { + label: Some("Enchanted glint"), + size: wgpu::Extent3d { + width: glint_width, + height: glint_height, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }, + wgpu::util::TextureDataOrder::LayerMajor, + glint_pixels, + ); + let glint_view = glint_texture.create_view(&Default::default()); + let glint_sampler = device.create_sampler(&wgpu::SamplerDescriptor { + label: Some("Glint"), + address_mode_u: wgpu::AddressMode::Repeat, + address_mode_v: wgpu::AddressMode::Repeat, + mag_filter: wgpu::FilterMode::Linear, + min_filter: wgpu::FilterMode::Linear, + ..Default::default() + }); + let mut hud = HudRenderer::new( + &device, + config.format.remove_srgb_suffix(), + &atlas_view, + &glint_view, + &glint_sampler, + )?; hud.atlas_texture = Some(atlas.clone()); let entity_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Horizon entities"), @@ -1622,6 +1661,20 @@ impl Renderer { vf, wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), ), + entry( + 5, + vf, + wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: true }, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + ), + entry( + 6, + vf, + wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), + ), ], }); let weather = weather::Weather::new( @@ -1658,6 +1711,14 @@ impl Renderer { binding: 4, resource: wgpu::BindingResource::Sampler(&lightmap_sampler), }, + wgpu::BindGroupEntry { + binding: 5, + resource: wgpu::BindingResource::TextureView(&glint_view), + }, + wgpu::BindGroupEntry { + binding: 6, + resource: wgpu::BindingResource::Sampler(&glint_sampler), + }, ], }); let hand_group = device.create_bind_group(&wgpu::BindGroupDescriptor { @@ -1684,6 +1745,14 @@ impl Renderer { binding: 4, resource: wgpu::BindingResource::Sampler(&lightmap_sampler), }, + wgpu::BindGroupEntry { + binding: 5, + resource: wgpu::BindingResource::TextureView(&glint_view), + }, + wgpu::BindGroupEntry { + binding: 6, + resource: wgpu::BindingResource::Sampler(&glint_sampler), + }, ], }); let entity_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 41eae1ec7..7f0d31ab0 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -67,6 +67,9 @@ pub struct HudAtlas { pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>, /// The default font (bitmap sheets in this atlas, unifont rasterized on demand). pub font: crate::font::Font, + /// `misc/enchanted_glint_item` as its own image: vanilla's `GlintSampler` + /// repeats it per pixel, which one sprite inside this atlas cannot. + pub glint: (Vec, u32, u32), white: Rect, } /// Atlas rows reserved for glyphs rasterized at run time. @@ -526,6 +529,7 @@ impl HudAtlas { } } let white = sprites["horizon/white"]; + let glint = Self::glint_texture(root, defaults); let font = crate::font::Font::load( root, &sprites, @@ -542,10 +546,20 @@ impl HudAtlas { translucent, flags, fire_animations, + glint, font, white, }) } + /// `misc/enchanted_glint_item.png` on its own, or a transparent texel if + /// the resource pack lacks it. + fn glint_texture(root: &Path, defaults: &Path) -> (Vec, u32, u32) { + let mut path = root.join("assets/minecraft/textures/misc/enchanted_glint_item.png"); + if !path.exists() && defaults != root { + path = defaults.join("assets/minecraft/textures/misc/enchanted_glint_item.png"); + } + decode(&path).map_or((vec![0; 4], 1, 1), |(w, h, pixels)| (pixels, w, h)) + } } #[repr(C)] #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)] @@ -554,7 +568,8 @@ pub struct HudVertex { pub uv: [f32; 2], pub color: u32, pub depth: f32, - /// The glint sprite UV (`GLINT_TEXTURING`), unused unless `uv.x >= 2`. + /// The `GLINT_TEXTURING` UV into the repeating glint texture, unused + /// unless `uv.x >= 2`. pub glint_uv: [f32; 2], } /// The GUI Scale option (0 = auto). @@ -1080,6 +1095,8 @@ impl HudRenderer { device: &wgpu::Device, format: wgpu::TextureFormat, view: &wgpu::TextureView, + glint_view: &wgpu::TextureView, + glint_sampler: &wgpu::Sampler, ) -> Result { let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Horizon HUD"), @@ -1124,6 +1141,22 @@ impl HudRenderer { ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), count: None, }, + wgpu::BindGroupLayoutEntry { + binding: 3, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: true }, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + count: None, + }, + wgpu::BindGroupLayoutEntry { + binding: 4, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), + count: None, + }, ], }); let group = device.create_bind_group(&wgpu::BindGroupDescriptor { @@ -1142,6 +1175,14 @@ impl HudRenderer { binding: 2, resource: wgpu::BindingResource::Sampler(&sampler), }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::TextureView(glint_view), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: wgpu::BindingResource::Sampler(glint_sampler), + }, ], }); let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { diff --git a/crates/horizon-client/src/hud.wgsl b/crates/horizon-client/src/hud.wgsl index 1f6d5797e..435f7f062 100644 --- a/crates/horizon-client/src/hud.wgsl +++ b/crates/horizon-client/src/hud.wgsl @@ -7,6 +7,9 @@ struct Hud { @group(0) @binding(0) var hud: Hud; @group(0) @binding(1) var atlas: texture_2d; @group(0) @binding(2) var atlas_sampler: sampler; +// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler). +@group(0) @binding(3) var glint_tex: texture_2d; +@group(0) @binding(4) var glint_sampler: sampler; struct Out { @builtin(position) clip: vec4, @location(0) uv: vec2, @@ -31,7 +34,7 @@ struct Out { if in.uv.x >= 2.0 { let mask = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a; if mask < 0.1 { discard; } - let glint = hud.size.w * textureSample(atlas, atlas_sampler, in.glint_uv); + let glint = hud.size.w * textureSample(glint_tex, glint_sampler, in.glint_uv); return vec4(glint.rgb * glint.rgb, mask); } let c = textureSample(atlas, atlas_sampler, in.uv) * in.color; diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs index 0a72b2ecc..76b13dbca 100644 --- a/crates/horizon-client/src/item_render.rs +++ b/crates/horizon-client/src/item_render.rs @@ -50,10 +50,9 @@ pub struct ItemQuad { /// `MaterialInfo.lightEmission` (block light floor). pub light_emission: u8, } -/// `TextureTransform.setupGlintTexturing`'s inputs and the glint sprite. +/// `TextureTransform.setupGlintTexturing`'s inputs. #[derive(Clone, Copy, Debug)] pub struct Glint { - pub rect: crate::hud::Rect, /// `options.glintSpeed` (vanilla default 0.5). pub speed: f32, /// `options.glintStrength` / shader `GlintAlpha` (vanilla default 0.75). @@ -65,21 +64,19 @@ pub struct Glint { pub scale: f32, } impl Glint { - /// `TextureTransform.setupGlintTexturing(scale)`: translation(-o0, o1) * - /// rotateZ(PI/18) * scale, wrapped and mapped into the glint sprite. - pub fn atlas_uv(&self, model: [f32; 2]) -> [f32; 2] { + /// `TextureTransform.setupGlintTexturing(scale)` applied to the model UV: + /// translation(-o0, o1) * rotateZ(PI/18) * scale. The result repeats: + /// the shader samples the dedicated glint texture with vanilla's + /// repeating `GlintSampler`, so the UVs stay unwrapped. + pub fn uv(&self, model: [f32; 2]) -> [f32; 2] { let millis = (f64::from(self.millis) * f64::from(self.speed) * 8.0) as i64; let offset0 = (millis % 110000) as f32 / 110000.0; let offset1 = (millis % 30000) as f32 / 30000.0; let angle = std::f32::consts::PI / 18.0; let (sin, cos) = angle.sin_cos(); - let x = model[0] * self.scale * cos - model[1] * self.scale * sin - offset0; - let y = model[0] * self.scale * sin + model[1] * self.scale * cos + offset1; - let u = (x - x.floor()).clamp(0.5 / self.rect.w as f32, 1.0 - 0.5 / self.rect.w as f32); - let v = (y - y.floor()).clamp(0.5 / self.rect.h as f32, 1.0 - 0.5 / self.rect.h as f32); [ - self.rect.u0 + u * (self.rect.u1 - self.rect.u0), - self.rect.v0 + v * (self.rect.v1 - self.rect.v0), + model[0] * self.scale * cos - model[1] * self.scale * sin - offset0, + model[0] * self.scale * sin + model[1] * self.scale * cos + offset1, ] } } @@ -739,7 +736,7 @@ impl ItemSink for WorldSink<'_> { }; let overlay = if glint.is_some() { 7 } else { 0 }; for (i, (p, uv)) in q.pos.iter().zip(q.uv).enumerate() { - let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.atlas_uv(q.foil_uv[i])); + let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.uv(q.foil_uv[i])); self.out.push(Vertex { normal: [0; 4], pos: p.to_array(), diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs index 87dfb354e..7c65ea86d 100644 --- a/crates/horizon-client/src/item_render/gui.rs +++ b/crates/horizon-client/src/item_render/gui.rs @@ -111,7 +111,7 @@ fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: batch.quad_glint( corners.map(|v| v.p.to_array()), corners.map(|v| [v.uv[0] + 2.0, v.uv[1]]), - corners.map(|v| glint.atlas_uv(v.glint_uv)), + corners.map(|v| glint.uv(v.glint_uv)), u32::MAX, ); batch.blend_since(start, crate::hud::Blend::Additive); @@ -157,7 +157,18 @@ pub fn draw( return; } let start = batch.vertices.len(); - draw_now(state, renderer, sprites, host, batch, x, y, time); + draw_now( + state, + renderer, + sprites, + host, + batch, + x, + y, + time, + glint_speed, + glint_alpha, + ); if let Some(key) = key && let Ok(mut drawn) = renderer.gui_drawn.lock() { @@ -231,6 +242,8 @@ fn draw_now( x: f32, y: f32, time: f32, + glint_speed: f32, + glint_alpha: f32, ) { let pose = Mat4::from_translation(Vec3::new(x + 8.0, y + 8.0, 0.0)) * Mat4::from_scale(Vec3::new(16.0, -16.0, 16.0)); @@ -252,10 +265,8 @@ fn draw_now( [x, y, x + 16.0, y + 16.0] }; let glint = sprites - .get("misc/enchanted_glint_item") - .copied() - .map(|rect| Glint { - rect, + .contains_key("misc/enchanted_glint_item") + .then_some(Glint { speed: glint_speed, alpha: glint_alpha, millis: time * 1000.0, From 91f1f839ab9e5d637a15204bfc629a47d266bdeb Mon Sep 17 00:00:00 2001 From: kohad1ck <163426863+kohad1ck@users.noreply.github.com> Date: Mon, 26 Oct 2026 18:28:19 +0800 Subject: [PATCH 061/105] Superflat: the Customize screen edits layers and presets Create New World greyed out Customize for a Superflat world because Horizon had no preset editor. Bring vanilla's CreateFlatWorldScreen and PresetFlatWorldScreen: - the layer list (top first), Remove Layer and the layer heights; - the preset chooser with the nine visible flat_world_preset entries, their display items and names; - the share box and Select, parsing layers;biome and validating block and biome ids against the prepared registries; - Done keeps the layers in WorldOptions, Cancel and Escape discard them. world_loading writes them with write_world_gen_settings_with, so a new world's world_gen_settings keeps the custom generator; Re-Create reads them back for the editor. Co-Authored-By: ZCode Agent --- crates/horizon-client/src/game/agent.rs | 16 + .../horizon-client/src/game/world_loading.rs | 7 +- crates/horizon-client/src/title.rs | 125 +++ .../horizon-client/src/title/create_world.rs | 25 +- crates/horizon-client/src/title/flat.rs | 882 ++++++++++++++++++ 5 files changed, 1051 insertions(+), 4 deletions(-) create mode 100644 crates/horizon-client/src/title/flat.rs diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index fa9dbf3c6..a069330f5 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -565,6 +565,22 @@ impl Game<'_> { "generate_structures": options.structures, "bonus_chest": options.bonus_chest(), }), + Mode::CreateFlat { + name, + seed, + options, + flat, + .. + } => json!({ + "mode": "customize-flat", + "fields": { "name": name, "seed": seed }, + "superflat": options.flat, + "biome": flat.settings().biome, + "layers": flat.settings().layers.iter().map(|layer| json!({ + "block": layer.block, + "height": layer.height, + })).collect::>(), + }), Mode::Edit { world, name, diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs index ef47cc9c0..168a3eaf8 100644 --- a/crates/horizon-client/src/game/world_loading.rs +++ b/crates/horizon-client/src/game/world_loading.rs @@ -89,7 +89,12 @@ impl WorldRequest { level.hardcore = o.hardcore; level.difficulty = horizon_client::title::DIFFICULTIES[o.difficulty()].into(); level.allow_commands = Some(o.commands(creative)); - horizon_client::save::write_world_gen_settings(&save_root, level.seed, o.world_gen())?; + horizon_client::save::write_world_gen_settings_with( + &save_root, + level.seed, + o.world_gen(), + o.flat_settings(), + )?; } // Worlds made without the Create New World screen (--world, the // control socket) take its default: commands on for Creative only. diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs index 87bd05fd0..e603fcf94 100644 --- a/crates/horizon-client/src/title.rs +++ b/crates/horizon-client/src/title.rs @@ -13,10 +13,12 @@ use std::{ }; mod create_world; +mod flat; #[cfg(test)] mod tests; pub mod world_management; pub use create_world::{DIFFICULTIES, WorldOptions}; +pub use flat::{FlatLayer, FlatSettings, State as FlatEditor}; /// SelectWorldScreen's `HeaderAndFooterLayout(8 + 9 + 8 + 20 + 4, 60)`. const LIST_TOP: f32 = 49.0; @@ -101,6 +103,16 @@ pub enum Mode { return_to: Box, }, Multiplayer(crate::multiplayer::Screen), + /// CreateFlatWorldScreen over Create New World: the fields that screen + /// keeps and the superflat editor on top of them. + CreateFlat { + name: String, + seed: String, + creative: bool, + focus: u8, + options: WorldOptions, + flat: flat::State, + }, } #[derive(Clone, Debug, PartialEq)] pub enum Action { @@ -128,6 +140,8 @@ pub struct Title { /// Direct Connection's address, synchronized with `options.txt`'s `lastServer`. pub last_server: String, pub saves: PathBuf, + /// The prepared resource root: the flat preset list and block registry. + resources: PathBuf, pub started: std::time::Instant, search: String, search_focused: bool, @@ -231,6 +245,7 @@ impl Title { mode, last_server: String::new(), saves, + resources: resources.to_owned(), started: now, search: String::new(), search_focused: false, @@ -316,6 +331,64 @@ impl Title { self.return_to_list(None); } } + /// A press on the superflat screens: their list, share box or buttons. + fn flat_click(&mut self, x: f32, y: f32, size: (f32, f32), hit: Option) { + match hit { + Some(70) => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.remove_selected(); + } + } + Some(71) => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.open_presets(); + } + } + Some(72) => self.close_flat(true), + Some(73) => self.close_flat(false), + Some(74) => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.apply_share(); + } + } + Some(75) => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.back_to_layers(); + } + } + None => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat::click(flat, (x, y), size); + } + } + _ => {} + } + } + /// Return to Create New World, keeping (`apply`) or dropping the layers. + fn close_flat(&mut self, apply: bool) { + let mode = std::mem::replace(&mut self.mode, Mode::Main); + if let Mode::CreateFlat { + name, + seed, + creative, + focus, + mut options, + flat, + } = mode + { + if apply { + options.flat = true; + options.flat_settings = Some(flat.settings); + } + self.mode = Mode::Create { + name, + seed, + creative, + focus, + options, + }; + } + } fn matches_search(&self, world: &WorldEntry) -> bool { let filter = self.search.to_lowercase(); world.name.to_lowercase().contains(&filter) || world.folder.to_lowercase().contains(&filter) @@ -363,6 +436,10 @@ impl Title { if let Mode::Multiplayer(screen) = &mut self.mode { return screen.drag(cursor.1, size); } + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat::drag(flat, cursor, size); + return; + } if let Mode::Select { worlds, .. } = &self.mode { let (top, bottom, _, content) = self.world_list(worlds, size); let mut scroll = self.scroll.get(); @@ -375,6 +452,9 @@ impl Title { if let Mode::Multiplayer(screen) = &mut self.mode { screen.release(); } + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat::release(flat); + } self.scroll.get_mut().release(); } /// Mouse wheel over the classic world and server lists. @@ -383,6 +463,10 @@ impl Title { screen.wheel(delta, cursor, size); return; } + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat::wheel(flat, delta, cursor, size); + return; + } let Mode::Select { worlds, .. } = &self.mode else { return; }; @@ -703,6 +787,7 @@ impl Title { Mode::Create { creative, options, .. } => create_world::buttons(w, h, *creative, options), + Mode::CreateFlat { flat, .. } => flat::buttons(w, h, flat), Mode::Edit { world, name, .. } => { let x = (w / 2.0).floor() - 100.0; let top = edit_top(h); @@ -1022,6 +1107,7 @@ impl Title { options, .. } => self.draw_create(atlas, batch, cursor, name, seed, *focus, options), + Mode::CreateFlat { flat, .. } => flat::draw(self, atlas, batch, cursor, flat), Mode::Edit { name, focused, .. } => { crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false); centered( @@ -1224,6 +1310,10 @@ impl Title { .into_iter() .find(|b| b.enabled && x >= b.x && x < b.x + b.w && y >= b.y && y < b.y + 20.0) .map(|b| b.id); + if matches!(self.mode, Mode::CreateFlat { .. }) { + self.flat_click(x, y, (w, h), hit); + return (Action::None, hit.is_some()); + } let action = self.click_action(x, y, (w, h), hit); // World list selection is silent; launching its selected entry sounds. let sound = hit.is_some() || matches!(action, Action::Play { .. }); @@ -1387,6 +1477,27 @@ impl Title { self.mode = *return_to.clone(); Action::None } + ( + Mode::Create { + name, + seed, + creative, + focus, + options, + }, + Some(26), + ) => { + let flat = flat::State::new(&self.resources, options.flat_settings.clone()); + self.mode = Mode::CreateFlat { + name: name.clone(), + seed: seed.clone(), + creative: *creative, + focus: *focus, + options: options.clone(), + flat, + }; + Action::None + } ( Mode::Create { creative, options, .. @@ -1590,6 +1701,16 @@ impl Title { self.return_to_list(Some(&folder)); } Mode::Error { return_to, .. } => self.mode = *return_to.clone(), + Mode::CreateFlat { .. } => { + if matches!(&self.mode, Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets) + { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.back_to_layers(); + } + } else { + self.close_flat(false); + } + } Mode::Create { .. } => self.cancel_create(), _ => self.mode = Mode::Main, } @@ -1618,6 +1739,7 @@ const SEARCH: crate::clipboard::FieldId = ("world.search", 0); const EDIT_NAME: crate::clipboard::FieldId = ("world.edit-name", 0); const WORLD_NAME: crate::clipboard::FieldId = ("world.name", 0); const WORLD_SEED: crate::clipboard::FieldId = ("world.seed", 0); +const FLAT_SHARE: crate::clipboard::FieldId = ("world.flat-share", 0); /// The focused field of the world screens and the server screens: the list's /// search, a world name or seed, or Add Server, Direct Connection and Join a /// Friend. @@ -1641,6 +1763,9 @@ fn caret_field<'a>( _ => None, }, Mode::Multiplayer(screen) => screen.focused_text(), + Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets && flat.share_focused => { + Some((FLAT_SHARE, &mut flat.share, 1230)) + } _ => None, } } diff --git a/crates/horizon-client/src/title/create_world.rs b/crates/horizon-client/src/title/create_world.rs index a2fa6b8ce..04b92ebb2 100644 --- a/crates/horizon-client/src/title/create_world.rs +++ b/crates/horizon-client/src/title/create_world.rs @@ -32,6 +32,8 @@ pub struct WorldOptions { pub commands: Option, /// The Superflat world preset instead of Default. pub flat: bool, + /// CreateFlatWorldScreen's layers and biome, kept with the world type. + pub flat_settings: Option, pub structures: bool, pub bonus_chest: bool, } @@ -43,6 +45,7 @@ impl Default for WorldOptions { difficulty: 2, commands: None, flat: false, + flat_settings: None, structures: true, bonus_chest: false, } @@ -64,6 +67,10 @@ impl WorldOptions { .unwrap_or(2), commands: Some(commands), flat: generation.flat, + flat_settings: generation + .flat + .then(|| super::flat::FlatSettings::from_world(dir)) + .flatten(), structures: generation.structures, bonus_chest: generation.bonus_chest, ..Self::default() @@ -88,6 +95,12 @@ impl WorldOptions { bonus_chest: self.bonus_chest(), } } + /// The custom layers, as `write_world_gen_settings_with` takes them. + pub fn flat_settings(&self) -> Option { + self.flat_settings + .as_ref() + .map(super::flat::FlatSettings::to_tag) + } /// A press on one of the open tab's cycle buttons or switches. pub(super) fn press(&mut self, id: u8, creative: &mut bool) { match id { @@ -101,7 +114,13 @@ impl WorldOptions { } 23 => self.difficulty = (self.difficulty + 1) % DIFFICULTIES.len(), 24 => self.commands = Some(!self.commands(*creative)), - 25 => self.flat = !self.flat, + 25 => { + self.flat = !self.flat; + if self.flat { + // setWorldType starts the generator from the flat preset. + self.flat_settings = Some(super::flat::FlatSettings::default()); + } + } 27 => self.structures = !self.structures, 28 => self.bonus_chest = !self.bonus_chest, _ => {} @@ -243,13 +262,13 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec, + pub structure_overrides: Vec, +} +impl Default for FlatSettings { + fn default() -> Self { + // worldgen/world_preset/flat.json's overworld. + Self { + biome: "minecraft:plains".into(), + features: false, + lakes: false, + layers: vec![ + FlatLayer { + block: "minecraft:bedrock".into(), + height: 1, + }, + FlatLayer { + block: "minecraft:dirt".into(), + height: 2, + }, + FlatLayer { + block: "minecraft:grass_block".into(), + height: 1, + }, + ], + structure_overrides: vec!["minecraft:strongholds".into(), "minecraft:villages".into()], + } + } +} +impl FlatSettings { + /// A saved world's flat generator settings, for Re-Create. + pub fn from_world(dir: &Path) -> Option { + let settings = crate::save::world_gen_settings(dir)?; + let generator = settings + .get("dimensions")? + .get("minecraft:overworld")? + .get("generator")?; + if crate::save::text(generator.get("type"))?.trim_start_matches("minecraft:") != "flat" { + return None; + } + Self::from_tag(generator.get("settings")?) + } + pub fn from_tag(tag: &Tag) -> Option { + let Some(Tag::List(list)) = tag.get("layers") else { + return None; + }; + let layers: Vec = list + .iter() + .filter_map(|layer| { + Some(FlatLayer { + block: crate::save::text(layer.get("block"))?, + height: crate::save::number(layer.get("height"))?.clamp(0, Y_SIZE as i64) + as i32, + }) + }) + .collect(); + if layers.is_empty() { + return None; + } + let flag = |key: &str, default: bool| { + crate::save::number(tag.get(key)).map_or(default, |value| value != 0) + }; + let structure_overrides = match tag.get("structure_overrides") { + Some(Tag::String(text)) => vec![text.to_string_lossy()], + Some(Tag::List(list)) => list + .iter() + .filter_map(|value| crate::save::text(Some(value))) + .collect(), + _ => Vec::new(), + }; + Some(Self { + biome: crate::save::text(tag.get("biome")).unwrap_or_else(|| "minecraft:plains".into()), + features: flag("features", false), + lakes: flag("lakes", false), + layers, + structure_overrides, + }) + } + /// FlatLevelGeneratorSettings.CODEC, as world_gen_settings stores it. + pub fn to_tag(&self) -> Tag { + let string = |text: &str| Tag::String(text.into()); + Tag::compound([ + ("biome", string(&self.biome)), + ("features", Tag::Byte(i8::from(self.features))), + ("lakes", Tag::Byte(i8::from(self.lakes))), + ( + "layers", + Tag::List( + self.layers + .iter() + .map(|layer| { + Tag::compound([ + ("block", string(&layer.block)), + ("height", Tag::Int(layer.height)), + ]) + }) + .collect(), + ), + ), + ( + "structure_overrides", + Tag::List( + self.structure_overrides + .iter() + .map(|id| string(id)) + .collect(), + ), + ), + ]) + } + /// `CreateFlatWorldScreen.save`: the text the preset screen shows. + pub fn to_share(&self) -> String { + let layers = self + .layers + .iter() + .map(|layer| { + if layer.height == 1 { + layer.block.clone() + } else { + format!("{}*{}", layer.height, layer.block) + } + }) + .collect::>() + .join(","); + format!("{layers};{}", self.biome) + } + /// `PresetFlatWorldScreen.fromString`: `layers;biome`, keeping the + /// decorations the screen was opened with. `None` for a malformed list, + /// as vanilla falls back to the preset's own settings. + pub fn parse( + text: &str, + blocks: &BTreeSet, + biomes: &BTreeSet, + base: &Self, + ) -> Option { + let (layer_text, biome_text) = text.split_once(';').unwrap_or((text, "")); + let mut layers = Vec::new(); + let mut total = 0; + for part in layer_text.split(',') { + let part = part.trim(); + if part.is_empty() { + continue; + } + let (height, block) = match part.split_once('*') { + Some((height, block)) => (height.trim().parse::().ok()?, block.trim()), + None => (1, part), + }; + let block = namespaced(block); + if !blocks.is_empty() && !blocks.contains(&block) { + return None; + } + let height = height.max(0).min(Y_SIZE - total); + if height == 0 { + continue; + } + total += height; + layers.push(FlatLayer { block, height }); + } + if layers.is_empty() { + return None; + } + let mut biome = namespaced(biome_text.trim()); + if biome == "minecraft:" || biome.is_empty() { + biome = "minecraft:plains".into(); + } + if !biomes.is_empty() && !biomes.contains(&biome) { + biome = "minecraft:plains".into(); + } + Some(Self { + biome, + layers, + ..base.clone() + }) + } +} +/// `Identifier.parse`: bare names get the default namespace. +fn namespaced(id: &str) -> String { + if id.is_empty() || id.contains(':') { + id.to_owned() + } else { + format!("minecraft:{id}") + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(super) enum Page { + Layers, + Presets, +} + +#[derive(Clone, Debug)] +pub struct State { + pub(super) page: Page, + pub(super) settings: FlatSettings, + /// The preset screen's share box (`createWorld.customize.presets.share`). + pub(super) share: String, + pub(super) share_focused: bool, + /// The selected layer, in the list's top-first order. + pub(super) selected: Option, + pub(super) scroll: ui::Scroll, + preset_selected: Option, + preset_scroll: ui::Scroll, + presets: Vec, + blocks: BTreeSet, + biomes: BTreeSet, +} +#[derive(Clone, Debug)] +struct Preset { + id: String, + display: String, + settings: FlatSettings, +} +impl State { + /// The layers the editor holds, for the control socket's state. + pub fn settings(&self) -> &FlatSettings { + &self.settings + } + pub(super) fn new(root: &Path, current: Option) -> Self { + let settings = current.unwrap_or_default(); + let (presets, blocks, biomes) = load(root); + Self { + page: Page::Layers, + share: settings.to_share(), + settings, + share_focused: false, + selected: None, + scroll: ui::Scroll::default(), + preset_selected: None, + preset_scroll: ui::Scroll::default(), + presets, + blocks, + biomes, + } + } + pub(super) fn open_presets(&mut self) { + self.page = Page::Presets; + self.preset_selected = None; + self.preset_scroll = ui::Scroll::default(); + self.share = self.settings.to_share(); + self.share_focused = false; + } + pub(super) fn back_to_layers(&mut self) { + self.page = Page::Layers; + self.share_focused = false; + } + pub(super) fn remove_selected(&mut self) { + let Some(row) = self.selected else { + return; + }; + let index = self.settings.layers.len().wrapping_sub(1 + row); + if index < self.settings.layers.len() { + self.settings.layers.remove(index); + } + self.selected = None; + } + /// PresetFlatWorldScreen's Select: parse the share text into the settings + /// the Create New World screen keeps. + pub(super) fn apply_share(&mut self) { + // PresetFlatWorldScreen keeps the selected preset's decorations while + // the share text supplies its layers and biome. + let base = self + .preset_selected + .and_then(|index| self.presets.get(index)) + .map(|preset| preset.settings.clone()) + .unwrap_or_else(|| self.settings.clone()); + // A malformed list falls back to FlatLevelGeneratorSettings.getDefault. + let settings = + FlatSettings::parse(&self.share, &self.blocks, &self.biomes, &base).unwrap_or_default(); + self.settings = settings; + self.share = self.settings.to_share(); + self.page = Page::Layers; + self.share_focused = false; + self.selected = None; + } + fn select_preset(&mut self, index: usize) { + let Some(preset) = self.presets.get(index) else { + return; + }; + self.preset_selected = Some(index); + self.share = preset.settings.to_share(); + self.share_focused = false; + } + fn selecting(&self) -> Option { + self.preset_selected + } +} + +/// `/data//worldgen/flat_level_generator_preset/.json`, +/// in the order of the `visible` tag, plus the block and biome ids the share +/// text is checked against. +fn load(root: &Path) -> (Vec, BTreeSet, BTreeSet) { + let mut presets = Vec::new(); + let tag_path = + root.join("data/minecraft/tags/worldgen/flat_level_generator_preset/visible.json"); + if let Ok(text) = std::fs::read_to_string(tag_path) + && let Ok(Value::Object(tag)) = serde_json::from_str(&text) + && let Some(Value::Array(ids)) = tag.get("values") + { + for id in ids.iter().filter_map(Value::as_str) { + let Some((namespace, path)) = id.split_once(':') else { + continue; + }; + let path = root.join(format!( + "data/{namespace}/worldgen/flat_level_generator_preset/{path}.json" + )); + let Ok(text) = std::fs::read_to_string(path) else { + continue; + }; + let Ok(value) = serde_json::from_str::(&text) else { + continue; + }; + let Some(settings) = preset_settings(&value) else { + continue; + }; + presets.push(Preset { + id: id.to_owned(), + display: value["display"] + .as_str() + .unwrap_or("minecraft:grass_block") + .to_owned(), + settings, + }); + } + } + let blocks = registry_ids(root, "minecraft:block"); + let biomes = json_keys(&root.join("worldgen/biomes.json")); + (presets, blocks, biomes) +} +fn preset_settings(value: &Value) -> Option { + let settings = value.get("settings")?; + let layers = settings + .get("layers")? + .as_array()? + .iter() + .filter_map(|layer| { + Some(FlatLayer { + block: layer.get("block")?.as_str()?.to_owned(), + height: layer.get("height")?.as_i64()? as i32, + }) + }) + .collect::>(); + if layers.is_empty() { + return None; + } + let structure_overrides = match settings.get("structure_overrides") { + Some(Value::String(id)) => vec![id.clone()], + Some(Value::Array(ids)) => ids + .iter() + .filter_map(Value::as_str) + .map(str::to_owned) + .collect(), + _ => Vec::new(), + }; + Some(FlatSettings { + biome: settings + .get("biome") + .and_then(Value::as_str) + .unwrap_or("minecraft:plains") + .to_owned(), + features: settings + .get("features") + .and_then(Value::as_bool) + .unwrap_or(false), + lakes: settings + .get("lakes") + .and_then(Value::as_bool) + .unwrap_or(false), + layers, + structure_overrides, + }) +} +/// The ids of a registry in the prepared `registries.json`. +fn registry_ids(root: &Path, registry: &str) -> BTreeSet { + let Ok(text) = std::fs::read_to_string(root.join("registries.json")) else { + return BTreeSet::new(); + }; + let Ok(value) = serde_json::from_str::(&text) else { + return BTreeSet::new(); + }; + value + .get(registry) + .and_then(|registry| registry.get("entries")) + .and_then(Value::as_object) + .map(|entries| entries.keys().cloned().collect()) + .unwrap_or_default() +} +fn json_keys(path: &Path) -> BTreeSet { + let Ok(text) = std::fs::read_to_string(path) else { + return BTreeSet::new(); + }; + let Ok(value) = serde_json::from_str::(&text) else { + return BTreeSet::new(); + }; + value + .as_object() + .map(|entries| entries.keys().cloned().collect()) + .unwrap_or_default() +} + +/// CreateFlatWorldScreen's list and the preset screen's list. +fn list_area(state: &State, size: (f32, f32)) -> (f32, f32, f32, f32) { + let (w, h) = (size.0.ceil(), size.1.ceil()); + let (top, bottom) = match state.page { + Page::Layers => (43.0, h - 60.0), + Page::Presets => (80.0, h - 37.0), + }; + let left = ((w - ROW_WIDTH) * 0.5).floor(); + let rows = match state.page { + Page::Layers => HEADER + state.settings.layers.len() as f32 * LAYER_ROW + 4.0, + Page::Presets => state.presets.len() as f32 * PRESET_ROW + 4.0, + }; + (top, bottom, left, rows) +} + +pub(super) fn buttons(w: f32, h: f32, state: &State) -> Vec