From 408a75aeb32f1f1e34d03f4ff9a42098fcf8514b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 11:45:03 +0100 Subject: [PATCH 01/84] Decorated pot: draw one face of its top and bottom planes --- .../horizon-client/src/block_entity_render.rs | 23 ++++++++++++++++++- .../horizon-client/src/item_render/special.rs | 2 +- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 10c5e2509..3d8c0258b 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -66,6 +66,24 @@ impl ModelPart { children, } } + /// `parse` of the entity model layer `layer`. Vanilla culls back faces for the pot's + /// `top` and `bottom` planes (`DecoratedPotRenderer.createBaseLayer`), so only the + /// up face of `top` and the down face of `bottom` show; ours draws both faces of each + /// plane, which fight for the same pixels, so the culled face is dropped here. + pub fn parse_layer(layer: &str, v: &Value) -> Self { + let mut part = Self::parse(v); + if layer == "minecraft:decorated_pot_base#main" { + // `ModelPart.Cube` polygon order: down, up, west, north, east, south. + for (name, face) in [("top", 1), ("bottom", 0)] { + if let Some((_, plane)) = part.children.iter_mut().find(|(n, _)| n == name) + && let Some(&polygon) = plane.polygons.get(face) + { + plane.polygons = vec![polygon]; + } + } + } + part + } pub fn child(&self, name: &str) -> Option<&ModelPart> { self.children .iter() @@ -794,7 +812,10 @@ impl BlockEntityRenderer { let all: Value = serde_json::from_slice(&std::fs::read(root.join("entity-models.json"))?)?; let models = MODELS .iter() - .filter_map(|(key, layer)| all.get(*layer).map(|v| (*key, ModelPart::parse(v)))) + .filter_map(|(key, layer)| { + all.get(*layer) + .map(|v| (*key, ModelPart::parse_layer(layer, v))) + }) .collect(); let mut renderer = Self::new(models, registry); renderer.visibility = Some(Mutex::new(crate::models::load_visibility(root, registry)?)); diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs index d42378db1..6f4980169 100644 --- a/crates/horizon-client/src/item_render/special.rs +++ b/crates/horizon-client/src/item_render/special.rs @@ -60,7 +60,7 @@ pub(super) fn load_parts(root: &Path) -> HashMap { .chain(COPPER_GOLEM_LAYERS.iter()) .filter_map(|(key, layer)| { all.get(*layer) - .map(|v| ((*key).to_owned(), ModelPart::parse(v))) + .map(|v| ((*key).to_owned(), ModelPart::parse_layer(layer, v))) }) .collect() } From 946f47b3ec6c79f21a67e4637f24869285321de4 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 12:48:36 +0100 Subject: [PATCH 02/84] Keep a happy ghast solid and still under a rider who gets off it On the server thread the window never learned the ghast was on its still timeout, and its copy trailed the server's, so a rider dropped through the ghast and the ghast flew off. Sync STAYS_STILL, assume the timeout on dismount, and put the window's ghast under the landing spot. --- crates/horizon-client/src/game/lan.rs | 11 ++++++ crates/horizon-client/src/game/remote.rs | 38 +++++++++++++++++++ .../src/game/remote_mob_data.rs | 4 ++ .../src/game/remote_vehicles.rs | 11 ++++++ 4 files changed, 64 insertions(+) diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 50fa222e6..4b028ee9f 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -264,6 +264,14 @@ fn mob_meta( meta.push((19, serializer::BOOLEAN, Value::Bool(true))); } } + // HappyGhast.STAYS_STILL (after AgeableMob's two and IS_LEASH_HOLDER), + // set while `serverStillTimeout > 0` (`syncStayStillFlag`). + "minecraft:happy_ghast" => { + if horizon_client::mobs::happy_ghast::on_still_timeout(m) { + meta.push((19, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((19, serializer::BOOLEAN, Value::Bool(false))); + } // Villager.DATA_VILLAGER_DATA and ZombieVillager's (after Zombie's three). "minecraft:villager" | "minecraft:zombie_villager" => { use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; @@ -836,6 +844,9 @@ impl Game<'_> { e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z]; e.needs_sync = m.needs_sync; mob_meta(m, hub, &mut e.meta, &mut e.defaults); + // HappyGhast.aiStep: requiresPrecisePosition while on a still timeout. + e.precise = m.species() == horizon_client::mobs::Species::HappyGhast + && horizon_client::mobs::happy_ghast::on_still_timeout(m); mob_equipment(m, hub, &mut e.equipment); self.mob_attributes(m, &mut e.attributes); e.leash = leash; diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5651647b7..eda1e2aca 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -154,6 +154,9 @@ pub(super) struct Remote { stepped: HashMap, /// `LivingEntity.lerpHeadTo`: the head yaw and the ticks left to reach it. head_lerps: HashMap, + /// The happy ghast the player just got off, until the server's teleport + /// puts the player on top of it (`place_ghast_under`). + pub(super) ghast_dismount: Option, /// Item entities waiting for their item data: where they are and their /// motion. pending_items: HashMap, @@ -451,6 +454,7 @@ impl Game<'_> { lerps: HashMap::new(), stepped: HashMap::new(), head_lerps: HashMap::new(), + ghast_dismount: None, pending_items: HashMap::new(), health: (20.0, 20, 5.0), flash_on_set_health: false, @@ -2969,6 +2973,37 @@ impl Game<'_> { p.health.food.saturation = saturation; } } + /// `ServerPlayer.dismountTo` lands a rider at the ghast's own (x, maxY, z) + /// (`HappyGhast.getDismountLocationForPassenger`). A vanilla client + /// simulates the ghast it rides, so its copy is where the server has it; + /// this window's copy trails the server's by the stepped interpolation and + /// would rise into the rider's feet, which lets the rider fall through. + /// Put the copy under the landing spot. + fn place_ghast_under(&mut self, id: u32, spot: Vec3) { + let Some(m) = self + .mobs + .iter_mut() + .find(|m| m.id == id && m.species() == horizon_client::mobs::Species::HappyGhast) + else { + return; + }; + let at = Vec3::new(spot.x, spot.y - f64::from(m.height()), spot.z); + // Only a teleport that is that dismount: right above the ghast. + if (at.x - m.position.x).powi(2) + (at.z - m.position.z).powi(2) > 25.0 + || (at.y - m.position.y).abs() > 5.0 + { + return; + } + m.position = at; + m.previous = at; + if let Some(handler) = self + .remote + .as_mut() + .and_then(|r| r.stepped.get_mut(&(id as i32))) + { + handler.cancel(); + } + } /// ClientPacketListener.handleMovePlayer. fn remote_teleport(&mut self, p: &play::PlayerPosition) -> Result<()> { use play::relative as rel; @@ -3028,6 +3063,9 @@ impl Game<'_> { self.previous_position = position; self.yaw = yaw; self.pitch = pitch; + if let Some(id) = self.remote.as_mut().and_then(|r| r.ghast_dismount.take()) { + self.place_ghast_under(id, position); + } if let Some(r) = self.remote.as_mut() { // handleMovePlayer does not change LocalPlayer.sendPosition's // baseline: the next tick must still report the corrected state. diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index fbfc5a4fb..bde97febf 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -67,6 +67,10 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin) { // Pillager.IS_CHARGING_CROSSBOW: the charge pose (Raider's // IS_CELEBRATING takes 16). (Species::Pillager, 17, Value::Bool(charging)) => m.extra.flag = *charging, + // HappyGhast.STAYS_STILL (after AgeableMob's two and IS_LEASH_HOLDER): + // `isOnStillTimeout` on a client, which keeps the ghast solid to + // the player (`canBeCollidedWith`). + (Species::HappyGhast, 19, Value::Bool(still)) => m.extra.counter = i32::from(*still), // SpellcasterIllager.DATA_SPELL_CASTING_ID: the casting pose. (Species::Evoker | Species::Illusioner, 17, Value::Byte(spell)) => { m.extra.variant2 = (*spell).max(0) as u8; diff --git a/crates/horizon-client/src/game/remote_vehicles.rs b/crates/horizon-client/src/game/remote_vehicles.rs index 620aff97c..b3d031ff3 100644 --- a/crates/horizon-client/src/game/remote_vehicles.rs +++ b/crates/horizon-client/src/game/remote_vehicles.rs @@ -121,6 +121,17 @@ impl Game<'_> { } else if self.riding == Some(vehicle_id) { // The server takes the player out, then teleports it. self.riding = None; + // HappyGhast.removePassenger: a still timeout of 10 (the server's + // STAYS_STILL confirms it), and the rider lands on top of the ghast + // (`place_ghast_under`). + if let Some(m) = self.mobs.iter_mut().find(|m| { + m.id == vehicle_id && m.species() == horizon_client::mobs::Species::HappyGhast + }) { + m.extra.counter = 10; + if let Some(r) = self.remote.as_mut() { + r.ghast_dismount = Some(vehicle_id); + } + } } } From d338bcd070a6c2bf2568c1f57900bf222299929b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:16:31 +0100 Subject: [PATCH 03/84] Decorated pot: say why only the outer faces stay Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/block_entity_render.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 3d8c0258b..1bbc7a207 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -66,10 +66,10 @@ impl ModelPart { children, } } - /// `parse` of the entity model layer `layer`. Vanilla culls back faces for the pot's - /// `top` and `bottom` planes (`DecoratedPotRenderer.createBaseLayer`), so only the - /// up face of `top` and the down face of `bottom` show; ours draws both faces of each - /// plane, which fight for the same pixels, so the culled face is dropped here. + /// `parse` of the entity model layer `layer`. The pot's `top` and `bottom` are flat + /// boxes (`DecoratedPotRenderer.createBaseLayer`) drawn with a culling render type, so + /// from outside only `top`'s up face and `bottom`'s down face show. Both faces of each + /// plane would fight for the same pixels here: keep the outer one. pub fn parse_layer(layer: &str, v: &Value) -> Self { let mut part = Self::parse(v); if layer == "minecraft:decorated_pot_base#main" { From d2105fe66c17fa41a5efe66a5217dd5ef7e94c1f Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:14:30 +0100 Subject: [PATCH 04/84] Round instant potion effects and measure splash range from the body Instant health and harm round to the nearest point instead of truncating. A splash potion measures the distance to the entity's box, not its centre, so a potion landing next to a player hits harder and reaches farther. --- crates/horizon-client/src/effects.rs | 7 +-- crates/horizon-client/src/game/potions.rs | 59 +++++++++++++++-------- 2 files changed, 44 insertions(+), 22 deletions(-) diff --git a/crates/horizon-client/src/effects.rs b/crates/horizon-client/src/effects.rs index 17dce93ab..2ead9122b 100644 --- a/crates/horizon-client/src/effects.rs +++ b/crates/horizon-client/src/effects.rs @@ -129,15 +129,16 @@ fn periodic(id: &str, tick: i32, amp: i32) -> Option { _ => None, } } -/// `InstantenousMobEffect.applyInstantenousEffect` (potions apply these directly). +/// `HealOrHarmMobEffect.applyInstantaneousEffect` (potions apply these directly; +/// the amount rounds to the nearest whole point). pub fn instant(id: &str, amp: i32, scale: f64) -> Option { match id { "instant_health" => Some(EffectAction::Heal( - (scale * f64::from(4 << amp.min(30))) as i32 as f32, + (scale * f64::from(4 << amp.min(30)) + 0.5) as i32 as f32, )), "instant_damage" => Some(EffectAction::Hurt( "minecraft:magic", - (scale * f64::from(6 << amp.min(30))) as i32 as f32, + (scale * f64::from(6 << amp.min(30)) + 0.5) as i32 as f32, )), "saturation" => Some(EffectAction::Eat(amp + 1, 1.0)), _ => None, diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index b28c2fb4d..669cbea53 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, Vec3}, + random::RandomSource, +}; /// A thrown splash or lingering potion in flight. #[derive(Clone, Debug)] @@ -44,6 +47,22 @@ fn mob_effect_id(id: &str) -> Option<&'static str> { .get(id) .copied() } +/// `ThrownSplashPotion.onHitAsPotion`: the squared distance from the potion's +/// box at the hit point to an entity's box grown by the hit margin +/// (`ProjectileUtil.computeMargin`), for entities that meet the potion's box +/// grown by (4, 2, 4); none when it is 16 or more. +fn splash_distance_sqr(at: Vec3, age: u32, bounds: Aabb) -> Option { + let potion = Aabb::new( + Vec3::new(at.x - 0.125, at.y, at.z - 0.125), + Vec3::new(at.x + 0.125, at.y + 0.25, at.z + 0.125), + ); + if !potion.inflate(Vec3::new(4.0, 2.0, 4.0)).intersects(bounds) { + return None; + } + let margin = ((f64::from(age) - 2.0) / 20.0).clamp(0.0, 0.3); + let d2 = potion.distance_squared_to_box(bounds.inflate(Vec3::new(margin, margin, margin))); + (d2 < 16.0).then_some(d2) +} impl Game<'_> { /// A splash potion, lingering potion or experience bottle in flight (the /// player's throws and dispensers both end up here). @@ -516,7 +535,7 @@ impl Game<'_> { } } if let Some(p) = hit { - landed.push((t.stack.clone(), p)); + landed.push((t.stack.clone(), p, t.age)); return false; } t.position = next; @@ -535,8 +554,8 @@ impl Game<'_> { t.age < 1200 && t.position.y > -128.0 }); self.potions.thrown = thrown; - for (stack, at) in landed { - self.splash(&stack, at); + for (stack, at, age) in landed { + self.splash(&stack, at, age); } } /// `ThrownItemRenderer` for thrown splash and lingering potions and @@ -589,17 +608,20 @@ impl Game<'_> { &mut self, effects: &'static [(&'static str, i32, i32)], at: Vec3, + age: u32, scale: f64, ) { if let Some(p) = self.player.as_ref() { - let center = Vec3::new( - p.position.x, - p.position.y + f64::from(p.dimensions.height) / 2.0, - p.position.z, + let w = f64::from(p.dimensions.width) / 2.0; + let bounds = Aabb::new( + Vec3::new(p.position.x - w, p.position.y, p.position.z - w), + Vec3::new( + p.position.x + w, + p.position.y + f64::from(p.dimensions.height), + p.position.z + w, + ), ); - let d2 = - (center.x - at.x).powi(2) + (center.y - at.y).powi(2) + (center.z - at.z).powi(2); - if d2 < 16.0 && (center.y - at.y).abs() <= 2.0 + f64::from(p.dimensions.height) { + if let Some(d2) = splash_distance_sqr(at, age, bounds) { let intensity = 1.0 - d2.sqrt() / 4.0; for (id, duration, amp) in effects { let instant = brewing::effect(id).is_some_and(|e| e.instant); @@ -620,7 +642,7 @@ impl Game<'_> { } } /// `ThrownSplashPotion.onHitAsPotion` (lingering clouds apply as a weaker splash). - fn splash(&mut self, stack: &ItemStack, at: Vec3) { + fn splash(&mut self, stack: &ItemStack, at: Vec3, age: u32) { if &*stack.item == "minecraft:experience_bottle" { // ThrownExperienceBottle.onHit: the water-coloured splash (level // event 2002) and 3 to 11 experience. @@ -681,15 +703,14 @@ impl Game<'_> { }; // Every player in range (`ThrownSplashPotion.applySplash` over // `LivingEntity`s, the players among them). - self.for_each_player(|g| g.splash_on_player(def.effects, at, scale)); + self.for_each_player(|g| g.splash_on_player(def.effects, at, age, scale)); // Mobs take the instant effects (undead invert healing and harming). let undead = &self.res.stations().enchantments.entity_tags; let mut hits = Vec::new(); for (i, m) in self.mobs.iter().enumerate() { - let d2 = (m.position.x - at.x).powi(2) - + (m.position.y + m.kind.height / 2.0 - at.y).powi(2) - + (m.position.z - at.z).powi(2); - if m.alive() && d2 < 16.0 { + if m.alive() + && let Some(d2) = splash_distance_sqr(at, age, m.bounds()) + { let inverted = undead .get("minecraft:inverted_healing_and_harm") .is_some_and(|t| t.contains(&m.kind.id)); @@ -716,12 +737,12 @@ impl Game<'_> { let m = &mut self.mobs[i]; if harm { m.hurt( - (intensity * f64::from(6 << amp)) as i32 as f32, + (intensity * f64::from(6 << amp) + 0.5) as i32 as f32, Some([at.x, at.y, at.z]), &mut self.world.random, ); } else { - m.health = (m.health + (intensity * f64::from(4 << amp)) as i32 as f32) + m.health = (m.health + (intensity * f64::from(4 << amp) + 0.5) as i32 as f32) .min(m.kind.max_health); } } From e87e839c97ba351d519804aa2290cbc70bf1ad45 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 15:17:44 +0100 Subject: [PATCH 05/84] Fire the construct_beacon trigger when a beacon activates --- crates/horizon-client/src/advancements.rs | 2 +- .../horizon-client/src/game/advancements.rs | 13 ++++++++++ crates/horizon-client/src/game/beacon.rs | 24 +++++++++++++++++++ 3 files changed, 38 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs index 6706532b7..e09f97b6d 100644 --- a/crates/horizon-client/src/advancements.rs +++ b/crates/horizon-client/src/advancements.rs @@ -458,7 +458,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. diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 0f76d0ca9..ad7a2368b 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -708,6 +708,19 @@ impl Game<'_> { let it = item_view(stack); self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w)); } + /// `ConstructBeaconTrigger`: the pyramid levels of the new beacon. + pub(super) fn trigger_construct_beacon(&mut self, levels: i32) { + let me = self.player_entity(); + self.trigger("minecraft:construct_beacon", 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::range_i(&c["level"], i64::from(levels)) + }); + } /// `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/beacon.rs b/crates/horizon-client/src/game/beacon.rs index 24ead3a3d..8830547db 100644 --- a/crates/horizon-client/src/game/beacon.rs +++ b/crates/horizon-client/src/game/beacon.rs @@ -164,11 +164,35 @@ impl Game<'_> { let (was, is) = (previous > 0, b.levels > 0); if !was && is { self.beacon_sound([x, y, z], "minecraft:block.beacon.activate"); + let levels = b.levels; + self.for_each_player(|g| g.beacon_constructed([x, y, z], levels)); } else if was && !is { self.beacon_sound([x, y, z], "minecraft:block.beacon.deactivate"); } } } + /// `BeaconBlockEntity.tick` after activating: `CONSTRUCT_BEACON` for a + /// player in the box `AABB(x, y, z, x, y - 4, z).inflate(10, 5, 10)`. + fn beacon_constructed(&mut self, p: [i32; 3], levels: i32) { + let Some(bb) = self + .player + .as_ref() + .map(|pl| pl.dimensions.bounds(pl.position)) + else { + return; + }; + let (lo, hi) = (bb.min_position(), bb.max_position()); + let [x, y, z] = p.map(f64::from); + if lo.x < x + 10.0 + && hi.x > x - 10.0 + && lo.y < y + 5.0 + && hi.y > y - 9.0 + && lo.z < z + 10.0 + && hi.z > z - 10.0 + { + self.trigger_construct_beacon(levels); + } + } pub(super) fn beacon_sound(&mut self, p: [i32; 3], sound: &str) { let at = [ f64::from(p[0]) + 0.5, From 83a6f5c7b9b76071bc7798b63f11085d37beb61a Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:27:13 +0100 Subject: [PATCH 06/84] Revert "Decorated pot: say why only the outer faces stay" This reverts commit d338bcd070a6c2bf2568c1f57900bf222299929b. --- crates/horizon-client/src/block_entity_render.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 1bbc7a207..3d8c0258b 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -66,10 +66,10 @@ impl ModelPart { children, } } - /// `parse` of the entity model layer `layer`. The pot's `top` and `bottom` are flat - /// boxes (`DecoratedPotRenderer.createBaseLayer`) drawn with a culling render type, so - /// from outside only `top`'s up face and `bottom`'s down face show. Both faces of each - /// plane would fight for the same pixels here: keep the outer one. + /// `parse` of the entity model layer `layer`. Vanilla culls back faces for the pot's + /// `top` and `bottom` planes (`DecoratedPotRenderer.createBaseLayer`), so only the + /// up face of `top` and the down face of `bottom` show; ours draws both faces of each + /// plane, which fight for the same pixels, so the culled face is dropped here. pub fn parse_layer(layer: &str, v: &Value) -> Self { let mut part = Self::parse(v); if layer == "minecraft:decorated_pot_base#main" { From 9841ce7824d8a65fbc66f5a2d2ecef07defd4912 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:27:13 +0100 Subject: [PATCH 07/84] Revert "Decorated pot: draw one face of its top and bottom planes" This reverts commit 408a75aeb32f1f1e34d03f4ff9a42098fcf8514b. --- .../horizon-client/src/block_entity_render.rs | 23 +------------------ .../horizon-client/src/item_render/special.rs | 2 +- 2 files changed, 2 insertions(+), 23 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 3d8c0258b..10c5e2509 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -66,24 +66,6 @@ impl ModelPart { children, } } - /// `parse` of the entity model layer `layer`. Vanilla culls back faces for the pot's - /// `top` and `bottom` planes (`DecoratedPotRenderer.createBaseLayer`), so only the - /// up face of `top` and the down face of `bottom` show; ours draws both faces of each - /// plane, which fight for the same pixels, so the culled face is dropped here. - pub fn parse_layer(layer: &str, v: &Value) -> Self { - let mut part = Self::parse(v); - if layer == "minecraft:decorated_pot_base#main" { - // `ModelPart.Cube` polygon order: down, up, west, north, east, south. - for (name, face) in [("top", 1), ("bottom", 0)] { - if let Some((_, plane)) = part.children.iter_mut().find(|(n, _)| n == name) - && let Some(&polygon) = plane.polygons.get(face) - { - plane.polygons = vec![polygon]; - } - } - } - part - } pub fn child(&self, name: &str) -> Option<&ModelPart> { self.children .iter() @@ -812,10 +794,7 @@ impl BlockEntityRenderer { let all: Value = serde_json::from_slice(&std::fs::read(root.join("entity-models.json"))?)?; let models = MODELS .iter() - .filter_map(|(key, layer)| { - all.get(*layer) - .map(|v| (*key, ModelPart::parse_layer(layer, v))) - }) + .filter_map(|(key, layer)| all.get(*layer).map(|v| (*key, ModelPart::parse(v)))) .collect(); let mut renderer = Self::new(models, registry); renderer.visibility = Some(Mutex::new(crate::models::load_visibility(root, registry)?)); diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs index 6f4980169..d42378db1 100644 --- a/crates/horizon-client/src/item_render/special.rs +++ b/crates/horizon-client/src/item_render/special.rs @@ -60,7 +60,7 @@ pub(super) fn load_parts(root: &Path) -> HashMap { .chain(COPPER_GOLEM_LAYERS.iter()) .filter_map(|(key, layer)| { all.get(*layer) - .map(|v| ((*key).to_owned(), ModelPart::parse_layer(layer, v))) + .map(|v| ((*key).to_owned(), ModelPart::parse(v))) }) .collect() } From c987778e97f2290abce276333ffc22ba24f6ef78 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 16:34:24 +0100 Subject: [PATCH 08/84] Decorated pot: keep every quad and cull back faces like entitySolid --- crates/horizon-client/src/block_entity_render.rs | 12 +++++++++++- crates/horizon-client/src/entity.wgsl | 9 +++++++-- crates/horizon-client/src/item_render.rs | 7 +++++-- crates/horizon-client/src/item_render/gui.rs | 1 + crates/horizon-client/src/item_render/special.rs | 14 ++++++++++++++ crates/horizon-client/src/mesher.rs | 6 +++++- 6 files changed, 43 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 10c5e2509..f28008d16 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -5,7 +5,11 @@ //! (`entity-models.json`); transforms, animation and textures follow each //! vanilla renderer. Faces are lit like the `entity` shader: the lightmap at //! the block plus `minecraft_mix_light` with the level's two diffuse lights. -use crate::{hud::Rect, mesher::Vertex, world::World}; +use crate::{ + hud::Rect, + mesher::{CULL_BACK, Vertex}, + world::World, +}; use glam::{DVec3, Mat4, Quat, Vec3}; use horizon_core::geometry::{ Direction, @@ -1384,6 +1388,7 @@ impl BlockEntityRenderer { m *= around(Mat4::from_rotation_y(turn * decay), pivot); } } + let first = out.len(); if let Some(paint) = paint("entity/decorated_pot/decorated_pot_base", 0xFFFFFF, packed) { @@ -1401,6 +1406,11 @@ impl BlockEntityRenderer { draw_part(part, side, m, &none, paint, out); } } + // `DecoratedPotRenderer` submits every part with `entitySolid`, which culls + // back faces: the flat `top` and `bottom` planes show one side each. + for vertex in &mut out[first..] { + vertex.normal = CULL_BACK; + } } Kind::EndPortal => { // TheEndPortalRenderer.TRANSFORMATION: y from 6/16 to 12/16; only the diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index 2e865dfb1..4bd8983d9 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, + // 1 drops the quad's back-facing pixels (Vertex::normal w = 1), like a culling render type. + @location(11) @interpolate(flat) cull: u32, } // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed. fn entity_light(normal: vec3, nether: bool) -> f32 { @@ -92,7 +94,10 @@ fn entity_vertex(position: vec3, uv: vec2, // minecraft_mix_light: the vertex colour times the cardinal light only. var c = color; var back = c; - if normal.w != 0.0 { + // Normal w: 0 keeps the baked colour, +-127 shades by the normal, and a small positive 1 + // keeps the baked colour but culls back faces (entitySolid models such as the decorated pot). + out.cull = select(0u, 1u, normal.w > 0.0 && normal.w < 0.5); + if abs(normal.w) >= 0.5 { c = vec4(c.rgb * entity_light(normal.xyz, globals.time.y != 0.0), c.a); back = select(c, vec4(back.rgb * entity_light(-normal.xyz, globals.time.y != 0.0), back.a), normal.w < 0.0); } @@ -187,7 +192,7 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 { // clouds.fsh: alpha fades out towards the cloud fog end. return vec4(color.rgb, color.a * (1.0 - linear_fog(in.spherical, 0.0, globals.fog_ends.y))); } - if color.a < 0.1 { discard; } + if color.a < 0.1 || (in.cull != 0u && !front) { discard; } // entity.fsh calculateFinalColor: the overlay (hurt red, TNT white) over the // lit texture, then the lightmap, then the glint and fog. color = vec4(mix(in.overlay_color.rgb, color.rgb, in.overlay_color.a), color.a); diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs index c2f5c8400..540f7c23c 100644 --- a/crates/horizon-client/src/item_render.rs +++ b/crates/horizon-client/src/item_render.rs @@ -12,7 +12,7 @@ mod special; use crate::{ block_entity_render::{ModelPart, diffuse}, hud::Rect, - mesher::Vertex, + mesher::{CULL_BACK, Vertex}, }; use glam::{Mat3, Mat4, Vec3}; use horizon_assets::{ @@ -46,6 +46,8 @@ pub struct ItemQuad { pub foil: Foil, /// `MaterialInfo.lightEmission` (block light floor). pub light_emission: u8, + /// The render type culls back faces (`entitySolid`): world drawing discards them. + pub cull_back: bool, } /// Which glint render type a quad uses. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -246,6 +248,7 @@ fn submit_quads( color: argb(color), foil, light_emission: q.light_emission, + cull_back: false, }); } } @@ -692,7 +695,7 @@ impl ItemSink for WorldSink<'_> { let overlay = if q.foil == Foil::None { 0 } else { 7 }; for (p, uv) in q.pos.iter().zip(q.uv) { self.out.push(Vertex { - normal: [0; 4], + normal: if q.cull_back { CULL_BACK } else { [0; 4] }, pos: p.to_array(), uv, layer: overlay, diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs index e3d7cc876..93645559a 100644 --- a/crates/horizon-client/src/item_render/gui.rs +++ b/crates/horizon-client/src/item_render/gui.rs @@ -269,6 +269,7 @@ mod tests { color, foil: Foil::None, light_emission: 0, + cull_back: false, } } diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs index d42378db1..8a54f49bb 100644 --- a/crates/horizon-client/src/item_render/special.rs +++ b/crates/horizon-client/src/item_render/special.rs @@ -65,6 +65,17 @@ pub(super) fn load_parts(root: &Path) -> HashMap { .collect() } +/// Marks every quad passed on as drawn with a back-face-culling render type (`entitySolid`). +struct CullBack<'a>(&'a mut dyn ItemSink); +impl ItemSink for CullBack<'_> { + fn quad(&mut self, quad: ItemQuad) { + self.0.quad(ItemQuad { + cull_back: true, + ..quad + }); + } +} + /// A pose override for a named part (`setupAnim`). type Adjust<'a> = &'a dyn Fn(&str, &mut [f32; 9]); fn none(_: &str, _: &mut [f32; 9]) {} @@ -119,6 +130,7 @@ fn draw( color, foil, light_emission: 0, + cull_back: false, }); } for (child_name, child) in &part.children { @@ -569,6 +581,8 @@ pub(super) fn submit( } SpecialKind::DecoratedPot => { let sides = pot_sides(argument); + // `DecoratedPotRenderer` draws every part with `entitySolid`. + let sink = &mut CullBack(sink); if let Some(base) = renderer.part("decorated_pot_base") && let Some(r) = sprites .get("entity/decorated_pot/decorated_pot_base") diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index fff3c6aa0..788eb316d 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -36,9 +36,13 @@ pub struct Vertex { pub color: u32, /// Smooth light, 16x fixed point: sky in bits 0..8, block in bits 8..16. pub light: u32, - /// RGBA8_SNORM face normal; w = -127 for two-sided lighting, 0 to keep baked/unlit colour. + /// RGBA8_SNORM face normal; w = -127 for two-sided lighting, 0 to keep baked/unlit colour, + /// [`CULL_BACK`] to keep it and also drop back-facing pixels. pub normal: [i8; 4], } +/// `Vertex::normal` of a baked-colour quad of an `entitySolid` model: the render type culls +/// back faces, which the entity pipelines here do not, so `entity.wgsl` discards them. +pub const CULL_BACK: [i8; 4] = [0, 0, 0, 1]; /// A section vertex: vanilla's `DefaultVertexFormat.BLOCK` (position, colour, /// UV0, UV2) with the sprite's array layer beside the light, in 24 bytes /// rather than vanilla's 28: the UV is fixed point, which holds model UVs From bf508c2842825c09abb986261342f53e38953af7 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:45:39 +0100 Subject: [PATCH 09/84] Let mobs, dropped items and projectiles trigger pressure plates and tripwires --- crates/horizon-client/src/game.rs | 91 ++++++++++++++++++++++-- crates/horizon-client/src/projectiles.rs | 17 +++++ 2 files changed, 103 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index ddb07912a..1cd69e037 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -546,6 +546,11 @@ struct GameLevel<'w> { cart_boxes: Vec<([f64; 3], [f64; 3])>, /// The other entities that keep blocks from being placed into them. blockers: Blockers<'w>, + /// Item entities, experience orbs and projectiles, which trigger plates and + /// tripwires but never keep a block from being placed. + dropped: &'w [ItemEntity], + orbs: &'w [ExperienceOrb], + projectiles: &'w [horizon_client::projectiles::Projectile], biomes: &'w Biomes, seed: i64, behaviours: &'w Behaviours, @@ -615,6 +620,53 @@ impl EntityObstructionWorld for BuildingObstruction { } } impl GameLevel<'_> { + /// The mobs that trigger plates and tripwires: living entities that don't + /// ignore block triggers (`Entity.isIgnoringBlockTriggers`: bats; armor + /// stands are not in `mobs`). + fn mob_trigger_boxes(&self) -> impl Iterator + '_ { + self.blockers + .mobs + .iter() + .filter(|m| !m.removed && m.species() != horizon_client::mobs::Species::Bat) + .map(Mob::bounds) + } + /// The non-living entities that trigger plates and tripwires (boats, + /// crystals, primed TNT, falling blocks, item entities, experience orbs and + /// projectiles). + fn other_trigger_boxes(&self) -> impl Iterator + '_ { + let b = self.blockers; + let square = |p: Vec3, size: f64| { + Aabb::new( + Vec3::new(p.x - size / 2.0, p.y, p.z - size / 2.0), + Vec3::new(p.x + size / 2.0, p.y + size, p.z + size / 2.0), + ) + }; + b.boats + .iter() + .map(boats::Boat::bounds) + .chain(b.crystals.iter().map(|c| { + // EntityType.END_CRYSTAL: 2 x 2. + let p = c.position; + Aabb::new( + Vec3::new(p.x - 1.0, p.y, p.z - 1.0), + Vec3::new(p.x + 1.0, p.y + 2.0, p.z + 1.0), + ) + })) + .chain(b.tnts.iter().map(tnt::PrimedTnt::bounds)) + .chain( + b.falling + .iter() + .map(|f| horizon_client::falling_block::bounds(f.position)), + ) + .chain(self.dropped.iter().map(ItemEntity::bounds)) + // EntityType.EXPERIENCE_ORB: 0.5 x 0.5. + .chain(self.orbs.iter().map(move |o| square(o.position, 0.5))) + .chain( + self.projectiles + .iter() + .map(move |p| square(p.position, p.kind.size())), + ) + } /// Every entity box that blocks building: the players who aren't /// spectators, the minecarts and the `Blockers` (a removed mob or a marker /// armor stand, whose box is empty, doesn't). @@ -838,7 +890,8 @@ impl LevelAccess for GameLevel<'_> { self.tickets.block_ticking(chunk.x, chunk.z) && ticking_chunk(self.world, chunk.x, chunk.z) } /// Entities that trigger pressure plates, tripwires and detector rails: - /// the players (the host and the LAN guests, mobs) and the minecarts. + /// the players (the host and the LAN guests), the mobs, the minecarts and + /// the other entities that don't ignore block triggers. fn count_entities(&self, area: Aabb, query: EntityQuery) -> usize { let hit = |(lo, hi): &([f64; 3], [f64; 3])| { area.intersects(Aabb::new( @@ -847,6 +900,16 @@ impl LevelAccess for GameLevel<'_> { )) }; let carts = || self.cart_boxes.iter().filter(|b| hit(b)).count(); + let mobs = || { + self.mob_trigger_boxes() + .filter(|b| area.intersects(*b)) + .count() + }; + let others = || { + self.other_trigger_boxes() + .filter(|b| area.intersects(*b)) + .count() + }; let players = || { self.player_box .iter() @@ -856,8 +919,8 @@ impl LevelAccess for GameLevel<'_> { }; match query { EntityQuery::Minecart => carts(), - EntityQuery::Mobs => players(), - EntityQuery::Everything => players() + carts(), + EntityQuery::Mobs => players() + mobs(), + EntityQuery::Everything => players() + carts() + mobs() + others(), } } fn emit(&mut self, event: LevelEvent) { @@ -2495,6 +2558,9 @@ impl Game<'_> { let mut level = GameLevel { cart_boxes, blockers, + dropped: &self.dropped, + orbs: &self.orbs, + projectiles: &self.creatures.projectiles, world: &mut self.world, facts: self.res.facts(), collision: self.collision, @@ -2625,7 +2691,8 @@ impl Game<'_> { .filter(|&(x, z)| levels.random_ticking(x, z) && ticking_chunk(&self.world, x, z)) .collect(); // Entity.checkInsideBlocks for the plates, tripwires and detector rails - // under the players (the host and the LAN guests) and the minecarts. + // under the players (the host and the LAN guests) and the minecarts + // (the mobs and other entities are added in `with_level` below). let mut inside = Vec::new(); let guests = self.lan_block_trigger_boxes(); let boxes = self @@ -2686,7 +2753,21 @@ impl Game<'_> { } } self.with_level(|b, level, ticks| { - for pos in inside { + // The mobs and the other entities (items, orbs, projectiles...) too. + let mut touched: Vec = Vec::new(); + for bounds in level.mob_trigger_boxes().chain(level.other_trigger_boxes()) { + let (lo, hi) = (bounds.min_position(), bounds.max_position()); + for x in (lo.x + 1e-7).floor() as i32..=(hi.x - 1e-7).floor() as i32 { + for y in (lo.y + 1e-7).floor() as i32..=(hi.y - 1e-7).floor() as i32 { + for z in (lo.z + 1e-7).floor() as i32..=(hi.z - 1e-7).floor() as i32 { + touched.push(BlockPos::new(x, y, z)); + } + } + } + } + touched.sort_unstable_by_key(|p| (p.x, p.y, p.z)); + touched.dedup(); + for pos in inside.into_iter().chain(touched) { b.entity_inside(level, ticks, pos); } for (pos, on_ground, feet_y) in standing { diff --git a/crates/horizon-client/src/projectiles.rs b/crates/horizon-client/src/projectiles.rs index 219d59b6b..a1d6e5215 100644 --- a/crates/horizon-client/src/projectiles.rs +++ b/crates/horizon-client/src/projectiles.rs @@ -62,6 +62,23 @@ pub enum ProjectileKind { }, } impl ProjectileKind { + /// The width and height of its entity type's `sized(...)`. + pub fn size(&self) -> f64 { + match self { + Self::Arrow { .. } => 0.5, + Self::Snowball + | Self::Egg + | Self::EnderPearl + | Self::LlamaSpit + | Self::Potion { .. } => 0.25, + Self::SmallFireball + | Self::WindCharge + | Self::BreezeWindCharge + | Self::ShulkerBullet { .. } + | Self::WitherSkull { .. } => 0.3125, + Self::LargeFireball { .. } => 1.0, + } + } /// Its entity type. pub fn id(&self) -> &'static str { match self { From b283f2ad314243210014263184ebf826eca53f68 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:45:44 +0100 Subject: [PATCH 10/84] Hurt mobs that touch a cactus or a sweet berry bush Mobs ignored both blocks. A mob inside a cactus now takes 1 damage a tick, and a mob inside a sweet berry bush is slowed (0.8, 0.75, 0.8) and, in a grown bush, takes 1 damage when it moved at least 0.003 on X or Z. Foxes and bees are left alone. --- crates/horizon-client/src/mobs.rs | 15 ++++++-- crates/horizon-client/src/mobs/ai.rs | 48 ++++++++++++++++++++++++ crates/horizon-client/src/mobs/living.rs | 9 ++++- 3 files changed, 67 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 00c21633e..0edcd3620 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -815,6 +815,8 @@ pub struct Mob { pub previous_swell: i32, pub ambient_timer: i32, pub fall_distance: f64, + /// `Entity.stuckSpeedMultiplier`: the next move is scaled by it. + pub stuck_multiplier: Vec3, pub persistent: bool, /// `CustomName` (plain text) and `CustomNameVisible`. pub custom_name: Option, @@ -1569,6 +1571,7 @@ impl Mob { // Mob.ambientSoundTime starts at 0. ambient_timer: 0, fall_distance: 0.0, + stuck_multiplier: Vec3::ZERO, persistent: false, random, ai: Box::default(), @@ -1640,13 +1643,17 @@ impl Mob { } } pub fn bounds(&self) -> Aabb { + self.bounds_at(self.position) + } + /// `Entity.makeBoundingBox(position)`. + pub fn bounds_at(&self, position: Vec3) -> Aabb { let w = f64::from(self.width()) / 2.0; Aabb::new( - Vec3::new(self.position.x - w, self.position.y, self.position.z - w), + Vec3::new(position.x - w, position.y, position.z - w), Vec3::new( - self.position.x + w, - self.position.y + f64::from(self.height()), - self.position.z + w, + position.x + w, + position.y + f64::from(self.height()), + position.z + w, ), ) } diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 2676c3a37..ffc74d0b9 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -400,6 +400,7 @@ pub fn tick( if !m.no_ai { ai_step(m, w, level_random, events); } + effects_from_blocks(m, w); if m.species() == Species::Rabbit { super::rabbit::post_tick(m); } @@ -428,6 +429,53 @@ pub fn tick( } true } +/// `LivingEntity.aiStep` -> `Entity.applyEffectsFromBlocks` for the blocks +/// that hurt or hold a mob: the cactus (`CactusBlock.entityInside`, 1) and the +/// sweet berry bush (`SweetBerryBushBlock.entityInside`: stuck at 0.8, 0.75, +/// 0.8, and a grown bush pricks for 1 when the mob moved at least 0.003 on X +/// or Z this tick). The blocks are those the mob's box touches where it +/// started the tick and where it ended. +fn effects_from_blocks(m: &mut Mob, w: &MobWorld) { + let mut visited: Vec<[i32; 3]> = Vec::new(); + for at in [m.previous, m.position] { + if !m.alive() { + return; + } + let b = m.bounds_at(at).deflate(Vec3::new(1e-5, 1e-5, 1e-5)); + for x in b.min_position().x.floor() as i32..=b.max_position().x.floor() as i32 { + for y in b.min_position().y.floor() as i32..=b.max_position().y.floor() as i32 { + for z in b.min_position().z.floor() as i32..=b.max_position().z.floor() as i32 { + let p = [x, y, z]; + if visited.contains(&p) { + continue; + } + match w.block_name(x, y, z) { + "minecraft:cactus" => { + m.damage(1.0, Damage::of(DamageKind::Cactus)); + } + "minecraft:sweet_berry_bush" + if !matches!(m.species(), Species::Fox | Species::Bee) => + { + m.fall_distance = 0.0; + m.stuck_multiplier = + Vec3::new(f64::from(0.8_f32), 0.75, f64::from(0.8_f32)); + let moved = m.previous.subtract(m.position); + if w.prop(x, y, z, "age") != Some("0") + && moved.horizontal_distance_squared() > 0.0 + && (moved.x.abs() >= f64::from(0.003_f32) + || moved.z.abs() >= f64::from(0.003_f32)) + { + m.damage(1.0, Damage::of(DamageKind::Cactus)); + } + } + _ => continue, + } + visited.push(p); + } + } + } + } +} /// LivingEntity.updateSwingTime (6-tick swing duration). pub fn tick_swing(m: &mut Mob) { if m.ai.swinging { diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs index 394821ace..7dfbf7017 100644 --- a/crates/horizon-client/src/mobs/living.rs +++ b/crates/horizon-client/src/mobs/living.rs @@ -370,7 +370,14 @@ impl Mob { /// Entity.move with block collisions and step-up; updates collision flags /// and fall distance (Entity.checkFallDamage). pub fn do_move(&mut self, w: &MobWorld, events: &mut Vec) { - let wanted = self.velocity; + let mut wanted = self.velocity; + // Entity.move: a block the mob is stuck in (sweet berry bush) scales + // this move once and stops it. + if self.stuck_multiplier.length_squared() > 1.0e-7 { + wanted = wanted.multiply(self.stuck_multiplier); + self.stuck_multiplier = Vec3::ZERO; + self.velocity = Vec3::ZERO; + } let step = self.kind.step_height as f32; let mut scene = SceneCollisions { world: w.world, From 472da6509dca7ebb9c4084d45ec40f96570e1d63 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:45:57 +0100 Subject: [PATCH 11/84] Projectiles ring bells they hit --- crates/horizon-client/src/game/creatures.rs | 25 +++++++++++++++- crates/horizon-world/src/level/interact.rs | 19 ++---------- crates/horizon-world/src/level/mod.rs | 16 +++++++++++ crates/horizon-world/src/level/redstone.rs | 32 +++++++++++++++++++-- 4 files changed, 73 insertions(+), 19 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2b65a3289..f82962d21 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -20,7 +20,7 @@ use horizon_client::{ projectiles::{Hit, Projectile, ProjectileKind, ProjectileWorld}, }; use horizon_core::{ - geometry::{Aabb, Vec3, traverse_blocks}, + geometry::{Aabb, Direction, Vec3, traverse_blocks}, position::BlockPos, random::RandomSource, }; @@ -1877,6 +1877,22 @@ impl Game<'_> { None => self.projectile_hit(p, hit), } } + /// `BellBlock.onProjectileHit`: a projectile that strikes the bell proper + /// rings it, and a player's shot counts as the player's ring. + fn bell_projectile_hit(&mut self, p: &Projectile, pos: [i32; 3], at: Vec3, face: [i32; 3]) { + let Some(face) = Direction::ALL.into_iter().find(|d| d.normal() == face) else { + return; + }; + let block = BlockPos::new(pos[0], pos[1], pos[2]); + let rang = self + .with_level(|b, level, ticks| b.bell_projectile_hit(level, ticks, block, face, at.y)); + if rang { + let _ = self.process_level_events(); + if p.owner == Some(Who::Player) { + self.stats.custom("bell_ring", 1); + } + } + } /// What an arrow's tick asked for: its particles and sounds. fn arrow_event(&mut self, at: Vec3, event: horizon_client::arrows::ArrowEvent) { use horizon_client::arrows::{ArrowEvent, ArrowParticle, ArrowSound, BlockReaction}; @@ -2002,6 +2018,13 @@ impl Game<'_> { } } pub(super) fn projectile_hit(&mut self, p: &Projectile, hit: Hit) -> Result<()> { + // Projectile.onHitBlock: BlockState.onProjectileHit, for every + // projectile (a wind charge out of the world's top has no face). + if let Hit::Block { pos, at, face } = hit + && face != [0; 3] + { + self.bell_projectile_hit(p, pos, at, face); + } self.combat.projectile_owner = match p.owner { Some(Who::Mob(id)) => Some(id), _ => None, diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs index 7b2195c34..18d131740 100644 --- a/crates/horizon-world/src/level/interact.rs +++ b/crates/horizon-world/src/level/interact.rs @@ -1,11 +1,9 @@ //! `BlockBehaviour.useWithoutItem` (right-click with an empty hand or an item //! that does not handle the block itself). -use super::{ - Behaviours, LevelAccess, LevelEvent, Sim, Ticks, classes::Class, query::axis_of, update::below, -}; +use super::{Behaviours, LevelAccess, LevelEvent, Sim, Ticks, classes::Class, update::below}; use crate::registry::BlockStateId; use horizon_core::{ - geometry::{Axis, Direction, Vec3}, + geometry::{Direction, Vec3}, position::BlockPos, random::RandomSource, }; @@ -338,18 +336,7 @@ impl Sim<'_, L> { } } Class::Bell => { - let click_y = hit.y - f64::from(pos.y); - let proper = axis_of(face) != Axis::Y && click_y <= 0.8124 && { - let facing_axis = axis_of(b.facing(state)); - match table.text(state, p.attachment) { - "floor" => facing_axis == axis_of(face), - "single_wall" | "double_wall" => facing_axis != axis_of(face), - "ceiling" => true, - _ => false, - } - }; - if proper { - self.bell_ring(pos, state, face); + if self.bell_hit(pos, state, face, hit.y - f64::from(pos.y)) { Success } else { Pass diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index a384b38b7..b16315279 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -768,6 +768,22 @@ impl Behaviours { self.sim(level, ticks) .big_dripleaf_entity_inside(pos, on_ground, feet_y); } + /// `BellBlock.onProjectileHit` for a projectile that hit `face` of the + /// block at `pos` at height `hit_y`. False when the block is not a bell + /// or the hit missed the bell proper. + pub fn bell_projectile_hit( + &self, + level: &mut L, + ticks: &mut Ticks, + pos: BlockPos, + face: Direction, + hit_y: f64, + ) -> bool { + let mut sim = self.sim(level, ticks); + let state = sim.state(pos); + self.data(state).is(classes::Class::Bell) + && sim.bell_hit(pos, state, face, hit_y - f64::from(pos.y)) + } /// Redstone signal queries (`SignalGetter`). pub fn has_neighbor_signal( &self, diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs index 92f9059e5..acbd4aaee 100644 --- a/crates/horizon-world/src/level/redstone.rs +++ b/crates/horizon-world/src/level/redstone.rs @@ -5,13 +5,16 @@ use super::{ LevelAccess, LevelEvent, Sim, classes::Class, data::state_flags, - query::{clockwise, counter_clockwise}, + query::{axis_of, clockwise, counter_clockwise}, states::BlockId, update::{HORIZONTAL, above, below, rel}, }; use crate::registry::BlockStateId; use horizon_core::{ - geometry::Direction, position::BlockPos, random::RandomSource, ticks::TickPriority, + geometry::{Axis, Direction}, + position::BlockPos, + random::RandomSource, + ticks::TickPriority, }; const SIGNAL_ORDER: [Direction; 6] = [ @@ -1159,6 +1162,31 @@ impl Sim<'_, L> { self.set_block_and_update(pos, b.table.set_bool(state, b.props.powered, signal)); } } + /// `BellBlock.onHit` with `requireHitFromCorrectSide`: a hit on `face` at + /// height `click_y` in the block rings the bell only when it struck the + /// bell proper. False when the hit missed it. + pub(crate) fn bell_hit( + &mut self, + pos: BlockPos, + state: BlockStateId, + face: Direction, + click_y: f64, + ) -> bool { + let b = self.b; + let facing_axis = axis_of(b.facing(state)); + let proper = axis_of(face) != Axis::Y + && click_y <= f64::from(0.8124f32) + && match b.table.text(state, b.props.attachment) { + "floor" => facing_axis == axis_of(face), + "single_wall" | "double_wall" => facing_axis != axis_of(face), + "ceiling" => true, + _ => false, + }; + if proper { + self.bell_ring(pos, state, face); + } + proper + } /// `BellBlock.attemptToRing`: `BellBlockEntity.onHit` queues block event 1 /// with the struck direction, then the sound and game event. pub(crate) fn bell_ring(&mut self, pos: BlockPos, state: BlockStateId, direction: Direction) { From e4cd56ed7b44cbe5af3835a4f3ba9730c96ad051 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:49:17 +0100 Subject: [PATCH 12/84] Make Frost Walker freeze water and protect from magma --- crates/horizon-client/src/game.rs | 7 + .../src/game/enchant_effects.rs | 212 +++++++++++++++++- crates/horizon-client/src/game/lan_actions.rs | 5 + crates/horizon-client/src/motion.rs | 3 + .../horizon-client/src/motion/environment.rs | 6 + 5 files changed, 230 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index ddb07912a..9b585e611 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1952,6 +1952,7 @@ impl Game<'_> { .as_ref() .is_some_and(|s| &*s.item == "minecraft:leather_boots"); let freeze_immune = self.wears_freeze_immune(); + let burn_immune = self.wears_burn_from_stepping_immunity(); let Some(player) = self.player.as_mut() else { return; }; @@ -1963,6 +1964,7 @@ impl Game<'_> { player.glider = glider; player.leather_boots = leather_boots; player.freeze_immune = freeze_immune; + player.burn_from_stepping_immune = burn_immune; player.fluids.fast_lava = self.dim == Dim::Nether; } fn held_slot(&self) -> usize { @@ -4518,6 +4520,11 @@ impl Game<'_> { } } self.powder_snow_fire()?; + // LivingEntity.baseTick: a new block position runs the worn + // enchantments' location_changed effects (frost walker) on the server. + if self.remote.is_none() { + self.location_changed_effects(before.2, before.0); + } self.tick_totem(); let Some(player) = self.player.as_mut() else { return Ok(()); diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs index 7cdb3e526..50b10beb1 100644 --- a/crates/horizon-client/src/game/enchant_effects.rs +++ b/crates/horizon-client/src/game/enchant_effects.rs @@ -3,10 +3,17 @@ //! unbreaking (`minecraft:item_damage`), sharpness/smite/bane and power //! (`minecraft:damage`), knockback, fire aspect, infinity (`minecraft:ammo_use`), //! thorns (`minecraft:post_attack`), mending (`minecraft:repair_with_xp`) and -//! the armor attribute effects (respiration, depth strider, ...). +//! the armor attribute effects (respiration, depth strider, ...) and the +//! `minecraft:location_changed` disk effect (frost walker). use super::Game; -use horizon_client::{enchant::EffectContext, items::ItemStack}; -use horizon_core::random::RandomSource; +use horizon_client::{ + enchant::{EffectContext, level_value}, + items::ItemStack, + mobs::Who, +}; +use horizon_core::{position::BlockPos, random::RandomSource}; +use horizon_world::{fluid::FluidKind, level::LevelAccess, registry::BlockStateId}; +use serde_json::Value; /// Where Mending found a damaged item (`EnchantedItemInUse.inSlot`). #[derive(Clone, Copy)] @@ -456,6 +463,173 @@ impl Game<'_> { } ignite } + /// `EnchantmentHelper.runLocationChangedEffects` for the worn armor of the + /// player, run on the server once the player has moved: `LivingEntity.baseTick` + /// runs it when the block position changed, `checkFallDamage` when it lands. + /// `from` and `was_on_ground` are where and how the tick began. + pub(super) fn location_changed_effects(&mut self, from: [f64; 3], was_on_ground: bool) { + let Some(p) = self.player.as_ref() else { + return; + }; + let at = [p.position.x, p.position.y, p.position.z]; + let on_ground = p.ground.on_ground; + let cell = |v: [f64; 3]| v.map(|c| c.floor() as i32); + if cell(from) == cell(at) && !(on_ground && !was_on_ground) { + return; + } + let riding = self.riding.is_some(); + let mut disks = Vec::new(); + for (stack, slot) in self.armor.iter().zip(["head", "chest", "legs", "feet"]) { + let Some(stack) = stack else { continue }; + for (id, level) in stack.enchantments() { + let Some(def) = self.res.stations().enchantments.get(id) else { + continue; + }; + if !def + .slots + .iter() + .any(|s| s == slot || s == "armor" || s == "any") + { + continue; + } + for effect in def.effects["minecraft:location_changed"] + .as_array() + .into_iter() + .flatten() + { + if effect["effect"]["type"] == "minecraft:replace_disk" + && location_requirements(&effect["requirements"], on_ground, riding) + { + disks.push((effect["effect"].clone(), *level)); + } + } + } + } + for (effect, level) in disks { + self.replace_disk(&effect, level, at); + } + } + /// `ReplaceDisk.apply`: the blocks of the disk around `at` that pass the + /// predicate become the effect's state, and each placement is a game event. + fn replace_disk(&mut self, effect: &Value, level: u32, at: [f64; 3]) { + let registry = self.pack.assets.registry; + let spec = &effect["block_state"]; + let Some(default) = spec["id"].as_str().and_then(|n| registry.default_state(n)) else { + return; + }; + let Some(mut state) = registry.state(default).cloned() else { + return; + }; + for (k, v) in spec["properties"].as_object().into_iter().flatten() { + state + .properties + .insert(k.clone(), v.as_str().unwrap_or("").to_owned()); + } + let new = registry.resolve(&state).unwrap_or(default); + let radius = level_value(&effect["radius"], level) as i32; + let height = level_value(&effect["height"], level) as i32; + let offset = cell_offset(effect); + let center = [0, 1, 2].map(|i| at[i].floor() as i32 + offset[i]); + let event = effect["trigger_game_event"].as_str() == Some("minecraft:block_place"); + for dy in (height - 1).min(0)..=0 { + for dz in -radius..=radius { + for dx in -radius..=radius { + let pos = [center[0] + dx, center[1] + dy, center[2] + dz]; + let (x, z) = ( + f64::from(pos[0]) + 0.5 - at[0], + f64::from(pos[2]) + 0.5 - at[2], + ); + if x * x + z * z >= f64::from(radius * radius) + || !self.disk_predicate(&effect["predicate"], pos, new) + || self.level_set(pos, new).is_err() + { + continue; + } + if event { + self.post_block_game_event( + "minecraft:block_place", + pos, + Some(Who::Player), + Some(new), + ); + } + } + } + } + } + /// The `BlockPredicate` subset the disk effect uses, tested at `pos`; no + /// predicate matches everything. + fn disk_predicate(&mut self, p: &Value, pos: [i32; 3], placed: BlockStateId) -> bool { + if p.is_null() { + return true; + } + let offset = cell_offset(p); + let at = [0, 1, 2].map(|i| pos[i] + offset[i]); + let state = self.world.block(at[0], at[1], at[2]); + let b = self.res.behaviours(); + let names = |v: &Value| -> Vec { + match v { + Value::String(s) => vec![s.clone()], + Value::Array(a) => a + .iter() + .filter_map(|n| n.as_str().map(String::from)) + .collect(), + _ => Vec::new(), + } + }; + match p["type"].as_str().unwrap_or("") { + "minecraft:all_of" => p["predicates"] + .as_array() + .into_iter() + .flatten() + .all(|q| self.disk_predicate(q, pos, placed)), + // `MatchingBlockTagPredicate` + "minecraft:matching_block_tag" => b + .tag(p["tag"].as_str().unwrap_or("").trim_start_matches('#')) + .is_some_and(|t| t.contains(b.block(state))), + // `MatchingBlocksPredicate` + "minecraft:matching_blocks" => { + names(&p["blocks"]).iter().any(|n| n == b.table.name(state)) + } + // `MatchingFluidsPredicate`: Fluids.WATER is the source. + "minecraft:matching_fluids" => { + let fluid = b.fluid(state); + names(&p["fluids"]).iter().any(|n| match n.as_str() { + "minecraft:water" => fluid.kind() == FluidKind::Water && fluid.is_source(), + "minecraft:flowing_water" => { + fluid.kind() == FluidKind::Water && !fluid.is_source() + } + _ => false, + }) + } + // `UnobstructedPredicate`: no building-blocking entity in the block. + "minecraft:unobstructed" => self.with_level(|_, level, _| { + level.is_unobstructed(BlockPos::new(pos[0], pos[1], pos[2]), placed) + }), + _ => false, + } + } + /// Whether a worn enchantment gives immunity to `#burn_from_stepping` + /// damage (frost walker's `minecraft:damage_immunity`). + pub(crate) fn wears_burn_from_stepping_immunity(&self) -> bool { + self.armor + .iter() + .zip(["head", "chest", "legs", "feet"]) + .any(|(stack, slot)| { + stack + .iter() + .flat_map(ItemStack::enchantments) + .any(|(id, _)| { + self.res.stations().enchantments.get(id).is_some_and(|def| { + def.effects.get("minecraft:damage_immunity").is_some() + && def + .slots + .iter() + .any(|s| s == slot || s == "armor" || s == "any") + }) + }) + }) + } /// Enchantment attribute modifiers of worn armor (respiration, depth strider...). /// Each piece's modifier id ends with its slot (`EnchantmentAttributeEffect.idForSlot`), /// so the same enchantment on two pieces stacks instead of replacing itself. @@ -479,3 +653,35 @@ impl Game<'_> { self.potions.enchant_modifiers = wanted; } } + +/// An effect's or predicate's `offset` vector (zero when absent). +fn cell_offset(v: &Value) -> [i32; 3] { + let at = |i: usize| { + v["offset"] + .get(i) + .and_then(Value::as_i64) + .map_or(0, |n| n as i32) + }; + [at(0), at(1), at(2)] +} +/// The loot-condition subset a `location_changed` effect requires of the +/// wearer: standing on the ground and not riding (frost walker). +fn location_requirements(req: &Value, on_ground: bool, riding: bool) -> bool { + match req["type"].as_str().unwrap_or("") { + "" if req.is_null() => true, + "minecraft:all_of" => req["terms"] + .as_array() + .into_iter() + .flatten() + .all(|t| location_requirements(t, on_ground, riding)), + "minecraft:inverted" => !location_requirements(&req["term"], on_ground, riding), + "minecraft:entity_properties" => { + let p = &req["predicate"]; + p["minecraft:flags"]["is_on_ground"] + .as_bool() + .is_none_or(|v| v == on_ground) + && (p["minecraft:vehicle"].is_null() || riding) + } + _ => false, + } +} diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 43bb573dc..64fda0636 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -2187,6 +2187,7 @@ impl Game<'_> { let (rules, motion) = (game.world.health_rules, game.motion); let health = &motion.health; let freeze_immune = game.wears_freeze_immune(); + let burn_immune = game.wears_burn_from_stepping_immunity(); let Some(player) = game.player.as_mut() else { return (Vec::new(), None); }; @@ -2251,6 +2252,7 @@ impl Game<'_> { // lit campfires and grown sweet berry bushes hurt (#1305). w.player.shift_key_down = sneaking; w.player.freeze_immune = freeze_immune; + w.player.burn_from_stepping_immune = burn_immune; let _ = w.server_block_damage(start); let _ = w.tick_environment_damage(); let _ = w.apply_fire_contact(); @@ -2276,6 +2278,9 @@ impl Game<'_> { for d in travelled { game.movement_stats(Vec3::new(d[0], d[1], d[2])); } + // LivingEntity.baseTick: a new block position runs the worn + // enchantments' location_changed effects (frost walker). + game.location_changed_effects([start.x, start.y, start.z], from_ground); // LivingEntity.baseTick: outside the world border, then tickEffects. game.border_damage(); game.tick_mob_effects(); diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index 0bce8927c..b8f2d981d 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -302,6 +302,8 @@ pub struct PlayerMotion { pub leather_boots: bool, /// An armor piece in `#freeze_immune_wearables` (`LivingEntity.canFreeze`). pub freeze_immune: bool, + /// A worn enchantment's `damage_immunity` to `#burn_from_stepping` (frost walker). + pub burn_from_stepping_immune: bool, /// `Entity.oldPosition`: where this tick started. pub old_position: Vec3, /// The server's copy of a player another client moves (a LAN guest), while @@ -475,6 +477,7 @@ impl PlayerMotion { ticks_frozen: 0, leather_boots: false, freeze_immune: false, + burn_from_stepping_immune: false, old_position: position, server_copy: false, client_side: false, diff --git a/crates/horizon-client/src/motion/environment.rs b/crates/horizon-client/src/motion/environment.rs index fc3c63c77..47033d676 100644 --- a/crates/horizon-client/src/motion/environment.rs +++ b/crates/horizon-client/src/motion/environment.rs @@ -10,6 +10,12 @@ impl MotionWorld<'_, '_, '_> { if self.player.invulnerable || self.player.spectator { return Ok(()); } + // Frost walker's `damage_immunity`: #burn_from_stepping (magma, campfire). + if self.player.burn_from_stepping_immune + && matches!(source, "minecraft:hot_floor" | "minecraft:campfire") + { + return Ok(()); + } let id = self .resources .health From 9d4c984e03154fcc86e3cb1593477e921a76ba06 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:49:31 +0100 Subject: [PATCH 13/84] Speed up an enderman while it has a target --- crates/horizon-client/src/mobs.rs | 4 +++- crates/horizon-client/src/mobs/enderman.rs | 9 +++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 00c21633e..133000ff0 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1847,7 +1847,9 @@ impl Mob { /// Movement speed attribute bonus (baby zombies, sprinting modifiers). /// MOVEMENT_SPEED including effects (speed +20%/level, slowness -15%/level). pub fn movement_speed(&self) -> f64 { - let mut v = strider::movement_speed(self, self.attrs.speed) * self.speed_bonus(); + let mut v = + strider::movement_speed(self, self.attrs.speed + enderman::attacking_speed(self)) + * self.speed_bonus(); for (e, _, amp) in &self.extra.effects { match *e { "minecraft:speed" => v *= 1.0 + 0.2 * f64::from(amp + 1), diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs index c5ed01680..06f5cd3f3 100644 --- a/crates/horizon-client/src/mobs/enderman.rs +++ b/crates/horizon-client/src/mobs/enderman.rs @@ -138,6 +138,15 @@ fn teleport_towards( let z = m.position.z + (m.random.next_double() - 0.5) * 8.0 - d[2] * 16.0; teleport_to(m, w, x, y, z, events) } +/// `Enderman.SPEED_MODIFIER_ATTACKING`, an ADD_VALUE modifier `setTarget` +/// adds while the enderman has a target. +pub fn attacking_speed(m: &Mob) -> f64 { + if m.species() == Species::Enderman && m.ai.target.is_some() { + f64::from(0.15f32) + } else { + 0.0 + } +} /// Enderman.customServerAiStep: in daylight, flee by teleporting. The End has a /// fixed time, so `Level.isBrightOutside` is never true there. pub fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { From 4c8ff0296988236ff4b33e83b082a4892228a794 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:51:03 +0100 Subject: [PATCH 14/84] Make skeleton arrow spread and damage follow the difficulty --- crates/horizon-client/src/mobs/spawning.rs | 4 ++++ crates/horizon-client/src/mobs/undead.rs | 5 +++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs index 93e3fe119..5d8a928f8 100644 --- a/crates/horizon-client/src/mobs/spawning.rs +++ b/crates/horizon-client/src/mobs/spawning.rs @@ -34,6 +34,8 @@ pub fn placement_ok(species: Species, w: &MobWorld, x: i32, y: i32, z: i32) -> b /// `DifficultyInstance`: the local difficulty at a position. #[derive(Clone, Copy, Debug)] pub struct LocalDifficulty { + /// `Difficulty.getId`: 0 peaceful to 3 hard. + pub id: u8, pub effective: f32, /// The world difficulty is hard. pub hard: bool, @@ -47,6 +49,7 @@ impl LocalDifficulty { let hard = base == 3; if base == 0 { return Self { + id: base, effective: 0.0, hard, }; @@ -59,6 +62,7 @@ impl LocalDifficulty { local *= 0.5; } Self { + id: base, effective: f32::from(base) * (0.75 + global + local), hard, } diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs index e77a37641..1fcea9c12 100644 --- a/crates/horizon-client/src/mobs/undead.rs +++ b/crates/horizon-client/src/mobs/undead.rs @@ -743,8 +743,9 @@ pub fn perform_ranged_attack(m: &mut Mob, who: Who, cx: &mut Cx, power: f32) { let zd = t.position.z - m.position.z; let dist = (xd * xd + zd * zd).sqrt(); // AbstractArrow.setBaseDamageFromMob: power * 2 + triangle(difficulty * 0.11, 0.57425). + let id = i32::from(cx.w.difficulty.id); let mut arrow_random = crate::projectiles::own_random(m); - let base = f64::from(power) * 2.0 + arrow_random.triangle(2.0 * 0.11, 0.574_25); + let base = f64::from(power) * 2.0 + arrow_random.triangle(f64::from(id) * 0.11, 0.574_25); let effect = match m.species() { Species::Stray => Some(("minecraft:slowness", 600)), Species::Bogged => Some(("minecraft:poison", 100)), @@ -765,7 +766,7 @@ pub fn perform_ranged_attack(m: &mut Mob, who: Who, cx: &mut Cx, power: f32) { &mut arrow_random, [xd, yd + dist * 0.2, zd], 1.6, - (14 - 2 * 4) as f32, + (14 - id * 4) as f32, ); cx.events.push(MobEvent::Projectile(p)); let pitch = 1.0 / (m.random.next_float() * 0.4 + 0.8); From 708702917c35ecfab2c3cd35de15cfc71ada76be Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:51:16 +0100 Subject: [PATCH 15/84] Remove an endermite after 2400 ticks --- crates/horizon-client/src/entity_nbt.rs | 6 ++++++ crates/horizon-client/src/mobs/ai.rs | 10 ++++++++++ 2 files changed, 16 insertions(+) diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 7f3565067..3e22145fb 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -458,6 +458,9 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.insert("life_ticks".into(), Tag::Int(m.extra.egg_time)); } } + "minecraft:endermite" => { + map.insert("Lifetime".into(), Tag::Int(m.extra.counter)); + } "minecraft:shulker" => { map.insert("AttachFace".into(), Tag::Byte(m.extra.variant3 as i8)); map.insert("Peek".into(), Tag::Byte(m.extra.counter as i8)); @@ -881,6 +884,9 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.extra.counter2 = number(tag.get("StunTick")).unwrap_or(0) as i32; m.extra.anim_ticks = number(tag.get("RoarTick")).unwrap_or(0) as i32; } + if m.species() == crate::mobs::Species::Endermite { + m.extra.counter = number(tag.get("Lifetime")).unwrap_or(0) as i32; + } if m.species() == crate::mobs::Species::Vex { if let Some(Tag::IntArray(v)) = tag.get("bound_pos") && v.len() == 3 diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 2676c3a37..560afe08c 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -961,6 +961,16 @@ fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } match m.species() { Species::Enderman => super::enderman::ai_step(m, w, events), + // Endermite.aiStep: `counter` is the life; an endermite not required + // to persist is discarded at 2400. + Species::Endermite => { + if !m.persistent { + m.extra.counter += 1; + } + if m.extra.counter >= 2400 { + m.removed = true; + } + } Species::Wolf => super::tame::ai_step(m, w, events), Species::Cat => super::tame::cat_ai_step(m, events), Species::Blaze => super::nether::blaze_ai_step(m, events), From 4084bcdf753c4e1c517ea1667b632016cfc7b110 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:54:11 +0100 Subject: [PATCH 16/84] Let a brush dust suspicious sand and gravel --- crates/horizon-client/src/game.rs | 25 ++ crates/horizon-client/src/game/brush.rs | 246 ++++++++++++++++++++ crates/horizon-client/src/game/item_draw.rs | 5 +- crates/horizon-client/src/game/lan.rs | 5 +- crates/horizon-client/src/game/remote.rs | 33 +++ crates/horizon-world/src/level/mod.rs | 3 +- crates/horizon-world/src/level/tick.rs | 7 + 7 files changed, 319 insertions(+), 5 deletions(-) create mode 100644 crates/horizon-client/src/game/brush.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 64d5b2766..b20de6ea8 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -18,6 +18,7 @@ mod boats; mod books; mod bossbars; mod breezes; +mod brush; mod campfire; mod campfire_douse; mod cartography; @@ -1653,6 +1654,8 @@ struct Game<'a> { boss_overlay: horizon_client::boss_overlay::BossOverlay, exec: commands::execute::ExecState, rand_sequences: horizon_client::random_sequences::RandomSequences, + /// `BrushableBlockEntity`'s brush counts of the blocks being brushed. + brushing: brush::Brushing, border: horizon_client::worldborder::WorldBorder, /// `WorldBorderRenderer` and its render state. border_renderer: horizon_client::border_render::BorderRenderer, @@ -2796,6 +2799,11 @@ impl Game<'_> { data, } => self.sculk_charge_event(pos, data), LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos), + LevelEvent::LevelEvent { + id: 3008, + pos, + data, + } => self.brush_complete_event([pos.x, pos.y, pos.z], data), LevelEvent::LevelEvent { id: 2004, pos, .. } => { self.spawner_burst([pos.x, pos.y, pos.z]) } @@ -2972,6 +2980,11 @@ impl Game<'_> { kind: "command_block", .. } => self.command_block_tick(pos), + LevelEvent::BlockEvent { + pos, + kind: "brushable", + .. + } => self.brushable_tick([pos.x, pos.y, pos.z]), LevelEvent::BlockEvent { pos, kind: "hatch", .. } => { @@ -3674,6 +3687,13 @@ impl Game<'_> { { return Ok(true); } + // BrushItem.useOn: brushing starts on the block aimed at (CONSUME). + if block_hit.is_some() && &*stack.item == "minecraft:brush" { + if self.using.is_none() { + self.using = Some((self.held_slot(), 0)); + } + return Ok(true); + } if !on_block && (self.raise_shield(self.held_slot()) || self.use_fishing_rod(&stack) @@ -3962,6 +3982,10 @@ impl Game<'_> { } return; } + if &*stack.item == "minecraft:brush" { + self.tick_brush(slot, ticks); + return; + } let Some(consumable) = info.consumable.as_ref() else { self.using = None; return; @@ -12540,6 +12564,7 @@ impl<'a> Game<'a> { boss_overlay: Default::default(), exec: Default::default(), rand_sequences: Default::default(), + brushing: Default::default(), border: Default::default(), border_renderer: Default::default(), border_state: Default::default(), diff --git a/crates/horizon-client/src/game/brush.rs b/crates/horizon-client/src/game/brush.rs new file mode 100644 index 000000000..c064a3153 --- /dev/null +++ b/crates/horizon-client/src/game/brush.rs @@ -0,0 +1,246 @@ +//! Brushing suspicious sand and gravel: `BrushItem.onUseTick` and +//! `BrushableBlockEntity`. The block's loot table stays in its saved block +//! entity (like a decorated pot's) until the first counted stroke rolls it. +use super::{Game, Hit, decorated_pot, spill, view_vector}; +use horizon_client::{ + particles::{ParticleOptions, ParticleType}, + save, +}; +use horizon_core::random::RandomSource; +use std::collections::HashMap; + +/// `BrushItem.USE_DURATION`. +const USE_DURATION: u32 = 200; + +/// A brushable block's counters. Vanilla never saves them: the block's +/// `dusted` state is all that is left after a reload. +#[derive(Default)] +pub(super) struct BrushState { + count: i32, + resets_at: i64, + cooldown_ends_at: i64, + hit_face: Option<[i32; 3]>, +} + +/// `BrushableBlockEntity.getCompletionState`: the `dusted` property. +fn completion_state(count: i32) -> i32 { + match count { + 0 => 0, + 1..=2 => 1, + 3..=5 => 2, + _ => 3, + } +} + +pub(super) type Brushing = HashMap<[i32; 3], BrushState>; + +impl Game<'_> { + /// `BrushItem.onUseTick` for a brush used `ticks` ticks so far, the + /// hand of `slot` acting. + pub(super) fn tick_brush(&mut self, slot: usize, ticks: u32) { + // No block under the crosshair: releaseUsingItem. + let Some(hit) = self.pick() else { + self.using = None; + return; + }; + let elapsed = ticks + 1; + // The last tick before the backswing. + if elapsed % 10 == 5 { + self.brush_stroke(&hit, slot); + } + // The use ends after 200 ticks; the held button starts it again. + self.using = (elapsed < USE_DURATION).then_some((slot, elapsed)); + } + + /// One stroke on the block aimed at: dust (this window only), the brush + /// sound, and the block entity's count. The brush wears when the block + /// changed state. + fn brush_stroke(&mut self, hit: &Hit, slot: usize) { + let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]); + let name = self.res.facts().get(state).name.clone(); + let (sound, brushable) = match &*name { + "minecraft:suspicious_sand" => ("minecraft:item.brush.brushing.sand", true), + "minecraft:suspicious_gravel" => ("minecraft:item.brush.brushing.gravel", true), + _ => ("minecraft:item.brush.brushing.generic", false), + }; + if self.lan_acting.is_none() { + self.brush_dust(hit, slot == super::shield::OFFHAND_SLOT); + } + let at = hit.pos.map(|v| f64::from(v) + 0.5); + self.audio.play(sound, Some(at), 1.0, 1.0); + if brushable && self.brush_block(hit.pos, hit.face) { + self.damage_held(1); + } + } + + /// `BrushItem.spawnDustParticles`. + pub(super) fn brush_dust(&mut self, hit: &Hit, off_hand: bool) { + let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]); + let Some((sprite, tint)) = self.particle_sprite(state, hit.pos) else { + return; + }; + let options = ParticleOptions::block(ParticleType::Block, sprite, tint); + // The arm that brushes: the main arm, or the other one for the off hand. + let flip = if off_hand == self.settings.main_hand_left { + 1.0 + } else { + -1.0 + }; + let view = view_vector(self.yaw, self.pitch); + // DustParticlesDelta.fromDirection. + let (dx, dz) = match hit.face { + [0, _, 0] => (view[2], -view[0]), + [0, 0, -1] => (1.0, -0.1), + [0, 0, 1] => (-1.0, 0.1), + [-1, 0, 0] => (-0.1, -1.0), + _ => (0.1, 1.0), + }; + let count = 7 + self.particles.level_random().next_int_bound(5).unwrap_or(0); + let x = hit.point[0] - if hit.face == [-1, 0, 0] { 1.0e-6 } else { 0.0 }; + let z = hit.point[2] - if hit.face == [0, 0, -1] { 1.0e-6 } else { 0.0 }; + for _ in 0..count { + let random = self.particles.level_random(); + let v = [ + dx * flip * 3.0 * random.next_double(), + 0.0, + dz * flip * 3.0 * random.next_double(), + ]; + self.particles.add(&options, [x, hit.point[1], z], v); + } + } + + /// `BrushableBlockEntity.brush`: whether the block changed (the brush wears). + fn brush_block(&mut self, pos: [i32; 3], face: [i32; 3]) -> bool { + let time = self.world.game_time; + let mut brush = self.brushing.remove(&pos).unwrap_or_default(); + brush.hit_face.get_or_insert(face); + brush.resets_at = time + 40; + if time < brush.cooldown_ends_at { + self.brushing.insert(pos, brush); + return false; + } + brush.cooldown_ends_at = time + 10; + self.unpack_brush_loot(pos); + let before = completion_state(brush.count); + brush.count += 1; + if brush.count >= 10 { + self.brushing_completed(pos, brush.hit_face); + return true; + } + self.schedule_brushable_tick(pos); + let after = completion_state(brush.count); + self.brushing.insert(pos, brush); + if before != after { + self.set_dusted(pos, after); + } + false + } + + /// `BrushableBlockEntity.unpackLootTable`: the table's roll becomes the + /// block entity's item. + fn unpack_brush_loot(&mut self, pos: [i32; 3]) { + let Some(mut tag) = spill::saved_entity(&self.world, pos) else { + return; + }; + if tag.get("LootTable").is_none() { + return; + } + let loot = horizon_client::structure_blocks::loot_data(&self.options.resources); + decorated_pot::unpack_loot( + &mut tag, + loot.as_deref(), + &mut self.world.random, + &mut self.rand_sequences, + self.level.seed, + ); + spill::put_saved_entity(&mut self.world, pos, tag); + } + + /// `BrushableBlockEntity.brushingCompleted`: the item drops out of the + /// brushed face and the block turns into its sand or gravel. + fn brushing_completed(&mut self, pos: [i32; 3], face: Option<[i32; 3]>) { + let state = self.world.block(pos[0], pos[1], pos[2]); + let turns_into = match &*self.res.facts().get(state).name { + "minecraft:suspicious_sand" => "minecraft:sand", + "minecraft:suspicious_gravel" => "minecraft:gravel", + _ => "minecraft:air", + }; + // dropContent: the item at the middle of the block beside that face. + let item = spill::saved_entity(&self.world, pos) + .and_then(|tag| tag.get("item").and_then(save::item_from_nbt)); + if let Some(mut item) = item { + let face = face.unwrap_or([0, 1, 0]); + let take = 10 + self.world.random.next_int_bound(21).unwrap_or(0); + item.count = item.count.min(take as u32); + let at = [ + f64::from(pos[0] + face[0]) + 0.5, + f64::from(pos[1] + face[1]) + 0.625, + f64::from(pos[2] + face[2]) + 0.5, + ]; + self.spawn_item(item, at, [0.0; 3], 0); + } + // Level event 3008 for every player, then the block change. + self.level_event_at(3008, pos, state.0 as i32); + if let Some(base) = self.pack.assets.registry.default_state(turns_into) { + let _ = self.level_set(pos, base); + } + } + + fn set_dusted(&mut self, pos: [i32; 3], dusted: i32) { + let registry = self.pack.assets.registry; + let Some(mut state) = registry + .state(self.world.block(pos[0], pos[1], pos[2])) + .cloned() + else { + return; + }; + state.properties.insert("dusted".into(), dusted.to_string()); + if let Ok(state) = registry.resolve(&state) { + let _ = self.level_set(pos, state); + } + } + + fn schedule_brushable_tick(&mut self, pos: [i32; 3]) { + let at = horizon_core::position::BlockPos::new(pos[0], pos[1], pos[2]); + self.with_level(|b, level, ticks| b.schedule_tick(level, ticks, at, 2)); + } + + /// `BrushableBlockEntity.checkReset`, from `BrushableBlock.tick`: a block + /// left alone loses two counts, again every four ticks. + pub(super) fn brushable_tick(&mut self, pos: [i32; 3]) { + let time = self.world.game_time; + let Some(mut brush) = self.brushing.remove(&pos) else { + return; + }; + let before = completion_state(brush.count); + if brush.count != 0 && time >= brush.resets_at { + brush.count = (brush.count - 2).max(0); + brush.resets_at = time + 4; + } + let after = completion_state(brush.count); + if brush.count != 0 { + self.brushing.insert(pos, brush); + self.schedule_brushable_tick(pos); + } + if before != after { + self.set_dusted(pos, after); + } + } + + /// Level event 3008 (`LevelEventHandler`): the finished block's sound + /// and break particles. + pub(super) fn brush_complete_event(&mut self, pos: [i32; 3], data: i32) { + let state = horizon_world::registry::BlockStateId(data as u32); + let sound = match &*self.res.facts().get(state).name { + "minecraft:suspicious_sand" => "minecraft:item.brush.brushing.sand.complete", + "minecraft:suspicious_gravel" => "minecraft:item.brush.brushing.gravel.complete", + _ => "", + }; + if !sound.is_empty() { + let at = pos.map(|v| f64::from(v) + 0.5); + // Each client plays it from the event itself. + self.audio.play_unshared(sound, Some(at), 1.0, 1.0); + } + self.destroy_particles(pos, state); + } +} diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index b6b7e2fb7..8deb483c1 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -179,8 +179,9 @@ fn use_duration(components: &Components) -> i32 { | "minecraft:crossbow" | "minecraft:trident" | "minecraft:spyglass" - | "minecraft:goat_horn" - | "minecraft:brush" => 72_000, + | "minecraft:goat_horn" => 72_000, + // BrushItem.USE_DURATION. + "minecraft:brush" => 200, _ => 0, } } diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 5292cd31b..e4c9d19a7 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1187,9 +1187,10 @@ impl Game<'_> { match e { horizon_world::level::LevelEvent::LevelEvent { id, pos, data } => { // The acting guest does not predict the egg's teleport - // particles, bone meal's growth, or anvil result sounds + // particles, bone meal's growth, anvil result sounds, or a + // finished brushing // (these levelEvent calls name no excluded player). - let except = if matches!(*id, 2015 | 1505 | 1029 | 1030) { + let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 3008) { None } else { self.lan_acting diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3cfbd15e3..5c25fc9b8 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -4063,6 +4063,15 @@ impl Game<'_> { } if reacts { self.predict_use(&changes, seq); + } else if held.as_ref().is_some_and(|s| &*s.item == "minecraft:brush") { + // BrushItem.useOn: brushing starts here (CONSUME, no swing); the + // server brushes and the dust is this client's own. + self.with_hand(hand, |g| { + if g.using.is_none() { + g.using = Some((g.held_slot(), 0)); + } + }); + return true; } else if let Some(stack) = held.as_ref() && self.predict_item_on_block(stack, &hit) { @@ -4383,6 +4392,30 @@ impl Game<'_> { // Another hotbar slot picked: LivingEntity.updatingUsingItem sees a // different stack in the hand. The off hand keeps its item. let in_hand = slot == self.selected || slot == super::shield::OFFHAND_SLOT; + // BrushItem.onUseTick: with no block aimed the use ends (the server + // ends it too); a stroke shows its dust. Its sounds are the server's. + if stack + .as_ref() + .is_some_and(|s| &*s.item == "minecraft:brush") + { + let elapsed = ticks + 1; + let hit = self.pick().filter(|_| in_hand); + if let Some(hit) = &hit + && elapsed % 10 == 5 + { + self.brush_dust(hit, slot == super::shield::OFFHAND_SLOT); + } + if hit.is_none() && in_hand { + self.send(S::PlayerAction(play::PlayerAction { + action: 6, + pos: [0; 3], + direction: 0, + sequence: 0, + })); + } + self.using = hit.and(Some((slot, elapsed))).filter(|_| elapsed < 200); + return; + } // A drawn bow, a charging crossbow, a raised shield...: held until // the button lets go. if stack.as_ref().is_some_and(|s| self.held_until_released(s)) { diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index a384b38b7..d9c63a493 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -252,7 +252,8 @@ pub enum LevelEvent { /// event follow as their own events; the caller removes the block. PrimeTnt { pos: BlockPos, rot: f64 }, /// Block-entity or entity side effects the caller implements: `"dispense"` - /// (dispenser/dropper/crafter scheduled tick), `"hatch"` (frogspawn + /// (dispenser/dropper/crafter scheduled tick), `"brushable"` (a suspicious + /// block's scheduled tick: `checkReset`), `"hatch"` (frogspawn /// hatched into tadpoles; the block is already destroyed), `"portal_spawn"` /// (a nether portal won its zombified piglin roll; the caller checks /// `anyPlayerCloseEnoughForSpawning` and spawns below the portal). diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index 29f53e053..186f64bd7 100644 --- a/crates/horizon-world/src/level/tick.rs +++ b/crates/horizon-world/src/level/tick.rs @@ -127,6 +127,13 @@ impl Sim<'_, L> { } Class::FallingBlock => self.falling_block_tick(pos, state), Class::Brushable => { + // BrushableBlock.tick checks the brush reset first (the + // caller keeps the brush counts). + self.emit(LevelEvent::BlockEvent { + pos, + state, + kind: "brushable", + }); if self.is_free(self.below_state(pos)) && pos.y >= self.level.min_y() { self.falling_block_fall(pos, state); } From b92dd805668a9a6a3ab5deee65054fcad0c54407 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 18:55:02 +0100 Subject: [PATCH 17/84] Let silverfish hide in stone and wake their friends when hurt --- crates/horizon-client/src/game/creatures.rs | 42 +++++ crates/horizon-client/src/game/spawner.rs | 2 +- crates/horizon-client/src/mobs.rs | 8 + crates/horizon-client/src/mobs/ai.rs | 6 +- crates/horizon-client/src/mobs/hostile.rs | 150 +++++++++++++++++- .../src/mobs/spawn_selection.rs | 2 +- 6 files changed, 206 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2b65a3289..6f5937a81 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1065,8 +1065,50 @@ impl Game<'_> { self.world.set(pos[0], pos[1], pos[2], state)?; } } + MobEvent::Infest { + pos, + infested, + poof, + } => { + let registry = &self.pack.assets.registry; + let old = self.world.block(pos[0], pos[1], pos[2]); + if let Some(mut state) = registry.state(old).cloned() { + let (from, to) = if infested { + ("minecraft:", "minecraft:infested_") + } else { + ("minecraft:infested_", "minecraft:") + }; + state.name = state.name.replacen(from, to, 1); + if let Ok(id) = registry.resolve(&state) { + self.world.set(pos[0], pos[1], pos[2], id)?; + } + } + if let Some(mob) = poof { + self.mob_poof(mob); + } + } MobEvent::BreakBlock { pos, drop } => { let old = self.world.block(pos[0], pos[1], pos[2]); + // InfestedBlock.spawnAfterBreak: its silverfish comes out + // when blocks drop. + if drop + && self + .res + .facts() + .get(old) + .name + .starts_with("minecraft:infested_") + && self.ui.rules.bool("block_drops") + { + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]), + f64::from(pos[2]) + 0.5, + ]; + if let Some(id) = self.spawn_mob("minecraft:silverfish", at, false) { + self.mob_poof(id); + } + } // Block.spawnDestroyParticles: fire breaks leave nothing. if !self.res.facts().get(old).has_class("BaseFireBlock") { self.destroy_particles(pos, old); diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs index 538cb39e7..5dd907afb 100644 --- a/crates/horizon-client/src/game/spawner.rs +++ b/crates/horizon-client/src/game/spawner.rs @@ -253,7 +253,7 @@ impl Game<'_> { self.world.modified.insert((key.0 >> 4, key.2 >> 4)); } /// `LivingEntity.makePoofParticles` (entity event 20) for a mob. - fn mob_poof(&mut self, id: u32) { + pub(super) fn mob_poof(&mut self, id: u32) { let Some(m) = self.mobs.iter().find(|m| m.id == id) else { return; }; diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 00c21633e..7bf034632 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1009,6 +1009,14 @@ pub enum MobEvent { pos: [i32; 3], open: bool, }, + /// `InfestedBlock.infestedStateByHost` (`infested`) or `hostStateByInfested` + /// for the block there, keeping its axis; `poof` is the silverfish that + /// hid in it (`spawnAnim`). + Infest { + pos: [i32; 3], + infested: bool, + poof: Option, + }, /// Destroy a block, dropping nothing (sheep eating grass becomes dirt via SetBlock). BreakBlock { pos: [i32; 3], diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 2676c3a37..fe3cdafb3 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -121,7 +121,7 @@ pub fn family(s: Species) -> Family { | S::Parched | S::WitherSkeleton | S::ZombifiedPiglin => Family::Undead, - S::Creeper | S::Spider | S::CaveSpider => Family::Hostile, + S::Creeper | S::Spider | S::CaveSpider | S::Silverfish => Family::Hostile, S::Squid | S::GlowSquid | S::Cod @@ -1306,6 +1306,10 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, _amount: f32) -> bool { super::bee::hurt(m); true } + Species::Silverfish => { + super::hostile::silverfish_hurt(m, source); + true + } Species::Enderman => super::enderman::on_damage(m, source), Species::WitherSkeleton | Species::Blaze | Species::MagmaCube | Species::Strider if source.is_fire() => diff --git a/crates/horizon-client/src/mobs/hostile.rs b/crates/horizon-client/src/mobs/hostile.rs index 0d3feaa6c..a58e4a909 100644 --- a/crates/horizon-client/src/mobs/hostile.rs +++ b/crates/horizon-client/src/mobs/hostile.rs @@ -1,7 +1,7 @@ //! Creepers (swelling, explosions) and spiders (wall climbing, daylight //! neutrality, leaping). use super::{ - Mob, MobEvent, MobWorld, Species, Who, + Damage, DamageKind, Mob, MobEvent, MobWorld, Species, Who, goals::{ Avoid, AvoidEntity, Cx, Float, Goal, HurtByTarget, LeapAtTarget, LookAtPlayer, MOVE, MeleeAttack, NearestTarget, RandomLookAround, Stroll, goal_clone, @@ -54,9 +54,157 @@ pub fn register(m: &mut Mob) { ); m.ai.nav.kind = super::nav::NavKind::WallClimber; } + S::Silverfish => { + let g = &mut m.ai.goals; + g.add(1, Float); + g.add(3, SilverfishWakeUpFriends); + g.add(4, MeleeAttack::new(1.0, false)); + g.add(5, SilverfishMergeWithStone::default()); + m.ai.targets.add(1, HurtByTarget::new().alert()); + m.ai.targets.add(2, NearestTarget::player(true)); + } _ => {} } } +/// `Silverfish.hurtServer`: a hit by an entity (or magic damage) starts the +/// countdown of its wake-up goal, kept in `extra.counter`. +pub fn silverfish_hurt(m: &mut Mob, source: &Damage) { + if (source.attacker.is_some() || source.kind == DamageKind::Magic) && m.extra.counter == 0 { + m.extra.counter = super::goals::reduced(20); + } +} +/// `Silverfish.SilverfishWakeUpFriendsGoal`: 20 ticks after being hurt, the +/// infested blocks within 10 blocks sideways and 5 up or down break (or turn +/// back into stone with mob griefing off), until a coin flip stops it. +#[derive(Clone, Debug)] +struct SilverfishWakeUpFriends; +impl Goal for SilverfishWakeUpFriends { + goal_clone!(); + fn name(&self) -> &'static str { + "SilverfishWakeUpFriendsGoal" + } + fn flags(&self) -> u8 { + 0 + } + fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + m.extra.counter > 0 + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + m.extra.counter -= 1; + if m.extra.counter > 0 { + return; + } + let base = [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ]; + // The loops' offsets go 0, 1, -1, 2, -2 and so on. + let offsets = |limit: i32| std::iter::once(0).chain((1..=limit).flat_map(|i| [i, -i])); + for y in offsets(5) { + for x in offsets(10) { + for z in offsets(10) { + let pos = [base[0] + x, base[1] + y, base[2] + z]; + if !cx + .w + .block_name(pos[0], pos[1], pos[2]) + .starts_with("minecraft:infested_") + { + continue; + } + if cx.w.mob_griefing { + cx.events.push(MobEvent::BreakBlock { pos, drop: true }); + } else { + cx.events.push(MobEvent::Infest { + pos, + infested: false, + poof: None, + }); + } + if m.random.next_boolean() { + return; + } + } + } + } + } +} +/// `Silverfish.SilverfishMergeWithStoneGoal`: a stroll that, now and then +/// with mob griefing on, hides in a stone block next to the silverfish. +#[derive(Clone, Debug)] +struct SilverfishMergeWithStone { + stroll: Stroll, + merge: Option<[i32; 3]>, +} +impl Default for SilverfishMergeWithStone { + fn default() -> Self { + Self { + stroll: Stroll::new(1.0).interval(10), + merge: None, + } + } +} +impl Goal for SilverfishMergeWithStone { + goal_clone!(); + fn name(&self) -> &'static str { + "SilverfishMergeWithStoneGoal" + } + fn flags(&self) -> u8 { + MOVE + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if m.ai.target.is_some() || !m.ai.nav.is_done() { + return false; + } + if cx.w.mob_griefing + && m.random + .next_int_bound(super::goals::reduced(10)) + .unwrap_or(1) + == 0 + { + // Direction.getRandom: down, up, north, south, west, east. + const DIRECTIONS: [[i32; 3]; 6] = [ + [0, -1, 0], + [0, 1, 0], + [0, 0, -1], + [0, 0, 1], + [-1, 0, 0], + [1, 0, 0], + ]; + let d = DIRECTIONS[m.random.next_int_bound(6).unwrap_or(0) as usize]; + let pos = [ + m.position.x.floor() as i32 + d[0], + (m.position.y + 0.5).floor() as i32 + d[1], + m.position.z.floor() as i32 + d[2], + ]; + if super::spawn_selection::infested_host(cx.w.block_name(pos[0], pos[1], pos[2])) { + self.merge = Some(pos); + return true; + } + } + self.merge = None; + self.stroll.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.merge.is_none() && self.stroll.can_continue(m, cx) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(pos) = self.merge else { + return self.stroll.start(m, cx); + }; + if super::spawn_selection::infested_host(cx.w.block_name(pos[0], pos[1], pos[2])) { + cx.events.push(MobEvent::Infest { + pos, + infested: true, + poof: Some(m.id), + }); + m.removed = true; + } + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.stroll.stop(m, cx); + } +} /// Entity.getLightLevelDependentMagicValue at the eye. pub fn mob_brightness(m: &Mob, w: &MobWorld) -> f32 { w.brightness( diff --git a/crates/horizon-client/src/mobs/spawn_selection.rs b/crates/horizon-client/src/mobs/spawn_selection.rs index 4e51722f1..dc6a2fc72 100644 --- a/crates/horizon-client/src/mobs/spawn_selection.rs +++ b/crates/horizon-client/src/mobs/spawn_selection.rs @@ -535,7 +535,7 @@ pub(crate) fn mob_spawn_rules(s: Species, l: &L, x: i32, y: i32 value >= 0.0 } /// `InfestedBlock.isCompatibleHostBlock`. -fn infested_host(block: &str) -> bool { +pub fn infested_host(block: &str) -> bool { matches!( block, "minecraft:stone" From 81b4c09ee6fd2cb5c83c43e7b8f67e92c12366e7 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:06:53 +0100 Subject: [PATCH 18/84] Count the endermite lifetime with NoAI set --- crates/horizon-client/src/mobs/ai.rs | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 560afe08c..d61f2caa0 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -397,7 +397,13 @@ pub fn tick( } return false; } - if !m.no_ai { + if m.no_ai { + // Mob.aiStep still runs without AI (only serverAiStep is skipped), + // so the endermite's life keeps counting. + if m.species() == Species::Endermite { + endermite_lifetime(m); + } + } else { ai_step(m, w, level_random, events); } if m.species() == Species::Rabbit { @@ -955,6 +961,16 @@ fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { _ => {} } } +/// Endermite.aiStep: `counter` is the life; an endermite not required to +/// persist is discarded at 2400. +fn endermite_lifetime(m: &mut Mob) { + if !m.persistent { + m.extra.counter += 1; + } + if m.extra.counter >= 2400 { + m.removed = true; + } +} fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { if family(m.species()) == Family::Aquatic { aquatic::ai_step(m, w, events); @@ -963,14 +979,7 @@ fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { Species::Enderman => super::enderman::ai_step(m, w, events), // Endermite.aiStep: `counter` is the life; an endermite not required // to persist is discarded at 2400. - Species::Endermite => { - if !m.persistent { - m.extra.counter += 1; - } - if m.extra.counter >= 2400 { - m.removed = true; - } - } + Species::Endermite => endermite_lifetime(m), Species::Wolf => super::tame::ai_step(m, w, events), Species::Cat => super::tame::cat_ai_step(m, events), Species::Blaze => super::nether::blaze_ai_step(m, events), From 79c3896449584da2309eea8db8aad12d8e949eda Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:13:58 +0100 Subject: [PATCH 19/84] Respawn on a free column within the respawn radius around the world spawn --- crates/horizon-client/src/game.rs | 17 +++-- crates/horizon-client/src/game/end.rs | 10 ++- .../horizon-client/src/game/initial_spawn.rs | 69 +++++++++++++------ crates/horizon-client/src/game/lan_actions.rs | 8 +++ .../horizon-client/src/game/server_travel.rs | 37 +++++++++- 5 files changed, 110 insertions(+), 31 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 8448f0837..2d853cbe5 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4253,11 +4253,18 @@ impl Game<'_> { if !(-1..=1).all(|dz| (-1..=1).all(|dx| self.streaming.is_lit(cx + dx, cz + dz))) { return Ok(()); } - // WorldSpawn: the stored column, lifted onto its current surface. - let y = self - .land_column(s.x.floor() as i32, s.z.floor() as i32) - .map_or(s.y, f64::from); - Vec3::new(s.x, y.max(s.y), s.z) + let column = [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32]; + if self.level.world_spawn == Some(column) { + // TeleportTransition.missingRespawnBlock: PlayerSpawnFinder + // around the world spawn, not its exact column. + self.respawn_spawn(column) + } else { + // A spawnpoint: the stored column, lifted onto its current surface. + let y = self + .land_column(column[0], column[2]) + .map_or(s.y, f64::from); + Vec3::new(s.x, y.max(s.y), s.z) + } }; let mut player = PlayerMotion::new(self.motion, feet)?; player.yaw = self.yaw; diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index 32d5113b0..f11d4a61c 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -578,9 +578,13 @@ impl Game<'_> { let s = self.level.spawn.unwrap_or([0.0, 64.0, 0.0]); target = Vec3::new(s[0].floor() + 0.5, s[1], s[2].floor() + 0.5); } - let y = self - .land_column(target.x.floor() as i32, target.z.floor() as i32) - .map_or(target.y, f64::from); + let (x, z) = (target.x.floor() as i32, target.z.floor() as i32); + // TeleportTransition.missingRespawnBlock: PlayerSpawnFinder around + // the world spawn. + if let Some(world) = self.level.world_spawn.filter(|w| w[0] == x && w[2] == z) { + return Ok((self.respawn_spawn(world), None)); + } + let y = self.land_column(x, z).map_or(target.y, f64::from); Ok((Vec3::new(target.x, y, target.z), None)) } diff --git a/crates/horizon-client/src/game/initial_spawn.rs b/crates/horizon-client/src/game/initial_spawn.rs index 3f7a071bb..bcea90337 100644 --- a/crates/horizon-client/src/game/initial_spawn.rs +++ b/crates/horizon-client/src/game/initial_spawn.rs @@ -121,33 +121,58 @@ impl Game<'_> { } Ok(Some([ox * 16 + 8, height, oz * 16 + 8])) } + /// PlayerSpawnFinder.findSpawn: the finder for a suggestion, its radius + /// the respawn radius cut to the world border. + fn spawn_finder(&self, suggestion: [i32; 3]) -> PlayerSpawnFinder { + if self.level.game_mode == 2 { + // Adventure mode: the suggestion itself. + let mut finder = PlayerSpawnFinder::new(suggestion, 0, |_| 0); + finder.next_candidate(); + return finder; + } + let mut radius = self.ui.rules.int("respawn_radius").max(0); + let to_border = self + .border + .distance(f64::from(suggestion[0]), f64::from(suggestion[2])) + .floor() as i32; + if to_border < radius { + radius = to_border; + } + if to_border <= 1 { + radius = 1; + } + PlayerSpawnFinder::new(suggestion, radius, |n| { + entity_random().next_int_bound(n).unwrap_or(0) + }) + } + /// PlayerSpawnFinder.findSpawn around the world spawn for a player placed + /// at once (TeleportTransition.createDefault and missingRespawnBlock): the + /// first free column within the respawn radius, the suggestion's own + /// column when none is. A candidate whose chunk is not loaded counts as + /// not free; the suggestion's chunk must be. + pub(super) fn respawn_spawn(&self, suggestion: [i32; 3]) -> Vec3 { + let mut finder = self.spawn_finder(suggestion); + while let Some(candidate) = finder.next_candidate() { + let SpawnCandidate::Column(x, z) = candidate else { + break; + }; + if !self.streaming.is_lit(x >> 4, z >> 4) { + continue; + } + if let Some(pos) = level_respawn_pos(&self.spawn_columns(), x, z) + && self.player_fits(pos) + { + return bottom_center(pos); + } + } + self.fixup_spawn_height(suggestion) + } /// PlayerSpawnFinder.findSpawn around the world spawn: the feet of a /// player who has no position yet. None while a candidate's chunk loads. pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result> { let mut finder = match self.player_spawn { Some(finder) => finder, - None if self.level.game_mode == 2 => { - // Adventure mode: the suggestion itself. - let mut finder = PlayerSpawnFinder::new(suggestion, 0, |_| 0); - finder.next_candidate(); - finder - } - None => { - let mut radius = self.ui.rules.int("respawn_radius").max(0); - let to_border = self - .border - .distance(f64::from(suggestion[0]), f64::from(suggestion[2])) - .floor() as i32; - if to_border < radius { - radius = to_border; - } - if to_border <= 1 { - radius = 1; - } - PlayerSpawnFinder::new(suggestion, radius, |n| { - entity_random().next_int_bound(n).unwrap_or(0) - }) - } + None => self.spawn_finder(suggestion), }; let found = loop { let Some(candidate) = finder.next_candidate() else { diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 43bb573dc..dcb3c8919 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1853,6 +1853,10 @@ impl Game<'_> { } if let Some(config) = elsewhere { self.respawn_trip(conn, config); + } else if in_frame_bed.is_none() && host.hub.guests[i].spawn.is_none() { + // TeleportTransition.createDefault: no point of its own, so the + // world spawn's free column once its chunks have loaded. + self.world_spawn_trip(conn); } if let Some(c) = in_frame_bed && self.dim == super::Dim::Overworld @@ -1871,6 +1875,10 @@ impl Game<'_> { host.hub.guests[i].yaw = yaw; [at.x, at.y, at.z] }); + if found.is_none() { + // TeleportTransition.missingRespawnBlock. + self.world_spawn_trip(conn); + } host.hub.teleport(i, Some(at)); } if away && let Err(e) = self.enter_level(Some(host), back) { diff --git a/crates/horizon-client/src/game/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs index bcaf37a76..e22cd60e9 100644 --- a/crates/horizon-client/src/game/server_travel.rs +++ b/crates/horizon-client/src/game/server_travel.rs @@ -31,6 +31,9 @@ pub(super) struct Trip { /// A respawn at this point outside the Overworld, resolved through its /// block on arrival. respawn: Option, + /// A respawn at the world spawn, moved onto a free column within the + /// respawn radius once the chunks around it have loaded. + world_spawn: bool, /// Sent by a command: the player is already where it goes. placed: bool, } @@ -66,10 +69,11 @@ impl Game<'_> { /// in it (Nether portals count up their transition time, End portals /// take them at once). pub(super) fn tick_server_travel(&mut self, host: &mut LanHost) { + // Outside a server only the respawns at the world spawn wait for chunks. + self.arrive_server_trips(host); if self.options.dedicated.is_none() { return; } - self.arrive_server_trips(host); let conns: Vec = host .hub .guests @@ -253,6 +257,7 @@ impl Game<'_> { plan, gateway: None, respawn: None, + world_spawn: false, placed: false, }); if let Err(e) = self.enter_level(Some(host), source) { @@ -272,6 +277,7 @@ impl Game<'_> { plan: None, gateway: None, respawn: Some(config), + world_spawn: false, placed: false, }); } @@ -304,6 +310,27 @@ impl Game<'_> { } } + /// TeleportTransition.createDefault and missingRespawnBlock: the player + /// waits at the world spawn for its chunks, then PlayerSpawnFinder puts + /// it on a free column within the respawn radius. + pub(super) fn world_spawn_trip(&mut self, conn: u32) { + let Some([x, y, z]) = self.level.world_spawn else { + return; + }; + self.server_trips.retain(|t| !t.is(conn)); + self.server_trips.push(Trip { + conn, + dim: Dim::Overworld, + target: Vec3::new(f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5), + end: false, + plan: None, + gateway: None, + respawn: None, + world_spawn: true, + placed: false, + }); + } + /// TeleportTransition.missingRespawnBlock: the world spawn, in the /// Overworld. fn respawn_at_world_spawn(&mut self, host: &mut LanHost, conn: u32) { @@ -318,6 +345,7 @@ impl Game<'_> { rotation: None, }); self.run_level_teleports(host); + self.world_spawn_trip(conn); } /// `TheEndGatewayBlockEntity.getPortalPosition` and the teleport within @@ -343,6 +371,7 @@ impl Game<'_> { plan: None, gateway: Some(job), respawn: None, + world_spawn: false, placed: false, }); } @@ -383,6 +412,11 @@ impl Game<'_> { continue; } } + } else if trip.world_spawn { + // PlayerSpawnFinder.findSpawn around the world spawn. + let suggestion = + [trip.target.x, trip.target.y, trip.target.z].map(|v| v.floor() as i32); + (self.respawn_spawn(suggestion), yaw) } else if let Some(job) = trip.gateway { match self.resolve_gateway(job, trip.target) { Ok(at) => (at, yaw), @@ -458,6 +492,7 @@ impl Game<'_> { plan: None, gateway: None, respawn: None, + world_spawn: false, placed: true, }); if let Err(e) = self.enter_level(Some(host), source) { From 886a84dea086f4c67674a40a4b72e3b90dd904ac Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:14:04 +0100 Subject: [PATCH 20/84] Fly thrown tridents on by themselves between server updates --- crates/horizon-client/src/game/remote.rs | 13 +++ .../src/game/remote_projectiles.rs | 39 ++++++++- crates/horizon-client/src/game/trident.rs | 83 +++++++++++++++---- 3 files changed, 115 insertions(+), 20 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3cfbd15e3..6b0d2477d 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -1406,6 +1406,17 @@ impl Game<'_> { { return; } + // A thrown trident is an arrow: placed at once, flown on by its tick. + if let Some(t) = self.tridents.iter_mut().find(|t| t.id == id as u32) { + if path.is_some() { + t.position = Vec3::new(position[0], position[1], position[2]); + } + if let Some((yaw, pitch)) = rotation { + t.yaw = yaw; + t.pitch = pitch; + } + return; + } // A dragon fireball keeps Entity's NO_OP InterpolationHandler too: // the server's position replaces its own at once. if let Some(b) = self.dragon_fireballs.iter_mut().find(|b| b.id == id as u32) { @@ -3016,6 +3027,8 @@ impl Game<'_> { p.velocity = v; } else if let Some(b) = self.dragon_fireballs.iter_mut().find(|b| b.id == id as u32) { b.velocity = v; + } else if let Some(t) = self.tridents.iter_mut().find(|t| t.id == id as u32) { + t.velocity = v; } else if let Some(p) = self .remote .as_mut() diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 897999c6b..133c2b9fd 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -122,6 +122,8 @@ impl Game<'_> { "minecraft:trident" => { let mut t = super::trident::ThrownTrident::remote(id, at, yaw, pitch); t.velocity = velocity; + // Projectile.getAddEntityPacket: the owner's id is the data. + t.owner = data as u32; self.tridents.push(t); } "minecraft:firework_rocket" => { @@ -261,6 +263,15 @@ impl Game<'_> { (9, Value::Bool(show)) => c.show_bottom = *show, _ => {} } + } else if let Some(t) = self.tridents.iter_mut().find(|t| t.id == id) { + // AbstractArrow.ID_FLAGS (no physics) and IN_GROUND, and + // ThrownTrident.ID_LOYALTY. + match (index, value) { + (8, Value::Byte(flags)) => t.no_physics = flags & 2 != 0, + (10, Value::Bool(in_ground)) => t.in_ground = *in_ground, + (11, Value::Byte(loyalty)) => t.loyalty = u32::from(*loyalty as u8), + _ => {} + } } else if let Some(p) = self.creatures.projectiles.iter_mut().find(|p| p.id == id) { match (&mut p.kind, index, value) { // AbstractArrow.ID_FLAGS (critical) and IN_GROUND. @@ -294,6 +305,25 @@ impl Game<'_> { } } + /// `Entity.getEyePosition` of a projectile's owner: this game's player or + /// another player the server sent. + fn remote_eye(&self, id: u32) -> Option { + let me = self + .remote + .as_ref() + .and_then(|r| u32::try_from(r.entity_id).ok()); + if me == Some(id) { + let eye = self.eye_position()?; + return Some(Vec3::new(eye[0], eye[1], eye[2])); + } + let m = self.mobs.iter().find(|m| m.id == id)?; + Some(Vec3::new( + m.position.x, + m.position.y + m.eye_height(), + m.position.z, + )) + } + /// One tick of interpolation, as `tick_remote_objects`. pub(super) fn tick_remote_projectiles(&mut self, mut step: impl FnMut(u32, Vec3) -> Vec3) { // PrimedTnt.tick runs on a client too: it falls, bounces and burns its @@ -326,6 +356,7 @@ impl Game<'_> { // updates (10 to 20 ticks apart); a block stops them there, and only // the server decides what they hit. let mut projectiles = std::mem::take(&mut self.creatures.projectiles); + let mut tridents = std::mem::take(&mut self.tridents); { let w = self.mob_world_base(&[]); let world = super::creatures::ProjWorld { @@ -348,12 +379,12 @@ impl Game<'_> { } } } + for t in &mut tridents { + t.remote_tick(&world, self.remote_eye(t.owner)); + } } self.creatures.projectiles = projectiles; - for t in &mut self.tridents { - let id = t.id; - t.remote_step(|at| step(id, at)); - } + self.tridents = tridents; // FireworkRocketEntity.tick: a rocket attached to the gliding local // player boosts it client-side too (attachedToEntity.isFallFlying). let me = self diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs index c31094596..75b546804 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -8,6 +8,7 @@ use horizon_client::{ items::ItemStack, mesher::Vertex, mobs::{Damage, DamageKind, Who, anim::Poses}, + projectiles::ProjectileWorld, }; use horizon_core::{ geometry::{Aabb, Vec3}, @@ -30,6 +31,8 @@ pub(super) struct ThrownTrident { pub(super) no_physics: bool, returning: u32, creative_only: bool, + /// The entity id a server sent as its owner (the one Loyalty returns it to). + pub(super) owner: u32, } impl ThrownTrident { /// A trident a server sent (`handleAddEntity`): placed and moved by it. @@ -49,12 +52,71 @@ impl ThrownTrident { no_physics: false, returning: 0, creative_only: false, + owner: 0, } } - /// One tick of a server's client: the previous position, then `step`. - pub(super) fn remote_step(&mut self, step: impl FnOnce(Vec3) -> Vec3) { + /// `ThrownTrident.tick`'s Loyalty return: pulled up and towards the + /// owner's eye. + fn loyalty_pull(&mut self, owner_eye: Vec3) { + let v = Vec3::new( + owner_eye.x - self.position.x, + owner_eye.y - self.position.y, + owner_eye.z - self.position.z, + ); + self.position.y += v.y * 0.015 * f64::from(self.loyalty); + let len = (v.x * v.x + v.y * v.y + v.z * v.z).sqrt().max(1e-9); + let accel = 0.05 * f64::from(self.loyalty); + self.velocity = Vec3::new( + self.velocity.x * 0.95 + v.x / len * accel, + self.velocity.y * 0.95 + v.y / len * accel, + self.velocity.z * 0.95 + v.z / len * accel, + ); + } + /// `ThrownTrident.tick` on a server's client: it flies on by itself + /// between the server's updates (`AbstractArrow.tick`: gravity and drag, + /// a block holds it), and Loyalty pulls it back to its owner; only the + /// server decides what it hits. + pub(super) fn remote_tick(&mut self, w: &impl ProjectileWorld, owner_eye: Option) { self.previous = self.position; - self.position = step(self.position); + if self.in_ground_time > 4 { + self.dealt_damage = true; + } + if self.loyalty > 0 + && (self.dealt_damage || self.no_physics) + && let Some(eye) = owner_eye + { + self.no_physics = true; + self.in_ground = false; + self.loyalty_pull(eye); + } + if self.in_ground && !self.no_physics { + self.in_ground_time += 1; + return; + } + self.in_ground_time = 0; + let m = self.velocity; + let (x, z) = if self.no_physics { + (-m.x, -m.z) + } else { + (m.x, m.z) + }; + self.yaw = x.atan2(z).to_degrees() as f32; + self.pitch = m.y.atan2(m.x.hypot(m.z)).to_degrees() as f32; + let to = self.position.add_vector(m); + if !self.no_physics + && let Some((at, _, _)) = w.clip(self.position, to) + { + self.position = at; + self.velocity = Vec3::ZERO; + self.in_ground = true; + return; + } + self.position = to; + // A trident's water inertia (0.99) equals the air drag. + self.velocity = self.velocity.scale(0.99); + if !self.no_physics { + self.velocity.y -= 0.05; + } } } const HALF: f64 = 0.25; @@ -240,6 +302,7 @@ impl Game<'_> { no_physics: false, returning: 0, creative_only: self.creative, + owner: 0, }); self.player_projectile_shot(); self.audio @@ -261,19 +324,7 @@ impl Game<'_> { if t.loyalty > 0 && (t.dealt_damage || t.no_physics) { t.no_physics = true; t.in_ground = false; - let v = Vec3::new( - owner_eye.x - t.position.x, - owner_eye.y - t.position.y, - owner_eye.z - t.position.z, - ); - t.position.y += v.y * 0.015 * f64::from(t.loyalty); - let len = (v.x * v.x + v.y * v.y + v.z * v.z).sqrt().max(1e-9); - let accel = 0.05 * f64::from(t.loyalty); - t.velocity = Vec3::new( - t.velocity.x * 0.95 + v.x / len * accel, - t.velocity.y * 0.95 + v.y / len * accel, - t.velocity.z * 0.95 + v.z / len * accel, - ); + t.loyalty_pull(owner_eye); if t.returning == 0 { self.audio.play( "minecraft:item.trident.return", From a44581eaf39a1775b79e5ee450f7a0fab1dc9347 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:14:23 +0100 Subject: [PATCH 21/84] Let a shulker bullet's levitation run out on mobs --- crates/horizon-client/src/game/creatures.rs | 2 +- crates/horizon-client/src/mobs.rs | 1 - crates/horizon-client/src/mobs/living.rs | 10 ++++++++-- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2b65a3289..3d16faae9 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2385,7 +2385,7 @@ impl Game<'_> { if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) && m.damage(4.0, source) { - m.extra.levitation = 200; + m.add_effect("minecraft:levitation", 200, 0); } } }, diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 00c21633e..631ef40eb 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -677,7 +677,6 @@ pub struct Extra { pub anger: i32, pub carried: Option, pub charged: bool, - pub levitation: i32, /// Held item ids (main hand, off hand) and head item. pub main_hand: Option>, pub off_hand: Option>, diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs index 394821ace..ddb25d877 100644 --- a/crates/horizon-client/src/mobs/living.rs +++ b/crates/horizon-client/src/mobs/living.rs @@ -742,8 +742,14 @@ impl Mob { movement.y = 0.2; } let mut y = movement.y; - if self.extra.levitation > 0 { - y += (0.05 * 1.0 - movement.y) * 0.2; + // LivingEntity.travelInAir: levitation lifts by its amplifier. + if let Some(&(_, _, amp)) = self + .extra + .effects + .iter() + .find(|e| e.0 == "minecraft:levitation") + { + y += (0.05 * f64::from(amp + 1) - movement.y) * 0.2; } else { y -= self.gravity(); } From 034af457778bab980cc95ca1c76c8e50471d49fc Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:15:33 +0100 Subject: [PATCH 22/84] Make adult piglins hunt adult hoglins --- crates/horizon-client/src/game/creatures.rs | 8 ++ crates/horizon-client/src/mobs.rs | 10 ++ crates/horizon-client/src/mobs/piglin.rs | 103 ++++++++++++++++++-- 3 files changed, 111 insertions(+), 10 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2b65a3289..a9aa16a1b 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1009,6 +1009,14 @@ impl Game<'_> { m.ai.target = Some(target); } } + MobEvent::HuntHoglin { mob, target, ticks } => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { + m.extra.ints[0] = ticks; + if m.ai.target.is_none() { + m.ai.target = Some(Who::Mob(target)); + } + } + } MobEvent::Projectile(mut p) => { self.next_entity += 1; p.id = self.next_entity; diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 00c21633e..cd00a12c4 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -985,6 +985,13 @@ pub enum MobEvent { mob: u32, target: Who, }, + /// `StartHuntingHoglin` for a nearby adult piglin: it takes the hoglin as + /// its anger target (when it has none) and starts its `HUNTED_RECENTLY` wait. + HuntHoglin { + mob: u32, + target: u32, + ticks: i32, + }, Projectile(crate::projectiles::Projectile), /// Spawn a new mob (breeding, slime splitting, chicken eggs...). Spawn(Box), @@ -1251,6 +1258,8 @@ pub struct Seen { /// `MAX_HEALTH`, `JUMP_STRENGTH` and `MOVEMENT_SPEED` base values (a /// horse's breeding stock). pub stats: [f64; 3], + /// A piglin's `HUNTED_RECENTLY` memory. + pub hunted_recently: bool, } impl Mob { pub fn burning_time(&self) -> f64 { @@ -1323,6 +1332,7 @@ impl Mob { m.extra.vector[0], m.attrs.speed, ], + hunted_recently: m.species() == Species::Piglin && m.extra.ints[0] > 0, } } /// `EntityType.getCategory`'s name. diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs index fff536932..5b8c17fb3 100644 --- a/crates/horizon-client/src/mobs/piglin.rs +++ b/crates/horizon-client/src/mobs/piglin.rs @@ -6,7 +6,8 @@ use super::{ anim::{Poses, State}, goals::{ Avoid, AvoidEntity, Cx, Float, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, MeleeAttack, - NearestTarget, Prey, RandomLookAround, Stroll, goal_clone, + NearestTarget, Prey, RandomLookAround, Stroll, TARGET, TargetState, goal_clone, + target_continue, }, }; use horizon_core::geometry::{Vec3, trig::Mth}; @@ -54,15 +55,94 @@ pub fn register_piglin(m: &mut Mob) { m.ai.targets.add(1, hurt); m.ai.targets .add(2, NearestTarget::player(true).when(hostile_to_player)); - m.ai.targets.add( - 3, - NearestTarget::new( - Prey::Filter(|s| s.species == Species::Hoglin && s.baby), - true, - ) - .interval(10) - .when(|m, _| !m.is_baby()), - ); + m.ai.targets.add(3, HuntHoglin::default()); + // `PiglinAi.initMemories`: the first hunt waits too. + m.extra.ints[0] = time_between_hunts(m); +} +/// `PiglinAi.TIME_BETWEEN_HUNTS`: 30 to 120 seconds. +fn time_between_hunts(m: &mut Mob) -> i32 { + m.random + .next_int_between_inclusive(600, 2400) + .unwrap_or(600) +} +/// `StartHuntingHoglin`: an adult piglin that is not angry, has not hunted +/// recently and sees no adult piglin that has, goes for the nearest adult +/// hoglin it sees; then it and the adult piglins near it wait before the next +/// hunt, and the others join in (`broadcastAngerTarget`). +#[derive(Clone, Debug)] +struct HuntHoglin { + found: Option, + st: TargetState, +} +impl Default for HuntHoglin { + fn default() -> Self { + let mut st = TargetState::default(); + st.unseen_memory = 60; + Self { found: None, st } + } +} +impl Goal for HuntHoglin { + goal_clone!(); + fn flags(&self) -> u8 { + TARGET + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if m.is_baby() || m.extra.ints[0] > 0 || m.extra.anger > 0 || m.ai.target.is_some() { + return false; + } + let range = m.attrs.follow_range; + let pos = Vec3::new(m.position.x, m.eye_y(), m.position.z); + let id = m.id; + if cx + .w + .nearby(pos, range, |s| { + s.id != id && s.species == Species::Piglin && !s.baby && s.hunted_recently + }) + .next() + .is_some() + { + return false; + } + let hoglins: Vec<(u32, Vec3)> = + cx.w.nearby(pos, range, |s| s.species == Species::Hoglin && !s.baby) + .map(|s| (s.id, s.position)) + .collect(); + self.found = hoglins + .into_iter() + .find(|&(hoglin, at)| { + m.distance_sqr(at) <= range * range && m.sees(cx.w, Who::Mob(hoglin)) + }) + .map(|(hoglin, _)| hoglin); + self.found.is_some() + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + target_continue(&mut self.st, true, m, cx) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(hoglin) = self.found else { return }; + m.ai.target = Some(Who::Mob(hoglin)); + m.extra.ints[0] = time_between_hunts(m); + let range = m.attrs.follow_range; + let pos = Vec3::new(m.position.x, m.eye_y(), m.position.z); + let id = m.id; + let others: Vec = + cx.w.nearby(pos, range, |s| { + s.id != id && s.species == Species::Piglin && !s.baby + }) + .map(|s| s.id) + .collect(); + for mob in others { + let ticks = time_between_hunts(m); + cx.events.push(MobEvent::HuntHoglin { + mob, + target: hoglin, + ticks, + }); + } + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + m.ai.target = None; + } } pub fn register_brute(m: &mut Mob) { let g = &mut m.ai.goals; @@ -251,6 +331,9 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { if m.species() == Species::Hoglin && m.alive() { hoglin_repellent(m, w); } + if m.species() == Species::Piglin && m.extra.ints[0] > 0 { + m.extra.ints[0] -= 1; + } if m.extra.anger > 0 { m.extra.anger -= 1; if m.extra.anger == 0 && m.ai.target == Some(Who::Player) && !hostile_to_player(m, w) { From 9aabeb39eee0dfe14a733f150d94703256576a43 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:18:50 +0100 Subject: [PATCH 23/84] Make /tp facing look from the feet, or the eyes under anchored eyes --- crates/horizon-client/src/game/commands.rs | 25 ++++++++++++++++------ 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 8f934ad8a..d760397f4 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1312,7 +1312,7 @@ impl Game<'_> { { return Err(err("commands.teleport.invalidPosition", &[])); } - let mut rotation = match ctx.get("rotation") { + let rotation = match ctx.get("rotation") { Some(Arg::Coords(c)) => Some(c.rotation(self.source_rotation())), _ => None, }; @@ -1327,21 +1327,31 @@ impl Game<'_> { (Some(f), _) => Some(f), (None, Some(_)) => { let e = self.entities(ctx, "facingEntity", false)?[0]; + // EntityAnchorArgument.Anchor.apply: the feet, or the eyes. let eyes = matches!(ctx.get("facingAnchor"), Some(Arg::Anchor(true))); + let eye_height = if eyes { self.target_eye_height(e) } else { 0.0 }; self.target_position(e) - .map(|p| [p[0], p[1] + if eyes { 1.62 } else { 0.0 }, p[2]]) + .map(|p| [p[0], p[1] + eye_height, p[2]]) } _ => None, }; - if let Some(f) = facing { - let eye = pos[1] + 1.62; + // Entity.lookAt: from the source's anchor (the feet, unless `anchored + // eyes`) on the teleported entity, so the eyes depend on the target. + let anchored_eyes = self.command_source.is_some_and(|s| s.eyes); + let look_at = |this: &Self, t: Target| { + let f = facing?; + let eye = if anchored_eyes { + pos[1] + this.target_eye_height(t) + } else { + pos[1] + }; let (dx, dy, dz) = (f[0] - pos[0], f[1] - eye, f[2] - pos[2]); let horizontal = (dx * dx + dz * dz).sqrt(); - rotation = Some([ + Some([ ((dz.atan2(dx).to_degrees()) - 90.0) as f32, (-(dy.atan2(horizontal).to_degrees())) as f32, - ]); - } + ]) + }; // A server's player in another level than the source's (`execute // in`, the console's Overworld) moves there (ServerPlayer.teleport // into another level), after the command. @@ -1351,6 +1361,7 @@ impl Game<'_> { None => self.dim, }; for &t in &targets { + let rotation = look_at(self, t).or(rotation); if self.teleport_across(t, source_level, pos, rotation) { continue; } From a4ccf205f7872362bb53b9ffd40f038ca8ce5793 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:21:09 +0100 Subject: [PATCH 24/84] Throw what /give cannot fit from the player's eyes, for that player only --- crates/horizon-client/src/entities.rs | 9 ++++++- crates/horizon-client/src/entities/fluids.rs | 1 + crates/horizon-client/src/entity_nbt.rs | 7 +++++ crates/horizon-client/src/game.rs | 5 +++- crates/horizon-client/src/game/commands.rs | 26 +++++++++++++++++-- crates/horizon-client/src/game/lan_actions.rs | 11 ++++++-- crates/horizon-client/src/game/machines.rs | 1 + crates/horizon-client/src/game/remote.rs | 1 + 8 files changed, 55 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs index 69e053411..ce12558c0 100644 --- a/crates/horizon-client/src/entities.rs +++ b/crates/horizon-client/src/entities.rs @@ -19,6 +19,8 @@ pub struct ItemEntity { pub id: u32, pub stack: ItemStack, pub thrower: Option<[i32; 4]>, + /// `ItemEntity.target`: the only player who may pick the item up. + pub target: Option<[i32; 4]>, pub position: Vec3, pub previous: Vec3, pub velocity: Vec3, @@ -346,7 +348,10 @@ pub fn merge_with_neighbours( } // ItemEntity.areMergable: both fit one stack of the same item and components. let (this, other) = (&items[i].stack, &items[j].stack); - if this.count + other.count > max_stack(other) || !this.same_item_same_components(other) { + if items[i].target != items[j].target + || this.count + other.count > max_stack(other) + || !this.same_item_same_components(other) + { continue; } let (to, from) = if other.count < this.count { @@ -874,6 +879,7 @@ mod fire_environment_tests { let make = |id: &str| ItemEntity { id: 1, thrower: None, + target: None, stack: ItemStack { item: std::sync::Arc::from(id), count: 1, @@ -970,6 +976,7 @@ mod merge_tests { ItemEntity { id: 0, thrower: None, + target: None, stack: ItemStack { item: std::sync::Arc::from(id), count, diff --git a/crates/horizon-client/src/entities/fluids.rs b/crates/horizon-client/src/entities/fluids.rs index fffa0ae2b..3b3dffa99 100644 --- a/crates/horizon-client/src/entities/fluids.rs +++ b/crates/horizon-client/src/entities/fluids.rs @@ -189,6 +189,7 @@ mod tests { extra: None, }, thrower: None, + target: None, position: at, previous: at, velocity: Vec3::ZERO, diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 7f3565067..c5115baac 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -967,6 +967,11 @@ pub fn item_entity_to_nbt(e: &ItemEntity, uuid: [i32; 4], raw: Option<&Tag>) -> } else if let Tag::Compound(map) = &mut tag { map.remove(&"Thrower".into()); } + if let Some(target) = e.target { + put(&mut tag, "Owner", Tag::IntArray(target.to_vec())); + } else if let Tag::Compound(map) = &mut tag { + map.remove(&"Owner".into()); + } tag } pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> Option { @@ -978,6 +983,7 @@ pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> Option { health: 5, fire_ticks: 0, thrower: None, + target: None, id: self.next_entity, stack, position: p, @@ -2417,6 +2418,7 @@ impl Game<'_> { ], ); let feet = [p.position.x, p.position.y, p.position.z]; + let own = self.level.ensure_player_uuid(); let mut kept = Vec::with_capacity(items.len()); for mut item in items { let b = item.bounds(); @@ -2426,7 +2428,8 @@ impl Game<'_> { && b.max_position().y > min[1] && b.min_position().z < max[2] && b.max_position().z > min[2]; - if touching && item.pickup_delay == 0 { + // ItemEntity.playerTouch: no pickup delay, and the target (if any) is this player. + if touching && item.pickup_delay == 0 && item.target.is_none_or(|t| t == own) { let before = item.stack.count; let kind = item.stack.item.clone(); match self.give(item.stack.clone()) { diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 8f934ad8a..2988996d1 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1042,6 +1042,17 @@ impl Game<'_> { // An air stack is empty: nothing is given (but the message still is). let empty = id == "minecraft:air"; for &t in targets.iter().filter(|_| !empty) { + // The player's UUID, which an item they could not hold is set to. + let conn = match t { + Target::Guest(conn) => Some(conn), + _ => self.lan_acting, + }; + let uuid = match conn { + Some(conn) => self + .command_guest(conn) + .map(|g| horizon_client::lan::playerdata::uuid_ints(g.uuid)), + None => Some(self.level.ensure_player_uuid()), + }; self.for_player(t, |g| { let mut remaining = count; while remaining > 0 { @@ -1058,8 +1069,19 @@ impl Game<'_> { .target_position(Target::Player) .unwrap_or(g.source_position()); if let Some(rest) = left { - // Inventory full: drop the rest at the player's feet without pickup delay. - g.spawn_item(rest, [p[0], p[1] + 1.32, p[2]], [0.0, 0.0, 0.0], 0); + // Inventory full: Player.createItemStackToDrop (thrown from + // the eyes), then setNoPickUpDelay and setTarget(player). + let eye = g.eye_position().unwrap_or([ + p[0], + p[1] + g.target_eye_height(Target::Player), + p[2], + ]); + g.throw_from_eyes(rest, eye); + if let Some(item) = g.dropped.last_mut() { + item.thrower = None; + item.pickup_delay = 0; + item.target = uuid; + } } else { let r = &mut g.world.random; let pitch = ((r.next_float() - r.next_float()) * 0.7 + 1.0) * 2.0; diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 43bb573dc..d0bd8e670 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -2569,9 +2569,15 @@ impl Game<'_> { /// Dropped items touching a guest go into their inventory. fn guest_pickups(&mut self, host: &mut LanHost, gi: usize) { - let (conn, mode, position, id) = { + let (conn, mode, position, id, uuid) = { let g = &host.hub.guests[gi]; - (g.conn, g.game_mode, g.position, g.entity_id) + ( + g.conn, + g.game_mode, + g.position, + g.entity_id, + horizon_client::lan::playerdata::uuid_ints(g.uuid), + ) }; if mode == SPECTATOR || self.dropped.is_empty() { return; @@ -2582,6 +2588,7 @@ impl Game<'_> { .enumerate() .filter(|(_, d)| { d.pickup_delay == 0 + && d.target.is_none_or(|t| t == uuid) && (d.position.x - position[0]).abs() < 1.5 && (d.position.z - position[2]).abs() < 1.5 && d.position.y > position[1] - 0.6 diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index bb936744b..94d9790d4 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -955,6 +955,7 @@ mod item_column_tests { id, stack: ItemStack::new("minecraft:stone", 1), thrower: None, + target: None, position: at, previous: at, velocity: Vec3::ZERO, diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3cfbd15e3..5b9bc7ff7 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2980,6 +2980,7 @@ impl Game<'_> { health: 5, fire_ticks: 0, thrower: None, + target: None, id: id as u32, stack, position: at, From 10872bdd64bcb3c96cf02a8d544d0645020111c6 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:22:53 +0100 Subject: [PATCH 25/84] Add the tridents field to the remote motion test fixture --- tests/test_remote_motion.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_remote_motion.py b/tests/test_remote_motion.py index b00e5f0a9..3a6e28de5 100644 --- a/tests/test_remote_motion.py +++ b/tests/test_remote_motion.py @@ -35,7 +35,7 @@ impl End { fn remote_eye_motion(&mut self, _id: u32, _v: [f64; 3]) {} } #[derive(Default)] struct Game { mobs: Vec, dropped: Vec, falling: Vec, tnts: Vec, - creatures: Creatures, dragon_fireballs: Vec, remote: Option, + creatures: Creatures, dragon_fireballs: Vec, tridents: Vec, remote: Option, potions: Potions, end: End, } impl Game { From 0cc3f567fc6acdffbfa80c7de1a535f3c75c2564 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:30:29 +0100 Subject: [PATCH 26/84] Play the bubble pop sound when an air bubble bursts --- .../horizon-client/examples/probe/hud_fixture.rs | 1 + crates/horizon-client/src/game.rs | 13 +++++++++++++ crates/horizon-client/src/hud_layout.rs | 15 +++++++++++++++ 3 files changed, 29 insertions(+) diff --git a/crates/horizon-client/examples/probe/hud_fixture.rs b/crates/horizon-client/examples/probe/hud_fixture.rs index a6f27fcda..5fc77309b 100644 --- a/crates/horizon-client/examples/probe/hud_fixture.rs +++ b/crates/horizon-client/examples/probe/hud_fixture.rs @@ -223,6 +223,7 @@ fn decorations(c: &Value, atlas: &HudAtlas) -> Vec { display_health: int("displayHealth", 0), last_health_time: millis - i64::from(int("lastHealthAgo", 0)), health_blink_time: i64::from(int("healthBlinkTime", 0)), + ..HealthHud::default() }; let kind = if has("minecraft:poison") { HeartKind::Poisoned diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 58b89a140..834befa5e 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -5275,6 +5275,19 @@ impl Game<'_> { }; let draws = self.health_hud.layout(&inputs, wi, hi); hud_layout::paint(&mut batch, atlas, &draws); + // Hud.playAirBubblePoppedSound: Player.playSound (PLAYERS), heard + // by this client only. + if let Some((volume, pitch)) = self.health_hud.bubble_pop_sound.take() { + let at = [p.position.x, p.position.y, p.position.z]; + let players = horizon_client::settings::SOUND_SOURCES + .iter() + .position(|s| *s == "player") + .unwrap_or(0); + let capture = self.audio.capture.take(); + self.audio + .play_on(players, "ui.hud.bubble_pop", Some(at), volume, pitch); + self.audio.capture = capture; + } } if contextual == ContextualBar::Locator { let draws = self.locator_bar_draws(wi, hi); diff --git a/crates/horizon-client/src/hud_layout.rs b/crates/horizon-client/src/hud_layout.rs index 4b0f2fa82..ac8cd514e 100644 --- a/crates/horizon-client/src/hud_layout.rs +++ b/crates/horizon-client/src/hud_layout.rs @@ -485,6 +485,11 @@ pub struct HealthHud { /// `Util.getMillis()` of the last health change. pub last_health_time: i64, pub health_blink_time: i64, + /// `Hud.lastBubblePopSoundPlayed`. + pub last_bubble_pop_sound: i32, + /// The `ui.hud.bubble_pop` volume and pitch `playAirBubblePoppedSound` + /// asked for this frame; the caller plays it and clears it. + pub bubble_pop_sound: Option<(f32, f32)>, } pub struct HealthInputs { @@ -751,12 +756,22 @@ impl HealthHud { let popping = bubble(0); let delay = i32::from(air != 0 && i.under_water); let empty = 10 - bubble(delay); + if !i.under_water { + self.last_bubble_pop_sound = 0; + } for b in 1..=10 { let x = x_right - (b - 1) * 8 - 9; if b <= full { out.push(sprite("hud/air", x, y, 9, 9)); } else if full != popping && b == popping && i.under_water { out.push(sprite("hud/air_bursting", x, y, 9, 9)); + // Hud.playAirBubblePoppedSound. + if self.last_bubble_pop_sound != b { + let volume = 0.5 + 0.1 * (empty - 3 + 1).max(0) as f32; + let pitch = 1.0 + 0.1 * (empty - 5 + 1).max(0) as f32; + self.bubble_pop_sound = Some((volume, pitch)); + self.last_bubble_pop_sound = b; + } } else if b > 10 - empty { let wobble = if empty == 10 && i.tick % 2 == 0 { next(2) From 7d7a85d1845d0ef2f7ff8a2866f92054f68a732e Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:31:28 +0100 Subject: [PATCH 27/84] Recruit nearby raiders only while the raid pathfinding goal runs Raiders recruited other raiders every 20 ticks whether or not they were heading for the raid. In vanilla the recruiting is part of PathfindToRaidGoal.tick, so a raider that has a target or carries a rider does not recruit. Do the recruiting from the goal's tick. --- crates/horizon-client/src/game/raids.rs | 10 ++++------ crates/horizon-client/src/mobs/raider.rs | 19 +++++++++++++++---- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs index bedca5708..4c5eff980 100644 --- a/crates/horizon-client/src/game/raids.rs +++ b/crates/horizon-client/src/game/raids.rs @@ -791,7 +791,7 @@ impl Game<'_> { let has_rider = ridden.contains(&m.id); let target_golem = matches!(m.ai.target, Some(horizon_client::mobs::Who::Mob(t)) if golems.contains(&t)); let target_player = m.ai.target == Some(horizon_client::mobs::Who::Player); - let (health, age, range) = (m.health, m.age, m.attrs.follow_range); + let (health, range) = (m.health, m.attrs.follow_range); let raids = &mut self.raiding.raids; let s = m.extra.raider.get_or_insert_with(Box::default); s.rider = has_rider; @@ -837,11 +837,9 @@ impl Game<'_> { { joins.push((m.id, id, health)); } - // PathfindToRaidGoal.recruitNearby. - if s.active_raid - && !s.raid_over - && !s.in_village - && age % 20 == 0 + // PathfindToRaidGoal.tick: recruitNearby, only while the goal runs. + if std::mem::take(&mut s.recruit_due) + && s.active_raid && let Some(id) = s.raid_id { recruit.push((id, position)); diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs index 6c3ab9b64..6096d04ad 100644 --- a/crates/horizon-client/src/mobs/raider.rs +++ b/crates/horizon-client/src/mobs/raider.rs @@ -38,6 +38,9 @@ pub struct State { pub in_village: bool, /// A dropped ominous banner this raider may fetch. pub banner_at: Option<[f64; 3]>, + /// `PathfindToRaidGoal.tick` ran its 20 tick recruitment: the game + /// recruits the raiders around this one. + pub recruit_due: bool, /// Beds around the raid's centre. pub homes: Option>>, /// A ravager carrying a raider, set every tick from `Extra::rider`. @@ -114,7 +117,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(3, PathfindToRaid); + m.ai.goals.add(3, PathfindToRaid::default()); m.ai.goals.add(4, MoveThroughVillage::new(1.05, 1.0)); m.ai.goals.add(5, Celebration); } @@ -357,9 +360,11 @@ impl Goal for ObtainBanner { } /// `PathfindToRaidGoal`: outside the village, head for the raid's centre in -/// hops of up to 15 blocks. -#[derive(Clone, Debug)] -pub struct PathfindToRaid; +/// hops of up to 15 blocks, recruiting nearby raiders every 20 ticks. +#[derive(Clone, Debug, Default)] +pub struct PathfindToRaid { + recruitment_tick: i32, +} impl PathfindToRaid { fn valid(s: &State) -> bool { s.active_raid && !s.raid_over && !s.in_village @@ -380,6 +385,12 @@ impl Goal for PathfindToRaid { let Some(c) = state(m).map(|s| s.raid_center) else { return; }; + if m.age as i32 > self.recruitment_tick { + self.recruitment_tick = m.age as i32 + 20; + if let Some(s) = m.extra.raider.as_deref_mut() { + s.recruit_due = true; + } + } if m.ai.nav.is_done() { let to = [ f64::from(c[0]) + 0.5, From c5a37c02de3101da524236010243244d278c5bd4 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:32:01 +0100 Subject: [PATCH 28/84] Push sonic boom targets only when hit, by their knockback resistance --- .../examples/probe/mob_ai_probe.rs | 8 ++ crates/horizon-client/src/game/creatures.rs | 115 ++++++++++++------ crates/horizon-client/src/game/lan_mobs.rs | 4 + crates/horizon-client/src/mobs.rs | 9 ++ crates/horizon-client/src/mobs/warden.rs | 31 +---- 5 files changed, 104 insertions(+), 63 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..290d45371 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -568,6 +568,10 @@ fn print_heart( fn player_damage(e: &MobEvent) -> f32 { match e { MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount, + MobEvent::SonicBoom { + target: Who::Player, + .. + } => 10.0, _ => 0.0, } } @@ -579,6 +583,10 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool { }; match e { MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0, + MobEvent::SonicBoom { + target: Who::Player, + .. + } => true, // ServerExplosion.hurtEntities: within twice the radius every hit does damage. MobEvent::Explode(at, radius) => { let d = Vec3::new(at[0], at[1], at[2]) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 1f560af0d..c7b033c03 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -838,6 +838,44 @@ impl Game<'_> { } } } + /// Melee or ranged damage to another mob; whether the hit landed. + fn mob_hits_mob(&mut self, target: u32, amount: f32, source: Damage) -> bool { + let mut killed = false; + let mut hurt = false; + if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) { + let hit = t.damage(amount, source); + hurt = hit; + if hit { + killed = !t.alive(); + // The hurt or death sound the mob raised. + let center = t.center(); + for event in std::mem::take(&mut t.outbox) { + if let MobEvent::Sound(s, _, volume, pitch) = event { + self.audio + .play(&format!("minecraft:{s}"), Some(center), volume, pitch); + } + } + } + } + if hurt + && let Some(Who::Mob(attacker)) = source.attacker + && let Some(m) = self + .mobs + .iter() + .find(|m| m.id == attacker && m.species() == Species::Axolotl) + { + self.audio.play( + "minecraft:entity.axolotl.attack", + Some([m.position.x, m.position.y, m.position.z]), + 1.0, + 1.0, + ); + } + if killed && let Some(Who::Mob(killer)) = source.attacker { + self.zombie_killed(killer, target); + } + hurt + } pub(super) fn handle_mob_events(&mut self, events: Vec) -> Result<()> { for e in events { match e { @@ -926,43 +964,48 @@ impl Game<'_> { amount, source, } => { - let mut killed = false; - let mut hurt = false; - if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) { - let hit = t.damage(amount, source); - hurt = hit; - if hit { - killed = !t.alive(); - // The hurt or death sound the mob raised. - let center = t.center(); - for event in std::mem::take(&mut t.outbox) { - if let MobEvent::Sound(s, _, volume, pitch) = event { - self.audio.play( - &format!("minecraft:{s}"), - Some(center), - volume, - pitch, - ); - } - } + self.mob_hits_mob(target, amount, source); + } + MobEvent::SonicBoom { + target, + attacker, + from, + direction, + } => { + // SonicBoom: the push only follows a hit that landed, scaled + // by the target's KNOCKBACK_RESISTANCE. + let (hurt, resistance) = match target { + Who::Player => { + let hurt = self.mob_hits_player(10.0, from, "minecraft:sonic_boom"); + let resistance = self.player.as_mut().map_or(0.0, |p| { + p.attribute("minecraft:knockback_resistance").unwrap_or(0.0) + }); + (hurt, resistance) } - } - if hurt - && let Some(Who::Mob(attacker)) = source.attacker - && let Some(m) = self - .mobs - .iter() - .find(|m| m.id == attacker && m.species() == Species::Axolotl) - { - self.audio.play( - "minecraft:entity.axolotl.attack", - Some([m.position.x, m.position.y, m.position.z]), - 1.0, - 1.0, - ); - } - if killed && let Some(Who::Mob(killer)) = source.attacker { - self.zombie_killed(killer, target); + Who::Mob(id) => { + let source = Damage { + kind: DamageKind::SonicBoom, + attacker: Some(Who::Mob(attacker)), + from: Some(from), + }; + let hurt = self.mob_hits_mob(id, 10.0, source); + let resistance = self + .mobs + .iter() + .find(|m| m.id == id) + .map_or(0.0, |m| m.attrs.knockback_resistance); + (hurt, resistance) + } + }; + if hurt { + let horizontal = 2.5 * (1.0 - resistance); + let vertical = 0.5 * (1.0 - resistance); + let velocity = [ + direction[0] * horizontal, + direction[1] * vertical, + direction[2] * horizontal, + ]; + self.handle_mob_events(vec![MobEvent::Push { target, velocity }])?; } } MobEvent::FinishAdmiring { mob } => self.finish_admiring(mob), diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index 4f53cec60..88f98e3f6 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -66,6 +66,10 @@ pub(super) fn acts_on_player(e: &MobEvent) -> bool { e, MobEvent::AttackPlayer(..) | MobEvent::DamagePlayer { .. } + | MobEvent::SonicBoom { + target: Who::Player, + .. + } | MobEvent::Push { target: Who::Player, .. diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 4b67f738f..49a11e75a 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -961,6 +961,15 @@ pub enum MobEvent { target: Who, velocity: [f64; 3], }, + /// `SonicBoom`: 10 damage to the target, then a push along `direction` + /// (the unit vector from the warden's chest to the target's eyes) only + /// if the hit landed, less the target's knockback resistance. + SonicBoom { + target: Who, + attacker: u32, + from: [f64; 3], + direction: [f64; 3], + }, /// `EvokerWololoSpellGoal`: a blue sheep turns red. Wololo { mob: u32, diff --git a/crates/horizon-client/src/mobs/warden.rs b/crates/horizon-client/src/mobs/warden.rs index 11161ef7c..f6acb3d50 100644 --- a/crates/horizon-client/src/mobs/warden.rs +++ b/crates/horizon-client/src/mobs/warden.rs @@ -697,34 +697,11 @@ pub(super) fn tick_sonic_boom(m: &mut Mob, w: &MobWorld, events: &mut Vec events.push(MobEvent::DamagePlayer { - amount: 10.0, - from, - kind: "minecraft:sonic_boom", - }), - Who::Mob(id) => events.push(MobEvent::AttackMob { - target: id, - amount: 10.0, - source: Damage { - kind: DamageKind::SonicBoom, - attacker: Some(Who::Mob(m.id)), - from: Some(from), - }, - }), - } - let horizontal = 2.5 * (1.0 - resistance); - let vertical = 0.5 * (1.0 - resistance); - events.push(MobEvent::Push { + events.push(MobEvent::SonicBoom { target, - velocity: [ - normal[0] * horizontal, - normal[1] * vertical, - normal[2] * horizontal, - ], + attacker: m.id, + from: at(m), + direction: normal, }); } /// `Warden.tick` on the client: the heartbeat (pitched by the client's copy From f1181d4a250b8d1a76dadfbadbbf714642492e17 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:32:16 +0100 Subject: [PATCH 29/84] Trial chamber mobs spawn with the gear their spawner's equipment table gives --- crates/horizon-client/src/game/mob_gear.rs | 56 +++++++++++++++++++ crates/horizon-client/src/game/spawner.rs | 27 +++++---- .../horizon-client/src/game/trial_spawner.rs | 2 +- crates/horizon-client/src/mobs/finalize.rs | 22 ++++++++ crates/horizon-client/src/mobs/spawner.rs | 28 ++++++++++ 5 files changed, 124 insertions(+), 11 deletions(-) diff --git a/crates/horizon-client/src/game/mob_gear.rs b/crates/horizon-client/src/game/mob_gear.rs index 809b250dc..7dc529f17 100644 --- a/crates/horizon-client/src/game/mob_gear.rs +++ b/crates/horizon-client/src/game/mob_gear.rs @@ -5,11 +5,15 @@ use super::Game; use horizon_client::{ mobs::{ Species, + drops::{self, SLOTS}, + finalize::equip_stack, gear::{self, ARMOR, MAIN}, + spawner::equipment_table, }, raid::{self, RaiderType}, }; use horizon_core::random::RandomSource; +use horizon_world::{loot::EntityLootParams, nbt::Tag}; /// `EnchantmentsByCostWithDifficulty` of `mob_spawn_equipment`. const MIN_COST: i32 = 5; @@ -47,6 +51,58 @@ fn slot_item(m: &horizon_client::mobs::Mob, slot: usize) -> Option { + /// `Mob.equip(EquipmentTable)` for a spawner's `equipment`: the loot table + /// (the mob as `this`, its random sequence) is rolled and each stack goes + /// in the slot `EquipmentUser.resolveSlot` picks, with the table's drop + /// chance for that slot. + pub(super) fn equip_from_table(&mut self, id: u32, table: &Tag) { + let Some((name, chances)) = equipment_table(table) else { + return; + }; + let Some(loot) = horizon_client::structure_blocks::loot_data(&self.options.resources) + else { + return; + }; + let Some(m) = self.mobs.iter().find(|m| m.id == id) else { + return; + }; + if !loot.has_table(&name) { + return; + } + let params = EntityLootParams { + this: drops::loot_entity(m, None), + ..EntityLootParams::default() + }; + let seed = self.level.seed; + let stacks = match loot.random_sequence(&name) { + Some(sequence) => { + let random = self.rand_sequences.get(sequence, seed); + loot.roll_entity(&name, random, ¶ms) + } + None => loot.roll_entity(&name, &mut self.world.random, ¶ms), + }; + let mut inserted: Vec = Vec::new(); + for stack in stacks.iter().filter(|s| !s.is_empty()) { + // `resolveSlot`: an `equippable` item goes in its own slot, any + // other in the main hand, each slot once. + let slot = match self + .res + .items() + .get(&stack.item) + .and_then(|i| i.equip_slot.as_deref()) + { + Some(name) => SLOTS.iter().position(|s| *s == name), + None => Some(0), + }; + let Some(slot) = slot.filter(|s| !inserted.contains(s)) else { + continue; + }; + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + equip_stack(m, slot, stack, chances[slot]); + } + inserted.push(slot); + } + } /// `Mob.populateDefaultEquipmentEnchantments`: the weapon one time in /// four and each piece of armour one time in two, scaled by the local /// difficulty, enchanted as if at an enchanting table of cost 5 to 22. diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs index 538cb39e7..de367a37c 100644 --- a/crates/horizon-client/src/game/spawner.rs +++ b/crates/horizon-client/src/game/spawner.rs @@ -21,10 +21,11 @@ type Pos = (i32, i32, i32); /// What a spawner tick decided to add, created once the level is free. pub(super) enum Planned { - /// `finalizeSpawn` ran on a fresh mob. - Finalized(Mob), - /// A mob loaded from the spawn data (with its passengers). - Loaded(Tag), + /// `finalizeSpawn` ran on a fresh mob; the spawn data's `equipment`. + Finalized(Mob, Option), + /// A mob loaded from the spawn data (with its passengers) and its + /// `equipment`. + Loaded(Tag, Option), } /// What the spawner code keeps between ticks. @@ -120,18 +121,24 @@ impl Game<'_> { for (i, plan) in planned.into_iter().enumerate() { let provisional = u32::MAX - i as u32; let id = match plan { - Planned::Finalized(mut mob) => { + Planned::Finalized(mut mob, equipment) => { self.next_entity += 1; mob.id = self.next_entity; let id = mob.id; self.mobs.push(mob); self.enchant_spawn_equipment(id); self.spawn_jockeys(id, true); - Some(id) + Some((id, equipment)) + } + Planned::Loaded(tag, equipment) => { + self.load_mob(tag, None).map(|id| (id, equipment)) } - Planned::Loaded(tag) => self.load_mob(tag, None), }; - if let Some(id) = id { + if let Some((id, equipment)) = id { + // `nextSpawnData.getEquipment().ifPresent(mob::equip)`. + if let Some(table) = equipment { + self.equip_from_table(id, &table); + } ids.insert(provisional, id); } } @@ -169,7 +176,7 @@ impl Game<'_> { mob.previous_head_yaw = 0.0; } let bounds = mob.bounds(); - planned.push(Planned::Finalized(mob)); + planned.push(Planned::Finalized(mob, r.equipment.cloned())); bounds } else { // A UUID already in the level is refused. @@ -197,7 +204,7 @@ impl Game<'_> { let tag = Tag::Compound(tag); let mob = horizon_client::entity_nbt::mob_from_nbt(&tag, self.res.mob_types(), 0)?; let bounds = mob.bounds(); - planned.push(Planned::Loaded(tag)); + planned.push(Planned::Loaded(tag, r.equipment.cloned())); bounds }; l.pending.borrow_mut().push(bounds); diff --git a/crates/horizon-client/src/game/trial_spawner.rs b/crates/horizon-client/src/game/trial_spawner.rs index 42a26c6e4..d076671ea 100644 --- a/crates/horizon-client/src/game/trial_spawner.rs +++ b/crates/horizon-client/src/game/trial_spawner.rs @@ -163,7 +163,7 @@ impl Game<'_> { let mut spawn = |l: &GameLevel, r: &SpawnerSpawn| { let added = l.game.plan_spawner_mob(l, r, &mut planned)?; let uuid = match planned.last_mut() { - Some(Planned::Loaded(Tag::Compound(tag))) => { + Some(Planned::Loaded(Tag::Compound(tag), _)) => { let tag_uuid = horizon_client::entity_nbt::uuid(&Tag::Compound(tag.clone())); tag_uuid.unwrap_or_else(|| { diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs index 4eeed885b..7cd8926c0 100644 --- a/crates/horizon-client/src/mobs/finalize.rs +++ b/crates/horizon-client/src/mobs/finalize.rs @@ -829,6 +829,28 @@ pub fn set_item(m: &mut Mob, slot: usize, id: &str) { } gear::set(m, gear_slot(slot), Vec::new()); } +/// `EquipmentUser.equip` for one rolled stack: `setItemSlot` puts the item in +/// `slot` with its own enchantments, then the slot's drop chance is stored +/// when the table names one. +pub fn equip_stack( + m: &mut Mob, + slot: usize, + stack: &horizon_world::loot::LootStack, + drop_chance: Option, +) { + set_item(m, slot, &stack.item); + if slot <= HEAD { + let levels = stack + .enchantments + .iter() + .map(|(id, level)| (Arc::from(id.as_str()), (*level).max(0) as u32)) + .collect(); + gear::set(m, gear_slot(slot), levels); + } + if let Some(chance) = drop_chance { + set_drop_chance(m, slot, chance); + } +} /// `Mob.setDropChance`. pub fn set_drop_chance(m: &mut Mob, slot: usize, chance: f32) { let c = m diff --git a/crates/horizon-client/src/mobs/spawner.rs b/crates/horizon-client/src/mobs/spawner.rs index 78b091b7b..f5e633226 100644 --- a/crates/horizon-client/src/mobs/spawner.rs +++ b/crates/horizon-client/src/mobs/spawner.rs @@ -152,6 +152,34 @@ pub(crate) fn cube_scale(id: &str, entity: &Compound) -> f32 { .map_or(1, |size| (size as i32).saturating_add(1).clamp(1, 127)) as f32 } +/// `EquipmentTable.CODEC`: the loot table and the drop chance of each +/// `EquipmentSlot` (`drops::SLOTS` order) the table names, `slot_drop_chances` +/// being one number for every slot or a map by slot name. +pub fn equipment_table(tag: &Tag) -> Option<(String, [Option; 8])> { + let chance = |t: &Tag| match t { + Tag::Float(v) => Some(f32::from_bits(*v)), + Tag::Double(v) => Some(f64::from_bits(*v) as f32), + Tag::Byte(v) => Some(f32::from(*v)), + Tag::Short(v) => Some(f32::from(*v)), + Tag::Int(v) => Some(*v as f32), + Tag::Long(v) => Some(*v as f32), + _ => None, + }; + let Some(Tag::String(table)) = tag.get("loot_table") else { + return None; + }; + let mut chances = [None; 8]; + match tag.get("slot_drop_chances") { + Some(Tag::Compound(map)) => { + for (i, slot) in super::drops::SLOTS.iter().enumerate() { + chances[i] = map.get(&JavaString::from(*slot)).and_then(chance); + } + } + Some(all) => chances = [Some(chance(all)?); 8], + None => {} + } + Some((table.to_string_lossy(), chances)) +} /// A whole number from any numeric tag (`NumericTag.intValue`: floats floor). pub(crate) fn number(tag: Option<&Tag>) -> Option { Some(match tag? { From 8c0ed0e591d7abe2d5a971ad8e6929c37283666b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:33:24 +0100 Subject: [PATCH 30/84] Let a comparator read an item frame through a block A comparator behind a solid block now reads the item frame on its far side (rotation + 1, or 0 when empty), and updates when the frame's item or rotation changes. --- crates/horizon-client/src/game.rs | 17 +++++++++++++++++ crates/horizon-client/src/game/frames.rs | 14 ++++++++++++++ crates/horizon-world/src/level/mod.rs | 6 ++++++ crates/horizon-world/src/level/redstone.rs | 10 ++++++++-- 4 files changed, 45 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 58b89a140..083c9c85e 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -545,6 +545,8 @@ struct GameLevel<'w> { player_collision: Option, /// Minecart boxes (detector rails). cart_boxes: Vec<([f64; 3], [f64; 3])>, + /// The item frames a comparator reads through a conductor. + item_frames: &'w [horizon_client::entities::ItemFrame], /// The other entities that keep blocks from being placed into them. blockers: Blockers<'w>, biomes: &'w Biomes, @@ -706,6 +708,20 @@ impl LevelAccess for GameLevel<'_> { } machines::container_signal(self.world, self.behaviours, self.items, self.registry, pos) } + fn item_frame_analog_output(&self, pos: BlockPos, facing: Direction) -> Option { + let mut frames = self + .item_frames + .iter() + .filter(|f| f.pos == [pos.x, pos.y, pos.z] && f.facing == facing as u8); + let frame = frames.next().filter(|_| frames.next().is_none())?; + // ItemFrame.getAnalogOutput. + Some( + frame + .item + .as_ref() + .map_or(0, |_| i32::from(frame.rotation % 8) + 1), + ) + } fn block_entity_signal( &self, pos: BlockPos, @@ -2541,6 +2557,7 @@ impl Game<'_> { }; let mut level = GameLevel { cart_boxes, + item_frames: &self.item_frames, blockers, world: &mut self.world, facts: self.res.facts(), diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs index d08c5f283..9e18b2cb3 100644 --- a/crates/horizon-client/src/game/frames.rs +++ b/crates/horizon-client/src/game/frames.rs @@ -7,6 +7,7 @@ use horizon_assets::{bake::bake_model, model::CuboidModel, resolve::ModelLibrary use horizon_client::{entities::ItemFrame, items::ItemStack, mesher::Vertex}; use horizon_core::{ geometry::{Aabb, Vec3}, + position::BlockPos, random::RandomSource, }; use std::sync::Arc; @@ -223,6 +224,7 @@ impl Game<'_> { } let p = self.item_frames[i].pos; self.world.modified.insert((p[0] >> 4, p[2] >> 4)); + self.frame_output_changed(p); self.swing_arm(); true } @@ -255,8 +257,17 @@ impl Game<'_> { } self.drop_frame_items(&f, with_frame, true); self.world.modified.insert((f.pos[0] >> 4, f.pos[2] >> 4)); + if f.item.is_some() { + self.frame_output_changed(f.pos); + } true } + /// `ItemFrame.setItem` / `setRotation`: `updateNeighbourForOutputSignal`, so + /// the comparators reading the frame take its new signal. + fn frame_output_changed(&mut self, pos: [i32; 3]) { + let at = BlockPos::new(pos[0], pos[1], pos[2]); + self.with_level(|b, level, ticks| b.update_neighbour_for_output_signal(level, ticks, at)); + } /// `ItemFrame.dropItem`: the frame (when breaking) and the held item. fn drop_frame_items(&mut self, f: &ItemFrame, with_frame: bool, by_player: bool) { if !self.ui.rules.bool("entity_drops") || (by_player && self.creative) { @@ -300,6 +311,9 @@ impl Game<'_> { self.audio .play(&sound(&f, "break"), Some(center(&f)), 1.0, 1.0); self.drop_frame_items(&f, true, false); + if f.item.is_some() { + self.frame_output_changed(f.pos); + } continue; } } diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index c81bdf369..f06771a06 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -372,6 +372,12 @@ pub trait LevelAccess { ) -> i32 { 0 } + /// `ItemFrame.getAnalogOutput` of the one item frame in the block at + /// `pos` that faces `facing` (`ComparatorBlock.getItemFrame`), or None when + /// there is not exactly one. + fn item_frame_analog_output(&self, _pos: BlockPos, _facing: Direction) -> Option { + None + } /// `ContainerOpenersCounter.recheckOpenCount` for the chest or ender chest /// block entity at `pos`: recounts its openers and returns the previous /// and new counts (the caller plays open/close effects when they change), diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs index 92f9059e5..bebf5d826 100644 --- a/crates/horizon-world/src/level/redstone.rs +++ b/crates/horizon-world/src/level/redstone.rs @@ -490,8 +490,14 @@ impl Sim<'_, L> { } else if result < 15 && self.is_redstone_conductor(target_state, target) { let further = rel(target, facing); let further_state = self.state(further); - if b.has_flag(further_state, state_flags::ANALOG_OUTPUT) { - result = self.analog_output(further_state, further, facing.opposite()); + let block = b + .has_flag(further_state, state_flags::ANALOG_OUTPUT) + .then(|| self.analog_output(further_state, further, facing.opposite())); + // ComparatorBlock.getInputSignal: an item frame behind the + // conductor counts too, the larger signal winning. + let frame = self.level.item_frame_analog_output(further, facing); + if let Some(signal) = frame.into_iter().chain(block).max() { + result = signal; } } } From b5a735c8d176f0ea15535c450bf4d548c1d69ffe Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:33:51 +0100 Subject: [PATCH 31/84] Let tame parrots follow their owner and sit when told to A tamed parrot ignored its owner: it never followed, and right-clicking it did nothing. Give the parrot the goals of Parrot.registerGoals (SitWhenOrderedToGoal, FollowOwnerGoal 1.0, 5.0, 1.0), let the owner toggle sitting with a click while it stands on the ground, and keep the owner and sitting state in the save file and in the data a guest gets. --- crates/horizon-client/src/entity_nbt.rs | 13 +++++++++++++ crates/horizon-client/src/game/creatures.rs | 15 +++++++++++++++ crates/horizon-client/src/game/lan.rs | 7 +++++++ crates/horizon-client/src/mobs/ai.rs | 1 + crates/horizon-client/src/mobs/tame.rs | 11 +++++++++++ 5 files changed, 47 insertions(+) diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 7f3565067..6c7fd1d5a 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -246,6 +246,14 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.entry("sound_variant".into()) .or_insert_with(|| string("minecraft:classic")); } + "minecraft:parrot" => { + if let Some(owner) = m.extra.owner { + map.insert("Owner".into(), Tag::IntArray(owner.to_vec())); + } else { + map.remove(&"Owner".into()); + } + map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting))); + } "minecraft:wolf" => { if let Some(owner) = m.extra.owner { map.insert("Owner".into(), Tag::IntArray(owner.to_vec())); @@ -773,6 +781,11 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - .unwrap_or(0) as u8; } } + if m.species() == crate::mobs::Species::Parrot { + m.extra.owner = crate::save::uuid_from_tag(tag.get("Owner")); + m.extra.tame = m.extra.owner.is_some(); + m.extra.sitting = flag(tag, "Sitting"); + } if m.species() == crate::mobs::Species::Wolf { let health = m.health; m.extra.owner = crate::save::uuid_from_tag(tag.get("Owner")); diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index d192a2b02..8eb4cc911 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2559,6 +2559,12 @@ impl Game<'_> { .items() .get(&item) .is_some_and(|i| i.max_damage > 0); + let parrot_poisonous = self + .res + .items() + .item_tags + .get("minecraft:parrot_poisonous_food") + .is_some_and(|t| t.contains(&*item)); let m = &mut self.mobs[index]; if !m.alive() { return Ok(false); @@ -2764,6 +2770,15 @@ impl Game<'_> { m.position.z.floor() as i32 >> 4, )); } + // Parrot.mobInteract: the owner makes a tame parrot on the ground + // sit or stand (poisonous food is handled apart). + Species::Parrot if m.extra.tame && m.on_ground && !parrot_poisonous => { + m.extra.sitting = !m.extra.sitting; + self.world.modified.insert(( + m.position.x.floor() as i32 >> 4, + m.position.z.floor() as i32 >> 4, + )); + } Species::Cat if !m.extra.tame && is_food => { consume = true; m.persistent = true; diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 5292cd31b..72345970b 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -231,6 +231,13 @@ fn mob_meta( } defaults.push((18, serializer::BYTE, Value::Byte(0))); } + "minecraft:parrot" => { + // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4. + let flags = i8::from(e.sitting) | if e.tame { 4 } else { 0 }; + if flags != 0 { + meta.push((18, serializer::BYTE, Value::Byte(flags))); + } + } "minecraft:cat" | "minecraft:wolf" => { // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4. let flags = i8::from(e.sitting) | if e.tame { 4 } else { 0 }; diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 2676c3a37..d30cc56ad 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -178,6 +178,7 @@ pub fn register(m: &mut Mob) { Family::Undead => undead::register(m), Family::Hostile => hostile::register(m), Family::Aquatic => aquatic::register(m), + Family::Generic if m.species() == Species::Parrot => super::tame::register_parrot(m), Family::Generic => { generic(m); if m.species() == Species::Rabbit { diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index 1e725df80..0043ff9ef 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -100,6 +100,17 @@ pub fn register(m: &mut Mob) { ), ); } +/// `Parrot.registerGoals`: a tamed parrot sits when told to and follows its +/// owner from five blocks away (the wander and the shoulder come as they are). +pub fn register_parrot(m: &mut Mob) { + let g = &mut m.ai.goals; + g.add(0, TamePanic(Panic::new(1.25))); + g.add(0, Float); + g.add(1, LookAtPlayer::new(8.0)); + g.add(2, SitWhenOrdered); + g.add(2, FollowOwner::new(1.0, 5.0, 1.0)); + g.add(2, Stroll::avoiding_water(1.0)); +} /// `Wolf.PREY_SELECTOR`: sheep, rabbits and foxes. fn wolf_prey(s: &super::Seen) -> bool { matches!(s.species, Species::Sheep | Species::Rabbit | Species::Fox) From 4d9ead721e547a3a4983ebf738c316674be1c55b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:36:35 +0100 Subject: [PATCH 32/84] Point the recovery compass at the player's last death The local player's last death location is now recorded, saved as LastDeathLocation, taken from the Login and Respawn packets on the server thread, and given to the item owner. --- crates/horizon-client/src/game.rs | 3 ++ crates/horizon-client/src/game/item_draw.rs | 5 ++++ crates/horizon-client/src/game/lan_actions.rs | 2 +- crates/horizon-client/src/game/remote.rs | 6 ++++ crates/horizon-client/src/lan/guest.rs | 2 +- crates/horizon-client/src/lan/hub.rs | 28 +++++++++---------- crates/horizon-client/src/lan/playerdata.rs | 2 ++ crates/horizon-client/src/save.rs | 21 ++++++++++++++ 8 files changed, 53 insertions(+), 16 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 58b89a140..8788c8f2b 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4587,6 +4587,9 @@ impl Game<'_> { let feet = [player.position.x, player.position.y, player.position.z]; let at = [feet[0], feet[1] + 1.32, feet[2]]; let killer = self.combat_killer_kind(); + // Player.die: the dimension and block of the death. + self.level.last_death = + Some((self.dim.id().to_owned(), feet.map(|v| v.floor() as i32))); self.death_message(); // ServerPlayer.die: deaths, and the time-since counters restart. self.stats.custom("deaths", 1); diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index b6b7e2fb7..ce3757305 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -247,6 +247,11 @@ impl Game<'_> { owner.main_arm_left = self.settings.main_hand_left; owner.is_local_player = true; owner.is_view_entity = true; + owner.last_death_location = self + .level + .last_death + .clone() + .map(|(dimension, pos)| GlobalPos { dimension, pos }); if let (Some((slot, ticks)), Some(stack)) = (self.using, stack) && self.stack_in(slot) == Some(stack) { diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 43bb573dc..20fbdf9af 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -2009,7 +2009,7 @@ impl Game<'_> { let g = &mut host.hub.guests[gi]; if g.health <= 0.0 && !g.dead { g.dead = true; - g.last_death = Some(g.position.map(|v| v.floor() as i32)); + g.last_death = Some((g.dimension.clone(), g.position.map(|v| v.floor() as i32))); let (id, at) = (g.entity_id, g.position); let reward = Experience { level: g.xp_level, diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3cfbd15e3..03f5cc554 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -995,6 +995,12 @@ impl Game<'_> { r.predictions.clear(); self.set_mode_id(spawn.game_type); self.dim = Dim::from_id(&spawn.dimension); + // ClientPacketListener.handleLogin / handleRespawn: the server's + // Player.getLastDeathLocation, for the recovery compass. + self.level.last_death = spawn + .last_death + .as_ref() + .map(|d| (d.dimension.clone(), d.pos)); if !same { let mut streaming = Streaming::new( Arc::new(NoTerrain), diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 7e43cf04e..23e1efbe2 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -210,7 +210,7 @@ pub struct Guest { /// last sent about itself. pub sent_shared: i8, /// Where the player last died (Player.lastDeathLocation), sent with the respawn. - pub last_death: Option<[i32; 3]>, + pub last_death: Option<(String, [i32; 3])>, /// The last action sequence to acknowledge at the next tick (-1: none). pub ack_up_to: std::cell::Cell, pub sent_selected: usize, diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index b1a8cbc62..7bcea3e79 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -557,16 +557,24 @@ impl Hub { // ---- joining ------------------------------------------------------- - fn spawn_info(&self, game_mode: i32) -> play::SpawnInfo { + fn spawn_info(&self, i: usize) -> play::SpawnInfo { + let g = &self.guests[i]; play::SpawnInfo { dimension_type: self.dimension_type, dimension: self.config.dimension.clone(), seed: horizon_core::biome::obfuscate_seed(self.config.seed), - game_type: game_mode, + game_type: g.game_mode, previous_game_type: None, debug: false, flat: false, - last_death: None, + // Player.getLastDeathLocation. + last_death: g + .last_death + .as_ref() + .map(|(dimension, pos)| play::GlobalPos { + dimension: dimension.clone(), + pos: *pos, + }), portal_cooldown: 0, sea_level: 63, } @@ -635,7 +643,7 @@ impl Hub { reduced_debug_info: false, show_death_screen: true, limited_crafting: false, - spawn: self.spawn_info(mode), + spawn: self.spawn_info(i), // MinecraftServer.usesAuthentication, enforceSecureProfile. online_mode: self.lan.shared.config.online.is_some(), enforces_secure_chat: self.enforces_secure_chat(), @@ -2361,14 +2369,7 @@ impl Hub { /// level loading screen from the Respawn packet until the level info's "level chunks load /// start" event and the chunk under the player, so the packets follow vanilla's order. pub fn respawn(&mut self, i: usize, at: [f64; 3], ctx: &TickCtx) { - let mode = self.guests[i].game_mode; - let mut info = self.spawn_info(mode); - // Player.getLastDeathLocation, set where the player died. - // The level they died in: theirs until now. - info.last_death = self.guests[i].last_death.map(|pos| play::GlobalPos { - dimension: self.guests[i].dimension.clone(), - pos, - }); + let info = self.spawn_info(i); self.close_container_for(i); let g = &mut self.guests[i]; // PlayerList.respawn: into the level in place (the respawn level). @@ -2481,8 +2482,7 @@ impl Hub { portal_sound: bool, ctx: &TickCtx, ) { - let mode = self.guests[i].game_mode; - let info = self.spawn_info(mode); + let info = self.spawn_info(i); self.close_container_for(i); let g = &mut self.guests[i]; g.dimension = self.config.dimension.clone(); diff --git a/crates/horizon-client/src/lan/playerdata.rs b/crates/horizon-client/src/lan/playerdata.rs index f5eb935c9..af8f15bb4 100644 --- a/crates/horizon-client/src/lan/playerdata.rs +++ b/crates/horizon-client/src/lan/playerdata.rs @@ -86,6 +86,7 @@ pub fn apply(guest: &mut Guest, level: &Level) { guest.respawn_elsewhere = level.respawn_elsewhere.clone(); guest.saved = level.player_extra.clone(); guest.seen_credits = level.seen_credits; + guest.last_death = level.last_death.clone(); let extra = level.player_extra.as_ref(); let short = |key: &str, default: i64| { extra @@ -168,6 +169,7 @@ pub fn store(guest: &Guest, level: &mut Level) { level.respawn_elsewhere = guest.respawn_elsewhere.clone(); level.on_ground = guest.on_ground; level.seen_credits = guest.seen_credits; + level.last_death = guest.last_death.clone(); level.player_extra = guest.saved.clone(); // The live body's fire, air and fall distance (Entity.saveWithoutId), // or what the file had while the player has no body yet. diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 5926e0a1d..c965d36c1 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -2761,6 +2761,8 @@ pub struct Level { pub xp_seed: i32, /// ServerPlayer.seenCredits: the end poem has been shown. pub seen_credits: bool, + /// Player.lastDeathLocation: the dimension and block of the last death. + pub last_death: Option<(String, [i32; 3])>, /// Player.active_effects: (id, duration, amplifier, ambient, show_icon). pub active_effects: Vec<(String, i32, i32, bool, bool)>, /// Player.EnderItems: the ender chest inventory (27 slots). @@ -2961,6 +2963,15 @@ impl Level { self.fall_distance = f("fall_distance").unwrap_or(0.0); self.on_ground = n("OnGround").unwrap_or(0) != 0; self.seen_credits = n("seenCredits").unwrap_or(0) != 0; + self.last_death = p.get("LastDeathLocation").and_then(|d| { + let Some(Tag::IntArray(pos)) = d.get("pos") else { + return None; + }; + Some(( + text(d.get("dimension"))?, + [*pos.first()?, *pos.get(1)?, *pos.get(2)?], + )) + }); if let Some(mode) = n("playerGameType") { self.creative = mode == 1; self.game_mode = mode as i32; @@ -3061,6 +3072,7 @@ impl Level { "Pos", "respawn", "recipeBook", + "LastDeathLocation", ] { map.remove(&JavaString::from(key)); } @@ -3187,6 +3199,15 @@ impl Level { entries.push(("Pos", doubles(&pos))); } entries.push(("seenCredits", Tag::Byte(i8::from(self.seen_credits)))); + if let Some((dimension, pos)) = &self.last_death { + entries.push(( + "LastDeathLocation", + Tag::compound([ + ("dimension", string(dimension)), + ("pos", Tag::IntArray(pos.to_vec())), + ]), + )); + } // A respawn point other than the world spawn: an anchor elsewhere, or a bed. if let Some((dimension, block, yaw, forced)) = &self.respawn_elsewhere { let mut respawn = vec![ From f1949c3bdacece089ba1dfa2bcfe31eb9698e2ce Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:36:39 +0100 Subject: [PATCH 33/84] Ask before the death screen's Title Screen button leaves the world --- crates/horizon-client/src/confirm_screen.rs | 15 ++++- crates/horizon-client/src/game.rs | 15 +++++ crates/horizon-client/src/game/chat.rs | 4 ++ crates/horizon-client/src/game/remote.rs | 2 + crates/horizon-client/src/game/screens.rs | 61 +++++++++++++++++++++ 5 files changed, 95 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/confirm_screen.rs b/crates/horizon-client/src/confirm_screen.rs index 3b4f7e7aa..c6fda8236 100644 --- a/crates/horizon-client/src/confirm_screen.rs +++ b/crates/horizon-client/src/confirm_screen.rs @@ -63,13 +63,24 @@ impl Confirm { atlas: &HudAtlas, cursor: (f32, f32), labels: [&Text; 2], + ) { + self.draw_active(batch, atlas, cursor, labels, true); + } + /// `draw` with the buttons greyed out while `setDelay` runs (`active` false). + pub fn draw_active( + &self, + batch: &mut HudBatch, + atlas: &HudAtlas, + cursor: (f32, f32), + labels: [&Text; 2], + active: bool, ) { for (line, x, y) in &self.lines { batch.text_styled(atlas, line, *x, *y, u32::MAX, true); } for ((bx, by), label) in self.buttons.into_iter().zip(labels) { - let hover = ui::hovered(cursor, bx, by, 150.0, 20.0); - ui::button(batch, atlas, bx, by, 150.0, 20.0, label, true, hover); + let hover = active && ui::hovered(cursor, bx, by, 150.0, 20.0); + ui::button(batch, atlas, bx, by, 150.0, 20.0, label, active, hover); } } } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 58b89a140..9747559f0 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4281,6 +4281,7 @@ impl Game<'_> { self.screen = Screen::Dead; self.ui.died_at = Some(Instant::now()); self.ui.death_text = None; + self.ui.death_confirm = None; self.capture(false); } self.previous_position = feet; @@ -11860,6 +11861,20 @@ impl ApplicationHandler for Game<'_> { _ => {} } } + // ConfirmScreen.keyPressed: Escape answers no, once its delay is over. + WindowEvent::KeyboardInput { event, .. } + if self.screen == Screen::Dead && self.ui.death_confirm.is_some() => + { + if event.state == ElementState::Pressed + && event.physical_key == PhysicalKey::Code(KeyCode::Escape) + && self + .ui + .death_confirm + .is_some_and(|t| t.elapsed().as_millis() >= 1000) + { + self.death_confirm_answer(false)?; + } + } // ConfirmScreen.keyPressed: Escape answers no. WindowEvent::KeyboardInput { event, .. } if self.server_packs.prompt.is_some() => { if event.state == ElementState::Pressed diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index 03174c009..bb4c26adc 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -102,6 +102,9 @@ pub struct UiState { /// Death screen cause and when the player died (buttons wait 20 ticks). pub death_text: Option, pub died_at: Option, + /// `DeathScreen.TitleConfirmScreen` and when it opened (its buttons wait + /// 20 ticks, `setDelay`). + pub death_confirm: Option, /// `LivingEntity.deathTime` of the window's player: ticks since it died. pub death_time: u32, } @@ -886,6 +889,7 @@ impl Game<'_> { let cause = self.ui.death_cause.take(); self.ui.died_at = Some(std::time::Instant::now()); self.ui.death_text = None; + self.ui.death_confirm = None; if !self.ui.rules.bool("show_death_messages") { return; } diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3cfbd15e3..fae77175c 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2185,6 +2185,7 @@ impl Game<'_> { if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() { self.screen = Screen::Dead; self.ui.death_time = 0; + self.ui.death_confirm = None; self.capture(false); } } @@ -2202,6 +2203,7 @@ impl Game<'_> { if me && self.screen != Screen::Dead && self.player.is_some() { self.screen = Screen::Dead; self.ui.death_time = 0; + self.ui.death_confirm = None; self.capture(false); } } diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index f8885f83a..4f5c72694 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -3,6 +3,7 @@ use super::{Game, Screen}; use horizon_client::{ Result, command::args::GameMode, + confirm_screen::Confirm, hud::{HudBatch, rgba}, text::{self, Text}, ui, @@ -84,6 +85,14 @@ fn pause_icons(w: f32, h: f32) -> [(f32, f32, &'static str); 4] { ] } /// DeathScreen.init: a hardcore player can only spectate. +/// `DeathScreen.TitleConfirmScreen`: its title and the yes and no labels. +fn death_confirm_texts() -> (Text, [Text; 2]) { + let t = |key: &str| Text::translate(key, &[]); + ( + t("deathScreen.quit.confirm"), + [t("deathScreen.titleScreen"), t("deathScreen.respawn")], + ) +} fn death_buttons(w: f32, h: f32, hardcore: bool) -> [(f32, f32, &'static str, u8); 2] { let respawn = if hardcore { "deathScreen.spectate" @@ -231,6 +240,20 @@ impl Game<'_> { ), ); } + // DeathScreen.handleExitToTitleScreen: the TitleConfirmScreen takes the + // screen over, on the same background. + if let Some(opened) = self.ui.death_confirm { + let (title, labels) = death_confirm_texts(); + let size = self.gui_size(); + Confirm::new(&atlas.font, size, &title, &Text::literal("")).draw_active( + batch, + atlas, + self.cursor, + [&labels[0], &labels[1]], + opened.elapsed().as_millis() >= 1000, + ); + return; + } let title = if self.level.hardcore { "deathScreen.title.hardcore" } else { @@ -294,6 +317,23 @@ impl Game<'_> { { return Ok(()); } + if let Some(opened) = self.ui.death_confirm { + // ConfirmScreen.setDelay: both buttons wait 20 ticks. + if opened.elapsed().as_millis() < 1000 { + return Ok(()); + } + let (title, _) = death_confirm_texts(); + let confirm = Confirm::new( + &self.gui.atlas.font, + self.gui_size(), + &title, + &Text::literal(""), + ); + if let Some(yes) = confirm.answer_at(self.cursor) { + self.death_confirm_answer(yes)?; + } + return Ok(()); + } let size = self .renderer .as_ref() @@ -303,6 +343,27 @@ impl Game<'_> { .into_iter() .find(|d| ui::hovered(self.cursor, d.0, d.1, 200.0, 20.0)) .map(|d| d.3); + // handleExitToTitleScreen: outside hardcore, Title Screen asks first. + if hit == Some(1) && !self.level.hardcore { + self.ui.death_confirm = Some(std::time::Instant::now()); + self.audio.play_button_click(); + return Ok(()); + } + self.death_action(hit) + } + /// The confirm screen's answer: yes leaves the world, no respawns + /// (`DeathScreen.handleExitToTitleScreen`'s callback). + pub(super) fn death_confirm_answer(&mut self, yes: bool) -> Result<()> { + self.ui.death_confirm = None; + if yes { + self.audio.play_button_click(); + self.close_world() + } else { + self.death_action(Some(0)) + } + } + /// A death screen button: 0 respawns (or spectates in hardcore), 1 leaves. + fn death_action(&mut self, hit: Option) -> Result<()> { if hit == Some(0) && self.remote.is_none() { let keep = self.ui.rules.bool("keep_inventory") || self.spectator(); self.experience.respawn(keep); From 796dc320d9b3ccef8c2bc949bbb0db0072ecc05d Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:36:45 +0100 Subject: [PATCH 34/84] Use the height adjusted biome temperature for the rain and snow line on the client --- crates/horizon-client/src/biome.rs | 26 ++++++++++++++++++- crates/horizon-client/src/game.rs | 16 ++++-------- crates/horizon-client/src/game/render_tick.rs | 11 +------- 3 files changed, 31 insertions(+), 22 deletions(-) diff --git a/crates/horizon-client/src/biome.rs b/crates/horizon-client/src/biome.rs index c8c15e44e..7aa95e623 100644 --- a/crates/horizon-client/src/biome.rs +++ b/crates/horizon-client/src/biome.rs @@ -1,7 +1,8 @@ //! Biome colours from the pinned biome definitions and colormaps //! (`Biome.getGrassColor`/`getFoliageColor`/..., `BlockTintSources`). use crate::Result; -use horizon_core::{noise::SimplexNoise, random::LegacyRandom}; +use horizon_core::{noise::SimplexNoise, position::BlockPos, random::LegacyRandom}; +use horizon_world::worldgen::biome_temperature::{BiomeTemperatureSettings, TemperatureModifier}; use serde_json::Value; use std::{collections::HashMap, fs, path::Path}; @@ -33,6 +34,8 @@ pub struct BiomeInfo { pub increased_fire_burnout: bool, pub name: String, pub temperature: f32, + /// `climateSettings.temperatureModifier` (frozen oceans). + pub temperature_modifier: TemperatureModifier, pub downfall: f32, pub precipitation: bool, pub grass: u32, @@ -45,6 +48,22 @@ pub struct BiomeInfo { pub fog: Option, pub water_fog: u32, } +impl BiomeInfo { + /// `Biome.getPrecipitationAt` in the Overworld (sea level 63): None + /// without precipitation, else whether it falls as snow + /// (`getHeightAdjustedTemperature` below 0.15). + pub fn snows_at(&self, x: i32, y: i32, z: i32) -> Option { + let settings = BiomeTemperatureSettings { + base_temperature: self.temperature, + modifier: self.temperature_modifier, + has_precipitation: self.precipitation, + downfall: self.downfall, + }; + settings + .has_precipitation + .then(|| settings.height_adjusted(BlockPos::new(x, y, z), 63) < 0.15) + } +} pub struct Biomes { pub list: Vec, pub index: HashMap, @@ -105,6 +124,10 @@ impl Biomes { let attributes = &v["attributes"]; let temperature = v["temperature"].as_f64().unwrap_or(0.5) as f32; let downfall = v["downfall"].as_f64().unwrap_or(0.5) as f32; + let temperature_modifier = match v["temperature_modifier"].as_str() { + Some("frozen") => TemperatureModifier::Frozen, + _ => TemperatureModifier::None, + }; let modifier = match effects["grass_color_modifier"].as_str() { Some("dark_forest") => GrassModifier::DarkForest, Some("swamp") => GrassModifier::Swamp, @@ -135,6 +158,7 @@ impl Biomes { .as_bool() .unwrap_or(false), temperature, + temperature_modifier, downfall, precipitation: v["has_precipitation"].as_bool().unwrap_or(true), grass: color(&effects["grass_color"]) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 58b89a140..e5667f6de 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9670,19 +9670,13 @@ impl Game<'_> { } } /// Whether precipitation at a column is snow (Biome.coldEnoughToSnow: - /// base temperature lowered above y 80) or none (no precipitation). + /// height adjusted temperature) or none (no precipitation). fn precipitation(&self, x: i32, y: i32, z: i32) -> Option { let chunk = self.world.chunks.get(&(x >> 4, z >> 4))?; - let b = self.res.biomes().get(chunk.biome(x, y, z)); - if !b.precipitation { - return None; - } - let t = if y > 80 { - b.temperature - (y - 80) as f32 * 0.05 / 40.0 - } else { - b.temperature - }; - Some(t < 0.15) + self.res + .biomes() + .get(chunk.biome(x, y, z)) + .snows_at(x, y, z) } /// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)`: one above the /// highest block in `blocks_motion_in_heightmap` or holding a fluid. diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index e013c8d29..f5efa392b 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -33,16 +33,7 @@ fn rains_at(world: &World, biomes: &Biomes, x: i32, y: i32, z: i32) -> bool { let Some(chunk) = world.chunks.get(&(x >> 4, z >> 4)) else { return false; }; - let b = biomes.get(chunk.biome(x, y, z)); - if !b.precipitation { - return false; - } - let t = if y > 80 { - b.temperature - (y - 80) as f32 * 0.05 / 40.0 - } else { - b.temperature - }; - t >= 0.15 + biomes.get(chunk.biome(x, y, z)).snows_at(x, y, z) == Some(false) } impl Game<'_> { From de2df51193171de808cbd3e6a79add64aa012e39 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:38:43 +0100 Subject: [PATCH 35/84] Wolf armor: put it on, repair it, shear it off, and let it take the damage --- crates/horizon-client/src/entity_nbt.rs | 15 +++++ crates/horizon-client/src/game/creatures.rs | 54 +++++++++++++++++ crates/horizon-client/src/game/lan.rs | 7 ++- crates/horizon-client/src/game/remote.rs | 17 ++++-- crates/horizon-client/src/mobs.rs | 65 ++++++++++++++++++++- crates/horizon-client/src/mobs/drops.rs | 4 ++ crates/horizon-client/src/mobs/render.rs | 26 ++++++++- crates/horizon-client/src/mobs/species.rs | 9 ++- 8 files changed, 186 insertions(+), 11 deletions(-) diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 7f3565067..18f89d884 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -544,6 +544,16 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { equipment.insert(slot.into(), crate::save::item_to_nbt(&stack)); continue; } + // A wolf's armor keeps the durability it lost. + if slot == "body" + && m.species() == crate::mobs::Species::Wolf + && let Some(id) = item + { + let mut stack = crate::items::ItemStack::new(id, 1); + stack.damage = m.extra.body_damage.max(0) as u32; + equipment.insert(slot.into(), crate::save::item_to_nbt(&stack)); + continue; + } match item { Some(id) => { let keep = matches!( @@ -780,6 +790,11 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - crate::mobs::tame::set_tame(&mut m, tame); m.health = health; m.extra.sitting = flag(tag, "Sitting"); + m.extra.body_damage = tag + .get("equipment") + .and_then(|e| e.get("body")) + .and_then(crate::save::item_from_nbt) + .map_or(0, |s| s.damage as i32); m.extra.color = number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15); if let Some(Tag::String(v)) = tag.get("variant") { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index d192a2b02..a72d53c6b 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2559,12 +2559,18 @@ impl Game<'_> { .items() .get(&item) .is_some_and(|i| i.max_damage > 0); + let me = self.level.player_uuid.or(Some([0, 0, 0, 1])); + let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft) + || self.keys.contains(&winit::keyboard::KeyCode::ShiftRight); + let held_damage = held.as_ref().map_or(0, |h| h.damage as i32); let m = &mut self.mobs[index]; if !m.alive() { return Ok(false); } let species = m.species(); let center = m.center(); + // Wolf armor the owner takes off with shears or leaves a dropped stack of. + let mut armor_drop: Option = None; let mut consume = false; let mut give: Option<&str> = None; let mut sound: Option<&str> = None; @@ -2637,6 +2643,22 @@ impl Game<'_> { handled = false; } } + // Entity.interact: shears take a tamed wolf's armor off for its owner. + Species::Wolf + if item == "minecraft:shears" + && m.extra.tame + && m.extra.owner == me + && m.extra.head.is_some() + && !sneaking => + { + let mut stack = ItemStack::new("minecraft:wolf_armor", 1); + stack.damage = m.extra.body_damage.max(0) as u32; + armor_drop = Some(stack); + m.extra.head = None; + m.extra.body_damage = 0; + eat = Some(("item.armor.unequip_wolf", 1.0, 1.0)); + self.damage_held_tool(); + } // Wolf.mobInteract: heal, dye the collar or sit/stand when tame; // a bone tames a wild one a third of the time. Species::Wolf if m.extra.tame && is_food && m.health < m.attrs.max_health => { @@ -2650,6 +2672,35 @@ impl Game<'_> { m.health = (m.health + heal).min(m.attrs.max_health); consume = true; } + // Wolf.mobInteract: the owner puts wolf armor on a tamed adult. + Species::Wolf + if item == "minecraft:wolf_armor" + && m.extra.tame + && m.extra.owner == me + && m.extra.head.is_none() + && !m.is_baby() => + { + m.extra.head = Some(item.as_str().into()); + m.extra.body_damage = held_damage; + consume = true; + eat = Some(("item.armor.equip_wolf", 1.0, 1.0)); + } + // Wolf.mobInteract: an armadillo scute repairs a sitting wolf's + // armor by an eighth of its durability. + Species::Wolf + if item == "minecraft:armadillo_scute" + && m.extra.tame + && m.extra.owner == me + && m.extra.sitting + && m.extra.head.is_some() + && m.extra.body_damage > 0 => + { + m.extra.body_damage = (m.extra.body_damage + - (horizon_client::mobs::WOLF_ARMOR_DURABILITY as f32 * 0.125) as i32) + .max(0); + consume = true; + eat = Some(("item.wolf_armor.repair", 1.0, 1.0)); + } Species::Wolf if m.extra.tame && item.ends_with("_dye") @@ -2897,6 +2948,9 @@ impl Game<'_> { self.spawn_item(rest, at, [0.0, 0.0, 0.0], 40); } } + if let Some(stack) = armor_drop { + self.spawn_item(stack, [center[0], center[1] + 0.5, center[2]], [0.0; 3], 10); + } for (item, count) in drops { for _ in 0..count { let v = [ diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 5292cd31b..7897b5c57 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -379,7 +379,12 @@ fn mob_equipment( let stack = ItemStack { item: item.clone(), count: 1, - damage: 0, + // A wolf's armor shows its cracks. + damage: if slot == 5 && m.species() == horizon_client::mobs::Species::Wolf { + e.body_damage.max(0) as u32 + } else { + 0 + }, extra: None, }; out.push((slot, hub.stack(&Some(stack)))); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3cfbd15e3..7077023b8 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2011,13 +2011,19 @@ impl Game<'_> { // player holds and wears (EquipmentSlot ordinals). C::SetEquipment(p) => { self.remote_object_equipment(p.id, &p.slots); - let items: Vec<(u8, Option>)> = p + let items: Vec<(u8, Option>, i32)> = p .slots .iter() - .map(|(slot, stack)| (*slot, stack.as_ref().map(|s| self.item_name(s.item)))) + .map(|(slot, stack)| { + ( + *slot, + stack.as_ref().map(|s| self.item_name(s.item)), + self.to_stack(stack).map_or(0, |s| s.damage as i32), + ) + }) .collect(); if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { - for (slot, item) in items { + for (slot, item, damage) in items { let e = &mut m.extra; match slot { 0 => e.main_hand = item, @@ -2025,7 +2031,10 @@ impl Game<'_> { 2 => e.feet = item, 3 => e.legs = item, 4 => e.chest = item, - 5 => e.head = item, + 5 => { + e.head = item; + e.body_damage = damage; + } _ => {} } } diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 4b67f738f..f9a53f0f2 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -631,6 +631,8 @@ pub struct Attrs { pub spawn_reinforcements: f64, pub jump_strength: f64, } +/// `minecraft:wolf_armor`'s maximum damage. +pub const WOLF_ARMOR_DURABILITY: i32 = 64; /// Species-specific persistent state (variants, colours, taming, ageing...). #[derive(Clone, Debug, Default)] pub struct Extra { @@ -659,6 +661,8 @@ pub struct Extra { /// `Mob.canPickUpLoot` (also lets dispensers equip it). pub pick_up_loot: bool, pub saddled: bool, + /// The durability a wolf's body armor (`extra.head`) has lost. + pub body_damage: i32, /// The saddle's components (name, enchantments...) when it is not a bare /// one; `saddled` stays the gameplay flag. pub saddle_stack: Option, @@ -1752,18 +1756,29 @@ impl Mob { if epf > 0.0 { amount *= 1.0 - epf / 25.0; } + // Wolf.actuallyHurt: wolf armor takes the damage instead of the wolf. + let absorbed = self.wolf_armor_absorbs(&source); let mut knock = true; if self.invulnerable as f32 > 10.0 { if amount <= self.last_hurt { return false; } - self.health -= amount - self.last_hurt; + let dealt = amount - self.last_hurt; + if absorbed { + self.hurt_wolf_armor(dealt); + } else { + self.health -= dealt; + } self.last_hurt = amount; knock = false; } else { self.last_hurt = amount; self.invulnerable = 20; - self.health -= amount; + if absorbed { + self.hurt_wolf_armor(amount); + } else { + self.health -= amount; + } self.hurt_time = 10; } // Animal.actuallyHurt: damage taken ends love mode (`resetLove`). @@ -1794,7 +1809,12 @@ impl Mob { // playHurtSound (Mob: also resets the ambient sound clock) or the // death sound: makeSound draws the voice pitch whenever there is a sound. let dead = !self.alive(); - let sound = ai::voice_sounds(self)[if dead { 2 } else { 1 }]; + // Wolf.getHurtSound: the armor's own sound when it takes the hit. + let sound = if absorbed { + "item.wolf_armor.damage" + } else { + ai::voice_sounds(self)[if dead { 2 } else { 1 }] + }; if !dead { self.ambient_timer = -self.kind.ambient_interval; } @@ -1809,6 +1829,45 @@ impl Mob { } true } + /// `Wolf.canArmorAbsorb`: it wears wolf armor and the damage type is not + /// in `#bypasses_wolf_armor` (drowning, magic, thorns, in a wall, out of + /// the world and the untyped kills). + fn wolf_armor_absorbs(&self, source: &Damage) -> bool { + self.species() == Species::Wolf + && self.extra.head.as_deref() == Some("minecraft:wolf_armor") + && !matches!( + source.kind, + DamageKind::Drown + | DamageKind::Magic + | DamageKind::InWall + | DamageKind::Thorns + | DamageKind::OutOfWorld + | DamageKind::Generic + ) + } + /// `Wolf.actuallyHurt`: the armor loses `ceil(damage)` durability, cracks + /// at `Crackiness.WOLF_ARMOR` steps and breaks at its maximum. + fn hurt_wolf_armor(&mut self, damage: f32) { + let crack = |lost: i32| { + let left = (WOLF_ARMOR_DURABILITY - lost) as f32 / WOLF_ARMOR_DURABILITY as f32; + [0.95_f32, 0.69, 0.32].iter().filter(|t| left < **t).count() + }; + let before = self.extra.body_damage; + let after = before + damage.ceil() as i32; + let at = [self.position.x, self.position.y, self.position.z]; + if after >= WOLF_ARMOR_DURABILITY { + self.extra.head = None; + self.extra.body_damage = 0; + self.outbox + .push(MobEvent::Sound("item.wolf_armor.break", at, 1.0, 1.0)); + } else { + self.extra.body_damage = after; + if crack(before) != crack(after) { + self.outbox + .push(MobEvent::Sound("item.wolf_armor.crack", at, 1.0, 1.0)); + } + } + } /// LivingEntity.knockback(power, xd, zd) towards the negative direction. pub fn knockback(&mut self, power: f64, mut xd: f64, mut zd: f64) { let power = power * (1.0 - self.attrs.knockback_resistance); diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs index c7b1c77e1..28ba2a0cd 100644 --- a/crates/horizon-client/src/mobs/drops.rs +++ b/crates/horizon-client/src/mobs/drops.rs @@ -245,6 +245,9 @@ pub fn slot_item(m: &Mob, slot: &str) -> Option { _ => (None, None), }; let mut stack = loot_stack(item?, 1); + if slot == "body" && m.species() == Species::Wolf { + stack.damage = m.extra.body_damage; + } if let (Some(index), Some(g)) = (index, gear::gear(m)) { for (e, l) in &g.slots[index] { stack.enchantments.push((e.to_string(), *l as i32)); @@ -282,6 +285,7 @@ pub fn clear_slot(m: &mut Mob, slot: &str) { } "body" if body => { m.extra.head = None; + m.extra.body_damage = 0; return; } "saddle" => { diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 077fd38a6..1e7286598 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -352,13 +352,37 @@ pub fn layers(m: &Mob) -> Vec { }) }; match m.species() { - // WolfCollarLayer. + // WolfArmorLayer, then WolfCollarLayer. S::Wolf if m.extra.tame => { let (model, texture) = if m.is_baby() { ("wolf_baby#main", "entity/wolf/wolf_collar_baby") } else { ("wolf#main", "entity/wolf/wolf_collar") }; + // The armor, then the cracks of its damage (`Crackiness.WOLF_ARMOR`). + if !m.is_baby() && m.extra.head.as_deref() == Some("minecraft:wolf_armor") { + let left = (super::WOLF_ARMOR_DURABILITY - m.extra.body_damage) as f32 + / super::WOLF_ARMOR_DURABILITY as f32; + push( + &mut v, + "wolf_armor#main", + "entity/equipment/wolf_body/armadillo_scute", + white, + false, + ); + let crack = [(0.32, "high"), (0.69, "medium"), (0.95, "low")] + .iter() + .find(|(t, _)| left < *t); + if let Some((_, level)) = crack { + push( + &mut v, + "wolf_armor#main", + &format!("entity/wolf/wolf_armor_crackiness_{level}"), + white, + false, + ); + } + } push( &mut v, model, diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs index f48a21fe9..95a342ca3 100644 --- a/crates/horizon-client/src/mobs/species.rs +++ b/crates/horizon-client/src/mobs/species.rs @@ -1690,10 +1690,15 @@ impl Def { } } /// Mobs whose `body` equipment slot Horizon keeps in `Extra::head` (a -/// happy ghast's harness, nautilus armour, a sulfur cube's swallowed block). +/// happy ghast's harness, nautilus armour, a sulfur cube's swallowed block, +/// a wolf's armor). pub fn body_slot(s: Species) -> bool { matches!( s, - Species::HappyGhast | Species::Nautilus | Species::ZombieNautilus | Species::SulfurCube + Species::HappyGhast + | Species::Nautilus + | Species::ZombieNautilus + | Species::SulfurCube + | Species::Wolf ) } From 9ca7162169b8db523223534eaa4874ea937e1be8 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:39:14 +0100 Subject: [PATCH 36/84] Let a tame parrot sit on its owner's shoulder A tame parrot never landed on its owner. Add LandOnOwnersShoulderGoal: when the parrot touches its owner, it is stored in the player's ShoulderEntityLeft or ShoulderEntityRight and removed from the world. It comes back, still tame, when the player falls, swims, flies, sleeps, is hurt, dies, turns spectator or spins with a riptide. The shoulder data is the player's own save data, so it also works for players on the integrated server and for LAN guests. --- crates/horizon-client/src/game.rs | 2 + crates/horizon-client/src/game/creatures.rs | 3 + crates/horizon-client/src/game/lan_actions.rs | 4 + crates/horizon-client/src/game/lan_mobs.rs | 1 + crates/horizon-client/src/game/shoulders.rs | 120 ++++++++++++++++++ crates/horizon-client/src/mobs.rs | 5 + crates/horizon-client/src/mobs/tame.rs | 29 +++++ 7 files changed, 164 insertions(+) create mode 100644 crates/horizon-client/src/game/shoulders.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 58b89a140..2acbfb4f9 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -156,6 +156,7 @@ mod server_packs; mod server_travel; mod shader_packs; mod shield; +mod shoulders; mod sign_edit; mod sniffers; mod spawner; @@ -4574,6 +4575,7 @@ impl Game<'_> { } self.powder_snow_fire()?; self.tick_totem(); + self.handle_shoulder_entities(); let Some(player) = self.player.as_mut() else { return Ok(()); }; diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 8eb4cc911..1a04ef0eb 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -49,6 +49,8 @@ pub(super) struct Creatures { pub elder_apparition: i32, /// The wandering trader spawner's clock. pub trader: super::wandering_trader::Spawner, + /// When each player last put a parrot on a shoulder (`timeEntitySatOnShoulder`). + pub shoulder_time: std::collections::HashMap<[i32; 4], i64>, } pub(super) struct ProjWorld<'a, 'w> { pub w: &'a MobWorld<'w>, @@ -992,6 +994,7 @@ impl Game<'_> { } MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob), MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive), + MobEvent::ParrotToShoulder { mob } => self.parrot_to_shoulder(mob), 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/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 43bb573dc..6e7f63f9c 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -378,6 +378,7 @@ impl Game<'_> { std::mem::swap(&mut self.adv.changed, &mut g.advancements_changed); std::mem::swap(&mut self.adv.unlocked, &mut g.recipes_unlocked); std::mem::swap(&mut self.level.recipe_book, &mut g.recipe_book); + std::mem::swap(&mut self.level.player_extra, &mut g.saved); std::mem::swap(&mut self.stats, &mut play.stats); std::mem::swap(&mut self.hook, &mut play.hook); let adv_loaded = std::mem::replace(&mut self.adv.loaded, true); @@ -610,6 +611,7 @@ impl Game<'_> { std::mem::swap(&mut self.adv.changed, &mut g.advancements_changed); std::mem::swap(&mut self.adv.unlocked, &mut g.recipes_unlocked); std::mem::swap(&mut self.level.recipe_book, &mut g.recipe_book); + std::mem::swap(&mut self.level.player_extra, &mut g.saved); std::mem::swap(&mut self.stats, &mut play.stats); std::mem::swap(&mut self.hook, &mut play.hook); self.adv.loaded = adv_loaded; @@ -2178,6 +2180,7 @@ impl Game<'_> { if !g.effects.list.is_empty() { self.as_guest(host, conn, |game| game.tick_mob_effects()); } + self.as_guest(host, conn, |game| game.handle_shoulder_entities()); return; } let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height()); @@ -2279,6 +2282,7 @@ impl Game<'_> { // LivingEntity.baseTick: outside the world border, then tickEffects. game.border_damage(); game.tick_mob_effects(); + game.handle_shoulder_entities(); let Some(player) = game.player.as_mut() else { return (Vec::new(), None); }; diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index 4f53cec60..4555474a5 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -80,6 +80,7 @@ pub(super) fn acts_on_player(e: &MobEvent) -> bool { } | MobEvent::EffectPlayer { .. } | MobEvent::AxolotlSupportPlayer + | MobEvent::ParrotToShoulder { .. } ) } diff --git a/crates/horizon-client/src/game/shoulders.rs b/crates/horizon-client/src/game/shoulders.rs new file mode 100644 index 000000000..602c5a5af --- /dev/null +++ b/crates/horizon-client/src/game/shoulders.rs @@ -0,0 +1,120 @@ +//! Parrots on a player's shoulder: a tame parrot lands on its owner +//! (`LandOnOwnersShoulderGoal`), is kept as the player's `ShoulderEntityLeft` +//! or `ShoulderEntityRight`, and flies off again when the player is hurt, +//! falls, swims, flies or sleeps (`ServerPlayer.handleShoulderEntities`). +use super::Game; +use horizon_client::mobs::Species; +use horizon_world::nbt::Tag; + +const KEYS: [&str; 2] = ["ShoulderEntityLeft", "ShoulderEntityRight"]; + +/// A shoulder slot holds a parrot when its compound is not empty. +fn occupied(extra: &Tag, key: &str) -> bool { + matches!(extra.get(key), Some(Tag::Compound(c)) if !c.is_empty()) +} + +impl Game<'_> { + /// `ServerPlayer.setEntityOnShoulder` for a parrot that touched its + /// owner: stored in the first free slot, the parrot gone from the world. + pub(super) fn parrot_to_shoulder(&mut self, mob: u32) { + let Some(i) = self + .mobs + .iter() + .position(|m| m.id == mob && m.alive() && !m.removed && m.species() == Species::Parrot) + else { + return; + }; + let Some(p) = self.player.as_ref() else { + return; + }; + if self.riding.is_some() + || !p.ground.on_ground + || p.fluids.was_touching_water + || p.in_powder_snow + || p.flying + { + return; + } + let extra = self + .level + .player_extra + .get_or_insert_with(|| Tag::Compound(Default::default())); + let Some(key) = KEYS.into_iter().find(|k| !occupied(extra, k)) else { + return; + }; + let tag = self.mob_tree_nbt(i); + if let Some(Tag::Compound(map)) = self.level.player_extra.as_mut() { + map.insert(key.into(), tag); + } + let (uuid, now) = (self.acting_uuid(), self.world.game_time); + self.creatures.shoulder_time.insert(uuid, now); + self.mobs[i].removed = true; + } + + /// `ServerPlayer.handleShoulderEntities`: the parrots leave the shoulder + /// of a player who falls, swims, flies, sleeps, is hurt, dying, a + /// spectator or spinning with a riptide. + pub(super) fn handle_shoulder_entities(&mut self) { + let Some(p) = self.player.as_ref() else { + return; + }; + let any = self + .level + .player_extra + .as_ref() + .is_some_and(|e| KEYS.iter().any(|k| occupied(e, k))); + if any + && (p.fall_distance > 0.5 + || p.fluids.was_touching_water + || p.flying + || p.spectator + || p.in_powder_snow + || p.auto_spin_attack_ticks > 0 + || p.health.hurt.hurt_time > 0 + || p.health.dead_or_dying() + || self.sleeping.is_some()) + { + self.remove_entities_on_shoulder(); + } + } + + /// `ServerPlayer.removeEntitiesOnShoulder` (not within a second of the + /// landing) and `respawnEntityOnShoulder`: the parrots come back at the + /// player, still owned by them. + fn remove_entities_on_shoulder(&mut self) { + let (uuid, now) = (self.acting_uuid(), self.world.game_time); + if self + .creatures + .shoulder_time + .get(&uuid) + .is_some_and(|t| t + 20 >= now) + { + return; + } + let Some(p) = self.player.as_ref().map(|p| p.position) else { + return; + }; + let Some(Tag::Compound(map)) = self.level.player_extra.as_mut() else { + return; + }; + let tags: Vec = KEYS + .iter() + .filter_map(|k| map.remove(&(*k).into())) + .collect(); + let pos = [p.x, p.y + f64::from(0.7_f32), p.z]; + for mut tag in tags { + let Tag::Compound(c) = &mut tag else { + continue; + }; + if c.is_empty() { + continue; + } + c.insert( + "Pos".into(), + Tag::List(pos.iter().map(|v| Tag::Double(v.to_bits())).collect()), + ); + c.insert("Owner".into(), Tag::IntArray(uuid.to_vec())); + self.load_mob(tag, None); + } + } +} diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 4b67f738f..b7e38bb01 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -894,6 +894,11 @@ pub enum MobEvent { mob: u32, hive: [i32; 3], }, + /// `LandOnOwnersShoulderGoal`: a tame parrot touched its owner and sits + /// on their shoulder (the host stores its tag and discards it). + ParrotToShoulder { + mob: u32, + }, /// `CopperGolem.turnToStatue`. BecomeStatue { mob: u32, diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index 0043ff9ef..82d808b7f 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -110,6 +110,35 @@ pub fn register_parrot(m: &mut Mob) { g.add(2, SitWhenOrdered); g.add(2, FollowOwner::new(1.0, 5.0, 1.0)); g.add(2, Stroll::avoiding_water(1.0)); + g.add(3, LandOnOwnersShoulder); +} +/// `LandOnOwnersShoulderGoal`: a standing parrot, 100 ticks old, lands on +/// the shoulder of the owner it touches; the host does the landing. +#[derive(Clone, Debug)] +struct LandOnOwnersShoulder; +impl Goal for LandOnOwnersShoulder { + goal_clone!(); + fn flags(&self) -> u8 { + 0 + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + // ShoulderRidingEntity.canSitOnShoulder: rideCooldownCounter > 100. + owner(m, cx.w).is_some_and(|(_, _, spectator)| !spectator) + && !m.extra.sitting + && m.age > 100 + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + if !m.extra.sitting + && m.extra.leash.is_none() + && cx + .w + .player + .as_ref() + .is_some_and(|p| m.bounds().intersects(p.bounds)) + { + cx.events.push(MobEvent::ParrotToShoulder { mob: m.id }); + } + } } /// `Wolf.PREY_SELECTOR`: sheep, rabbits and foxes. fn wolf_prey(s: &super::Seen) -> bool { From c30d51d65e1cde584b319f7105c4e772737077ce Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:41:45 +0100 Subject: [PATCH 37/84] Wolves fight other owners' tamed wolves --- crates/horizon-client/src/mobs.rs | 3 +++ crates/horizon-client/src/mobs/tame.rs | 6 ++++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 6b1e16f5c..66257ea8e 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1215,6 +1215,8 @@ pub struct Seen { pub baby: bool, pub in_love: bool, pub tame: bool, + /// A tamed animal's owner (`getOwner`). + pub owner: Option<[i32; 4]>, pub hostile: bool, pub target: Option, pub health: f32, @@ -1302,6 +1304,7 @@ impl Mob { m.extra.in_love > 0 }, tame: m.extra.tame, + owner: m.extra.owner, hostile: m.hostile(), target: m.ai.target, health: m.health, diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index 1e725df80..b6d0b1bb7 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -442,7 +442,8 @@ impl Goal for OwnerHurt { m.ai.target = None; } } -/// `Wolf.wantsToAttack`: never creepers, ghasts or tame wolves and cats. +/// `Wolf.wantsToAttack`: never creepers, ghasts, tame cats and parrots, or a +/// tame wolf of the same owner. fn wants_to_attack(m: &Mob, w: &MobWorld, who: Who) -> bool { let Who::Mob(id) = who else { return false; @@ -455,7 +456,8 @@ fn wants_to_attack(m: &Mob, w: &MobWorld, who: Who) -> bool { }; match s.species { Species::Creeper | Species::Ghast => false, - Species::Wolf | Species::Cat | Species::Parrot => !s.tame, + Species::Wolf => !s.tame || s.owner != m.extra.owner, + Species::Cat | Species::Parrot => !s.tame, Species::Horse | Species::Donkey | Species::Mule | Species::Llama => !s.tame, _ => true, } From 78a5ee0e55c8944114a77f465c1ddbfbb5d5d3f0 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:43:53 +0100 Subject: [PATCH 38/84] Let parrots imitate nearby mobs and dance to a jukebox Parrots only ever made their own sound. Follow Parrot.aiStep: one tick in 400 a parrot imitates a random mob within 20 blocks (half the time), and its ambient sound is sometimes a mob's voice. A parrot within 3.46 blocks of a playing jukebox now uses the party pose (level events 1010 and 1011). --- crates/horizon-client/src/game.rs | 6 + crates/horizon-client/src/game/jukebox.rs | 23 +++- crates/horizon-client/src/mobs.rs | 6 + crates/horizon-client/src/mobs/ai.rs | 4 + crates/horizon-client/src/mobs/body_anim.rs | 4 +- crates/horizon-client/src/mobs/parrot.rs | 138 ++++++++++++++++++++ 6 files changed, 179 insertions(+), 2 deletions(-) create mode 100644 crates/horizon-client/src/mobs/parrot.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 58b89a140..8e4038b80 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2844,6 +2844,12 @@ impl Game<'_> { data, } => self.sculk_charge_event(pos, data), LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos), + // LevelEventHandler 1010 and 1011: the parrots nearby dance or stop. + LevelEvent::LevelEvent { + id: id @ (1010 | 1011), + pos, + .. + } => self.notify_record_playing([pos.x, pos.y, pos.z], id == 1010), LevelEvent::LevelEvent { id: 2004, pos, .. } => { self.spawner_burst([pos.x, pos.y, pos.z]) } diff --git a/crates/horizon-client/src/game/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs index c3ed75ebb..5c55c5f54 100644 --- a/crates/horizon-client/src/game/jukebox.rs +++ b/crates/horizon-client/src/game/jukebox.rs @@ -6,10 +6,15 @@ use super::Game; use horizon_client::{ containers::{BlockEntity, Jukebox}, items::ItemStack, + mobs::Species, particles::{ParticleOptions, ParticleType}, text::Text, }; -use horizon_core::{position::BlockPos, random::RandomSource}; +use horizon_core::{ + geometry::{Aabb, Vec3}, + position::BlockPos, + random::RandomSource, +}; use horizon_world::level::flags as level_flags; impl Game<'_> { @@ -106,11 +111,27 @@ impl Game<'_> { self.titles .set_overlay(Text::translate("record.nowPlaying", &[description]), true); self.update_song_volumes(); + self.notify_record_playing(pos, true); } fn stop_song(&mut self, pos: [i32; 3]) { if let Some(id) = self.jukebox_sounds.remove(&(pos[0], pos[1], pos[2])) { self.audio.stop_and_release(id); } + self.notify_record_playing(pos, false); + } + /// `LevelEventHandler.notifyNearbyEntities` (level events 1010 and 1011): + /// parrots within three blocks of the jukebox start or stop dancing. + pub(super) fn notify_record_playing(&mut self, pos: [i32; 3], playing: bool) { + let min = Vec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])); + let area = Aabb::new(min, min.add_vector(Vec3::new(1.0, 1.0, 1.0))) + .inflate(Vec3::new(3.0, 3.0, 3.0)); + for m in self + .mobs + .iter_mut() + .filter(|m| m.species() == Species::Parrot && m.bounds().intersects(area)) + { + m.extra.party_jukebox = playing.then_some(pos); + } } /// `popOutTheItem`: the disc above the jukebox, and the song stops. fn eject_record(&mut self, pos: [i32; 3]) { diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 6b1e16f5c..058ab7a09 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -46,6 +46,7 @@ pub mod monster_brain; pub mod nautilus; pub mod nav; pub mod nether; +pub mod parrot; pub mod path; pub mod phantom; pub mod piglin; @@ -667,6 +668,8 @@ pub struct Extra { pub items: Vec>, pub tame: bool, pub sitting: bool, + /// `Parrot.partyParrot` and `jukebox`: the playing jukebox it dances to. + pub party_jukebox: Option<[i32; 3]>, /// The owner's UUID (tamed animals). pub owner: Option<[i32; 4]>, /// Slime/magma cube size (0 = not sized). @@ -1260,6 +1263,8 @@ pub struct Seen { pub stats: [f64; 3], /// `Wolf.isInSittingPose`. pub sitting: bool, + /// `Entity.isSilent`. + pub silent: bool, /// `Entity.isVehicle` or `isPassenger`. pub ridden: bool, } @@ -1335,6 +1340,7 @@ impl Mob { m.attrs.speed, ], sitting: m.extra.sitting, + silent: m.silent, ridden: m.rider.is_some() || m.extra.rider.is_some() || m.extra.mount.is_some(), } } diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 2676c3a37..20e6dd615 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -581,6 +581,7 @@ fn play_ambient(m: &mut Mob, w: &MobWorld, events: &mut Vec) { "entity.wolf.pant" } } + Species::Parrot => super::parrot::ambient(m, w), Species::Cat if m.extra.tame && m.extra.in_love > 0 => "entity.cat.purr", Species::Cat if !m.extra.tame => "entity.cat.stray_ambient", Species::PolarBear if m.is_baby() => "entity.polar_bear.ambient_baby", @@ -632,6 +633,9 @@ fn play_ambient(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } /// LivingEntity.aiStep (and Mob/AgeableMob/Animal additions). fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &mut Vec) { + if m.species() == Species::Parrot { + super::parrot::ai_step(m, w, level_random, events); + } // Witch.aiStep runs before super.aiStep(). if m.species() == Species::Witch { let far = m diff --git a/crates/horizon-client/src/mobs/body_anim.rs b/crates/horizon-client/src/mobs/body_anim.rs index 4411d347b..75d71c110 100644 --- a/crates/horizon-client/src/mobs/body_anim.rs +++ b/crates/horizon-client/src/mobs/body_anim.rs @@ -980,7 +980,9 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool { Species::Parrot => { let flap = m.anim.flap_o + (m.anim.flap - m.anim.flap_o) * s.partial; let speed = m.anim.flap_speed_o + (m.anim.flap_speed - m.anim.flap_speed_o) * s.partial; - let pose = if m.extra.sitting { + let pose = if m.extra.party_jukebox.is_some() { + ParrotPose::Party + } else if m.extra.sitting { ParrotPose::Sitting } else if !m.on_ground && !m.fluids.in_water { ParrotPose::Flying diff --git a/crates/horizon-client/src/mobs/parrot.rs b/crates/horizon-client/src/mobs/parrot.rs new file mode 100644 index 000000000..c50176f7b --- /dev/null +++ b/crates/horizon-client/src/mobs/parrot.rs @@ -0,0 +1,138 @@ +//! What `Parrot.aiStep` adds: imitating the mobs around it (`imitateNearbyMobs`, +//! the ambient sound of `getAmbient`) and dancing near a playing jukebox. +use super::{Mob, MobEvent, MobWorld, Species}; +use horizon_core::{ + geometry::Vec3, + random::{LegacyRandom, RandomSource}, +}; + +/// `Parrot.MOB_SOUND_MAP` (the happy ghast's is `SoundEvents.EMPTY`: ""). +const IMITATIONS: [(Species, &str); 41] = [ + (Species::Blaze, "entity.parrot.imitate.blaze"), + (Species::Bogged, "entity.parrot.imitate.bogged"), + (Species::Breeze, "entity.parrot.imitate.breeze"), + (Species::CamelHusk, "entity.parrot.imitate.camel_husk"), + (Species::CaveSpider, "entity.parrot.imitate.spider"), + (Species::Creaking, "entity.parrot.imitate.creaking"), + (Species::Creeper, "entity.parrot.imitate.creeper"), + (Species::Drowned, "entity.parrot.imitate.drowned"), + ( + Species::ElderGuardian, + "entity.parrot.imitate.elder_guardian", + ), + (Species::Endermite, "entity.parrot.imitate.endermite"), + (Species::Evoker, "entity.parrot.imitate.evoker"), + (Species::Ghast, "entity.parrot.imitate.ghast"), + (Species::HappyGhast, ""), + (Species::Guardian, "entity.parrot.imitate.guardian"), + (Species::Hoglin, "entity.parrot.imitate.hoglin"), + (Species::Husk, "entity.parrot.imitate.husk"), + (Species::Illusioner, "entity.parrot.imitate.illusioner"), + (Species::MagmaCube, "entity.parrot.imitate.magma_cube"), + (Species::Parched, "entity.parrot.imitate.parched"), + (Species::Phantom, "entity.parrot.imitate.phantom"), + (Species::Piglin, "entity.parrot.imitate.piglin"), + (Species::PiglinBrute, "entity.parrot.imitate.piglin_brute"), + (Species::Pillager, "entity.parrot.imitate.pillager"), + (Species::Ravager, "entity.parrot.imitate.ravager"), + (Species::Shulker, "entity.parrot.imitate.shulker"), + (Species::Silverfish, "entity.parrot.imitate.silverfish"), + (Species::Skeleton, "entity.parrot.imitate.skeleton"), + (Species::Slime, "entity.parrot.imitate.slime"), + (Species::Spider, "entity.parrot.imitate.spider"), + (Species::Stray, "entity.parrot.imitate.stray"), + (Species::Vex, "entity.parrot.imitate.vex"), + (Species::Vindicator, "entity.parrot.imitate.vindicator"), + (Species::Warden, "entity.parrot.imitate.warden"), + (Species::Witch, "entity.parrot.imitate.witch"), + (Species::Wither, "entity.parrot.imitate.wither"), + ( + Species::WitherSkeleton, + "entity.parrot.imitate.wither_skeleton", + ), + (Species::Zoglin, "entity.parrot.imitate.zoglin"), + (Species::Zombie, "entity.parrot.imitate.zombie"), + (Species::ZombieHorse, "entity.parrot.imitate.zombie_horse"), + ( + Species::ZombieNautilus, + "entity.parrot.imitate.zombie_nautilus", + ), + ( + Species::ZombieVillager, + "entity.parrot.imitate.zombie_villager", + ), +]; + +fn imitation(species: Species) -> Option<&'static str> { + IMITATIONS.iter().find(|i| i.0 == species).map(|i| i.1) +} + +/// `Parrot.getPitch`. +fn pitch(random: &mut LegacyRandom) -> f32 { + (random.next_float() - random.next_float()) * 0.2 + 1.0 +} + +/// The start of `Parrot.aiStep`: a jukebox that is gone or farther than +/// 3.46 blocks stops the dance, and one tick in 400 the parrot imitates a +/// mob nearby. +pub fn ai_step( + m: &mut Mob, + w: &MobWorld, + level_random: &mut LegacyRandom, + events: &mut Vec, +) { + if let Some(at) = m.extra.party_jukebox { + let d = |i: usize, v: f64| f64::from(at[i]) + 0.5 - v; + let (x, y, z) = (d(0, m.position.x), d(1, m.position.y), d(2, m.position.z)); + let jukebox = &*w.facts.get(w.world.block(at[0], at[1], at[2])).name == "minecraft:jukebox"; + if x * x + y * y + z * z >= 3.46 * 3.46 || !jukebox { + m.extra.party_jukebox = None; + } + } + if level_random.next_int_bound(400).unwrap_or(1) == 0 { + imitate_nearby_mobs(m, w, level_random, events); + } +} + +/// `Parrot.imitateNearbyMobs`: half the time, a random imitable mob within 20 +/// blocks is heard through the parrot's own mouth. +fn imitate_nearby_mobs( + m: &Mob, + w: &MobWorld, + random: &mut LegacyRandom, + events: &mut Vec, +) { + if !m.alive() || m.silent || random.next_int_bound(2).unwrap_or(1) != 0 { + return; + } + let area = m.bounds().inflate(Vec3::new(20.0, 20.0, 20.0)); + let mobs: Vec<_> = w + .others + .iter() + .filter(|s| s.alive && imitation(s.species).is_some() && s.bounds.intersects(area)) + .collect(); + if mobs.is_empty() { + return; + } + let mob = mobs[random.next_int_bound(mobs.len() as i32).unwrap_or(0) as usize]; + if mob.silent { + return; + } + if let Some(sound) = imitation(mob.species).filter(|s| !s.is_empty()) { + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::Sound(sound, at, 0.7, pitch(random))); + } +} + +/// `Parrot.getAmbient`: now and then (outside peaceful) the voice of a random +/// imitable mob instead of the parrot's own. +pub fn ambient(m: &mut Mob, w: &MobWorld) -> &'static str { + if w.difficulty.effective > 0.0 && m.random.next_int_bound(1000).unwrap_or(1) == 0 { + let i = m + .random + .next_int_bound(IMITATIONS.len() as i32) + .unwrap_or(0); + return IMITATIONS[i as usize].1; + } + "entity.parrot.ambient" +} From 54b1c4f9415adc0bf42585e1e1d7c5022521cf83 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:51:03 +0100 Subject: [PATCH 39/84] Make climbing follow vanilla: no climbing while flying, open trapdoors over ladders climb --- crates/horizon-client/src/motion.rs | 54 +++++++++++++++++++++-------- 1 file changed, 40 insertions(+), 14 deletions(-) diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index fcdd32cbd..d96c07ff0 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -13,6 +13,7 @@ use horizon_world::{ attributes::{Modifier, Operation, entity::Catalog, live::LiveAttributes}, block_collision::BlockCollisionRegistry, block_landing::BlockLandingRegistry, + climbing::{self, ClimbingRegistry, ClimbingWorld}, collision_context::{CollisionContext, CollisionEntity, CollisionItem}, edge_backoff::{self, EdgeBackoffInput, EdgeBackoffWorld}, entity_move::{self, CollisionFlags, EntityMoveWorld, MovementHistory, MoverType}, @@ -50,6 +51,8 @@ pub struct MotionResources { pub attributes: Arc, pub blocks: BoundMovementProperties, pub climbable: BTreeSet, + /// `LivingEntity.onClimbable` tags plus open trapdoors above a ladder. + pub climbing: ClimbingRegistry<'static>, pub fall_reset: BTreeSet, pub landing: BlockLandingRegistry, pub health: crate::health::HealthResources, @@ -97,6 +100,12 @@ impl MotionResources { .cloned() .collect()) }; + let climbing = ClimbingRegistry::new( + assets.registry, + &tag("minecraft:trapdoors")?, + &tag("minecraft:climbable")?, + &tag("minecraft:can_glide_through")?, + )?; Ok(Self { landing: crate::landing::load(root, &properties)?, health: crate::health::HealthResources::load(root)?, @@ -108,6 +117,7 @@ impl MotionResources { suppresses_bounce: tag("minecraft:suppresses_bounce")?, })?, climbable: tag("minecraft:climbable")?, + climbing, fall_reset: tag("minecraft:fall_damage_resetting")?, }) } @@ -753,23 +763,15 @@ impl MotionWorld<'_, '_, '_> { supporting_block: self.player.ground.supporting_block, } } - /// `LivingEntity.onClimbable` at the player's feet (it remembers the block). + /// `Player.onClimbable` (never while flying) over `LivingEntity.onClimbable` + /// at the player's feet: the climbable tag or an open trapdoor above a + /// matching ladder. It remembers the block. pub fn climbable(&mut self) -> Result { - if self.player.spectator { + if self.player.flying { return Ok(false); } - let p = BlockPos::containing(self.player.position); - let name = &self - .assets - .registry - .state(self.block(p)) - .ok_or("missing scene state")? - .name; - let climbable = self.resources.climbable.contains(name); - if climbable { - self.player.last_climbable = Some(p); - } - Ok(climbable) + let resources = self.resources; + climbing::on_climbable(self, &resources.climbing).map_err(|e| e.to_string().into()) } pub fn travel_in_air(&mut self, input: Vec3) -> Result<()> { living_air::travel_in_air(self, input) @@ -1611,6 +1613,30 @@ impl MotionWorld<'_, '_, '_> { Ok(()) } } +impl ClimbingWorld for MotionWorld<'_, '_, '_> { + type Error = std::convert::Infallible; + fn is_spectator(&mut self) -> std::result::Result { + Ok(self.player.spectator) + } + fn block_position(&mut self) -> std::result::Result { + Ok(BlockPos::containing(self.player.position)) + } + fn in_block_state(&mut self) -> std::result::Result { + Ok(self.block(BlockPos::containing(self.player.position))) + } + fn is_fall_flying(&mut self) -> std::result::Result { + Ok(self.player.fall_flying) + } + fn block_state( + &mut self, + position: BlockPos, + ) -> std::result::Result { + Ok(self.block(position)) + } + fn set_last_climbable_position(&mut self, position: BlockPos) { + self.player.last_climbable = Some(position); + } +} impl crate::auto_jump::AutoJumpWorld for MotionWorld<'_, '_, '_> { type Error = Box; fn collision_shape(&mut self, p: BlockPos) -> Result { From 4575f4f1dffa435d615f02b1da7d33b725f7f552 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:51:18 +0100 Subject: [PATCH 40/84] Honour spawn-protection on a dedicated server Players who are not operators can no longer start digging or use an item on a block within the radius of the world spawn. They get the spawn protection message and the client gets the block back, like DedicatedServer.isUnderSpawnProtection. --- crates/horizon-client/src/game/dedicated.rs | 3 + crates/horizon-client/src/game/lan_actions.rs | 77 +++++++++++++++---- crates/horizon-client/src/lan/hub.rs | 4 + 3 files changed, 71 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs index fa5365195..07b07a27b 100644 --- a/crates/horizon-client/src/game/dedicated.rs +++ b/crates/horizon-client/src/game/dedicated.rs @@ -644,6 +644,9 @@ impl Game<'_> { return Ok(()); } self.sync_ops(&lists); + if let Some(host) = self.lan.as_mut() { + host.hub.spawn_protection = props.spawn_protection; + } log( "INFO", &format!( diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 43bb573dc..0430b9013 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -926,6 +926,45 @@ impl Game<'_> { d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < range * range } + /// DedicatedServer.isUnderSpawnProtection: no operators, an operator or a + /// radius of 0 or less is never under it; else a block within the radius + /// of the world spawn (square, in the Overworld) is. + fn under_spawn_protection(&self, host: &LanHost, gi: usize, pos: [i32; 3]) -> bool { + let g = &host.hub.guests[gi]; + let radius = host.hub.spawn_protection; + if self.options.dedicated.is_none() || radius <= 0 || g.dimension != "minecraft:overworld" { + return false; + } + let Some(spawn) = self.level.world_spawn else { + return false; + }; + if host.hub.ops.is_empty() || host.hub.ops.contains_key(&g.uuid) { + return false; + } + let dx = pos[0].abs_diff(spawn[0]); + let dz = pos[2].abs_diff(spawn[2]); + dx.max(dz) <= radius as u32 + } + + /// ServerPlayer.sendSpawnProtectionMessage. + fn spawn_protection_message(&self, host: &LanHost, conn: u32, pos: [i32; 3]) { + let message = horizon_client::text::Text::translate( + "build.spawn_protection", + &[horizon_client::text::Text::literal(format!( + "{}, {}, {}", + pos[0], pos[1], pos[2] + ))], + ) + .with_color(horizon_client::text::RED); + host.hub.send_to( + conn, + &C::SystemChat(play::SystemChat { + content: horizon_client::lan::data::component_nbt(&message.component()), + overlay: true, + }), + ); + } + /// A packet from a guest that the hub does not handle itself. pub(super) fn lan_guest_packet(&mut self, host: &mut LanHost, conn: u32, packet: S) { let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else { @@ -950,6 +989,12 @@ impl Game<'_> { if spectator { return; } + // ServerPlayerGameMode.handleBlockBreakAction: no dig starts + // under spawn protection (the ack puts the block back). + if self.under_spawn_protection(host, gi, a.pos) { + self.spawn_protection_message(host, conn, a.pos); + return; + } let face = direction(i32::from(a.direction)); let play = host.play.entry(conn).or_default(); play.digging = Some((a.pos, face)); @@ -1063,19 +1108,25 @@ impl Game<'_> { ], }; let hand = if p.hand == 1 { Hand::Off } else { Hand::Main }; - let logged = self.world.block_log.as_ref().map_or(0, Vec::len); - let heard = self.audio.capture.as_ref().map_or(0, Vec::len); - let swung = self.as_guest(host, conn, |g| { - g.forced_hit = Some(hit); - g.guest_use = Some(GuestUse::OnBlock(hand)); - let swings = g.swings_started; - let _ = g.use_item(); - g.forced_hit = None; - g.guest_use = None; - g.swings_started != swings - }); - self.lan_swing_back(host, conn, swung); - self.guest_use_sounds(host, conn, logged, heard); + // handleUseItemOn: under spawn protection nothing is used or + // placed; the player is told and the blocks below go back. + if self.under_spawn_protection(host, gi, p.pos) { + self.spawn_protection_message(host, conn, p.pos); + } else { + let logged = self.world.block_log.as_ref().map_or(0, Vec::len); + let heard = self.audio.capture.as_ref().map_or(0, Vec::len); + let swung = self.as_guest(host, conn, |g| { + g.forced_hit = Some(hit); + g.guest_use = Some(GuestUse::OnBlock(hand)); + let swings = g.swings_started; + let _ = g.use_item(); + g.forced_hit = None; + g.guest_use = None; + g.swings_started != swings + }); + self.lan_swing_back(host, conn, swung); + self.guest_use_sounds(host, conn, logged, heard); + } // The client predicted a result: correct it with what really is. for pos in [ p.pos, diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index b1a8cbc62..f2a8edfff 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -168,6 +168,9 @@ pub struct Hub { level_sync: std::collections::HashMap, /// Operators and their permission levels (dedicated servers). pub ops: std::collections::HashMap, + /// `spawn-protection` (dedicated servers): the radius around the world + /// spawn that only operators may change. + pub spawn_protection: i32, chat_type: i32, dimension_type: i32, clock_ids: Vec, @@ -332,6 +335,7 @@ impl Hub { ticking: (20.0, false), stepping: 0, ops: Default::default(), + spawn_protection: 0, weather: (false, 0.0, 0.0), level_sync: Default::default(), chat_type, From 2d72e987c59db0d610cc30a3ae69b61790d3d1be Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:53:15 +0100 Subject: [PATCH 41/84] Play ambient sounds and spawn fireflies around firefly bushes, eyeblossoms, pale moss and dry plants --- .../examples/probe/marker_particles_probe.rs | 3 + crates/horizon-client/src/animate_tick.rs | 146 +++++++++++++++++- crates/horizon-client/src/game/render_tick.rs | 22 ++- 3 files changed, 169 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/examples/probe/marker_particles_probe.rs b/crates/horizon-client/examples/probe/marker_particles_probe.rs index 72ebaff22..aec1ccff6 100644 --- a/crates/horizon-client/examples/probe/marker_particles_probe.rs +++ b/crates/horizon-client/examples/probe/marker_particles_probe.rs @@ -74,6 +74,9 @@ pub fn main() -> Result<()> { biomes: &biomes, registry: assets.registry, raining_at: &|_| false, + height_no_leaves: &|_| 0, + firefly_bush_sounds: false, + sky_darken: 0, marker: target.map(|name| (name, &options as &dyn Fn(_) -> _)), }; engine.seed_randoms(1057, 0, 0); diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs index 28b28544b..7d3d2ca6c 100644 --- a/crates/horizon-client/src/animate_tick.rs +++ b/crates/horizon-client/src/animate_tick.rs @@ -70,6 +70,14 @@ enum Animate { waterlogged: bool, }, EndPortal, + FireflyBush, + /// An open eyeblossom (`Type.OPEN.emitSounds()`). + OpenEyeblossom, + PaleHangingMoss, + /// `DryVegetationBlock`: a dead bush. + DeadBush, + /// `ShortDryGrassBlock` and `TallDryGrassBlock`. + DryGrass, } fn step(facing: &str) -> [i32; 3] { match facing { @@ -149,6 +157,11 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { waterlogged: prop("waterlogged").as_deref() == Some("true"), }, "end_portal" => Animate::EndPortal, + "firefly_bush" => Animate::FireflyBush, + "open_eyeblossom" => Animate::OpenEyeblossom, + "pale_hanging_moss" => Animate::PaleHangingMoss, + "dead_bush" => Animate::DeadBush, + "short_dry_grass" | "tall_dry_grass" => Animate::DryGrass, "sculk_sensor" | "calibrated_sculk_sensor" if prop("sculk_sensor_phase").as_deref() == Some("active") => { @@ -194,6 +207,10 @@ pub struct AnimateTables { power_transmitter: Vec, /// `#triggers_ambient_dried_ghast_block_sounds` (soul sand, soul soil). dried_ghast_sounds: Vec, + /// `#triggers_ambient_desert_dry_vegetation_block_sounds`. + desert_dry_vegetation_sounds: Vec, + terracotta: Vec, + pale_oak_logs: Vec, /// `FireBlock.canBurn`: states with ignite odds above zero (none waterlogged). burnable: Vec, /// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`). @@ -269,6 +286,11 @@ impl AnimateTables { power_provider: by_state("minecraft:enchantment_power_provider"), power_transmitter: by_state("minecraft:enchantment_power_transmitter"), dried_ghast_sounds: by_state("minecraft:triggers_ambient_dried_ghast_block_sounds"), + desert_dry_vegetation_sounds: by_state( + "minecraft:triggers_ambient_desert_dry_vegetation_block_sounds", + ), + terracotta: by_state("minecraft:terracotta"), + pale_oak_logs: by_state("minecraft:pale_oak_logs"), burnable, ambient, }) @@ -294,6 +316,12 @@ pub struct AnimateContext<'a> { pub registry: &'a BlockRegistry, /// `Level.isRainingAt`. pub raining_at: &'a dyn Fn([i32; 3]) -> bool, + /// `getHeight(MOTION_BLOCKING_NO_LEAVES, x, z)` at a position's column. + pub height_no_leaves: &'a dyn Fn([i32; 3]) -> i32, + /// `EnvironmentAttributes.FIREFLY_BUSH_SOUNDS` (overworld day timeline). + pub firefly_bush_sounds: bool, + /// `Level.getSkyDarken`, for `getMaxLocalRawBrightness`. + pub sky_darken: i32, /// Creative main-hand marker block and a resolver for each placed state's sprite. pub marker: Option<(&'a str, &'a dyn Fn(BlockStateId) -> Option)>, } @@ -344,6 +372,12 @@ impl AnimateContext<'_> { ], )) } + /// `Level.getMaxLocalRawBrightness`: the brighter of block light and + /// sky light less the sky darkening. + fn max_local_raw_brightness(&self, p: [i32; 3]) -> i32 { + let light = self.world.light(p[0], p[1], p[2]); + i32::from(light & 15).max(i32::from(light >> 4) - self.sky_darken) + } fn foliage(&self, p: [i32; 3]) -> u32 { let biome = self .world @@ -395,7 +429,7 @@ fn do_animate_tick( return; } let state = ctx.state(pos); - block_animate_tick(tables, engine, ctx, state, pos); + block_animate_tick(tables, engine, ctx, state, pos, center); let facts = ctx.facts.get(state); if facts.fluid != Fluid::None { fluid_animate_tick( @@ -504,6 +538,22 @@ fn try_spawn_drip( } } } +/// `AmbientDesertBlockSoundsPlayer.shouldPlayDesertDryVegetationBlockSounds`: +/// sand or terracotta two blocks deep. +fn desert_dry_vegetation_sounds( + tables: &AnimateTables, + ctx: &AnimateContext, + below: [i32; 3], +) -> bool { + let triggers = |p: [i32; 3]| { + tables + .desert_dry_vegetation_sounds + .get(ctx.state(p).0 as usize) + .copied() + .unwrap_or(false) + }; + triggers(below) && triggers([below[0], below[1] - 1, below[2]]) +} /// `WaterFluid.animateTick` / `LavaFluid.animateTick`. fn fluid_animate_tick( engine: &mut ParticleEngine, @@ -579,6 +629,7 @@ fn block_animate_tick( ctx: &AnimateContext, state: BlockStateId, pos: [i32; 3], + player: [i32; 3], ) { let (fx, fy, fz) = (f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])); match tables.kind(state) { @@ -935,6 +986,99 @@ fn block_animate_tick( } } } + Animate::FireflyBush => { + // FireflyBushBlock.animateTick: the idle sound on a quiet night + // under open sky, and fireflies in the dark within 5 blocks. + if next_int(engine.random(), 30) == 0 + && ctx.firefly_bush_sounds + && (ctx.height_no_leaves)(pos) <= pos[1] + { + let name = "minecraft:block.firefly_bush.idle"; + sound(engine, name, [fx, fy, fz], 1.0, 1.0); + } + if ctx.max_local_raw_brightness(pos) <= 13 { + let r = engine.random(); + if r.next_double() <= 0.7 { + let p = [ + fx + r.next_double() * 10.0 - 5.0, + fy + r.next_double() * 5.0, + fz + r.next_double() * 10.0 - 5.0, + ]; + add(engine, T::Firefly, p, [0.0; 3]); + } + } + } + Animate::OpenEyeblossom => { + // EyeblossomBlock.animateTick: pale moss below. + if next_int(engine.random(), 700) == 0 { + let below = ctx.state([pos[0], pos[1] - 1, pos[2]]); + if ctx + .registry + .state(below) + .is_some_and(|s| s.name == "minecraft:pale_moss_block") + { + let name = "minecraft:block.eyeblossom.idle"; + sound(engine, name, [fx, fy, fz], 1.0, 1.0); + } + } + } + Animate::PaleHangingMoss => { + // HangingMossBlock.animateTick: under pale oak logs or leaves. + if next_int(engine.random(), 500) == 0 { + let above = ctx.state([pos[0], pos[1] + 1, pos[2]]); + let pale_leaves = ctx + .registry + .state(above) + .is_some_and(|s| s.name == "minecraft:pale_oak_leaves"); + if pale_leaves + || tables + .pale_oak_logs + .get(above.0 as usize) + .copied() + .unwrap_or(false) + { + let name = "minecraft:block.pale_hanging_moss.idle"; + sound(engine, name, [fx, fy, fz], 1.0, 1.0); + } + } + } + Animate::DeadBush => { + // AmbientDesertBlockSoundsPlayer.playAmbientDeadBushSounds. + if next_int(engine.random(), 130) == 0 { + let below = [pos[0], pos[1] - 1, pos[2]]; + let state = ctx.state(below); + let red_sand = ctx + .registry + .state(state) + .is_some_and(|s| s.name == "minecraft:red_sand"); + let terracotta = tables + .terracotta + .get(state.0 as usize) + .copied() + .unwrap_or(false); + if (red_sand || terracotta) && next_int(engine.random(), 3) != 0 { + return; + } + if desert_dry_vegetation_sounds(tables, ctx, below) { + let name = "minecraft:block.deadbush.idle"; + sound(engine, name, [fx, fy, fz], 1.0, 1.0); + } + } + } + Animate::DryGrass => { + // AmbientDesertBlockSoundsPlayer.playAmbientDryGrassSounds: + // played at the player. + if next_int(engine.random(), 200) == 0 + && desert_dry_vegetation_sounds(tables, ctx, [pos[0], pos[1] - 1, pos[2]]) + { + let at = [ + f64::from(player[0]) + 0.5, + f64::from(player[1]), + f64::from(player[2]) + 0.5, + ]; + sound(engine, "minecraft:block.dry_grass.ambient", at, 1.0, 1.0); + } + } Animate::EndPortal => { // EndPortalBlock.animateTick: one smoke particle above the surface. let r = engine.random(); diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index e013c8d29..d106e32ad 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -18,10 +18,22 @@ use horizon_core::random::{LegacyRandom, RandomSource}; /// The first motion-blocking block at or below `from` (Heightmap MOTION_BLOCKING), plus one. fn motion_blocking(world: &World, facts: &BlockFacts, x: i32, z: i32, from: i32) -> i32 { + motion_blocking_leaves(world, facts, x, z, from, true) +} +/// `motion_blocking` where leaves count only for MOTION_BLOCKING, not for +/// MOTION_BLOCKING_NO_LEAVES. +fn motion_blocking_leaves( + world: &World, + facts: &BlockFacts, + x: i32, + z: i32, + from: i32, + leaves: bool, +) -> i32 { let mut y = from.min(MIN_Y + HEIGHT - 1); while y > MIN_Y { let f = facts.get(world.block(x, y, z)); - if f.full_collision || f.fluid != Fluid::None || f.name.contains("leaves") { + if f.full_collision || f.fluid != Fluid::None || leaves && f.name.contains("leaves") { return y + 1; } y -= 1; @@ -271,6 +283,11 @@ impl Game<'_> { && motion_blocking(world, facts, p[0], p[2], p[1] + 64) <= p[1] && rains_at(world, biomes, p[0], p[1], p[2]) }; + let height_no_leaves = + |p: [i32; 3]| motion_blocking_leaves(world, facts, p[0], p[2], i32::MAX, false); + // The day timeline: firefly bush sounds from 12600 to 23400. + let firefly_bush_sounds = self.dim == Dim::Overworld + && (12600..23401).contains(&self.world.day_time.rem_euclid(24000)); let ctx = AnimateContext { world, facts, @@ -278,6 +295,9 @@ impl Game<'_> { biomes, registry: self.pack.assets.registry, raining_at: &raining_at, + height_no_leaves: &height_no_leaves, + firefly_bush_sounds, + sky_darken: self.sky_darken(), marker: marker.map(|name| (name, &marker_options as &dyn Fn(_) -> _)), }; if let Some(e) = eye { From fbdd04d8172a884dd281cdf8897a12744eff2976 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 19:58:03 +0100 Subject: [PATCH 42/84] Use armor stand, boat, cart and item eye heights for facing entity eyes --- crates/horizon-client/src/entities.rs | 11 +++++++++++ crates/horizon-client/src/game/commands/execute.rs | 12 ++++++++++++ 2 files changed, 23 insertions(+) diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs index 69e053411..3a23a6c32 100644 --- a/crates/horizon-client/src/entities.rs +++ b/crates/horizon-client/src/entities.rs @@ -713,6 +713,17 @@ pub struct ArmorStand { } impl ArmorStand { pub const SLOTS: [&'static str; 6] = ["mainhand", "offhand", "feet", "legs", "chest", "head"]; + /// The eye height of `getDimensionsMarker`: none for a marker, halved + /// (with `BABY_DIMENSIONS`' 0.9875) when small. + pub fn eye_height(&self) -> f64 { + if self.marker { + 0.0 + } else if self.small { + f64::from(0.9875f32) + } else { + f64::from(1.7775f32) + } + } pub fn new(id: u32, position: Vec3, yaw: f32) -> Self { Self { fire_ticks: 0, diff --git a/crates/horizon-client/src/game/commands/execute.rs b/crates/horizon-client/src/game/commands/execute.rs index 3f7e4c2a0..cda51eabb 100644 --- a/crates/horizon-client/src/game/commands/execute.rs +++ b/crates/horizon-client/src/game/commands/execute.rs @@ -145,6 +145,18 @@ impl Game<'_> { .iter() .find(|m| m.id == id) .map_or(0.0, |m| m.eye_y() - m.position.y), + Target::Stand(id) => self + .armor_stands + .iter() + .find(|a| a.id == id) + .map_or(0.0, |a| a.eye_height()), + // EntityType eyeHeight: boats 0.5625, items 0.2125; the rest keep + // the default of 0.85 of the height (minecarts 0.7, experience + // orbs and paintings 0.5), item frames 0. + Target::Boat(_) => f64::from(0.5625f32), + Target::Item(_) => f64::from(0.2125f32), + Target::Cart(_) => f64::from(0.7f32 * 0.85), + Target::Orb(_) | Target::Painting(_) => f64::from(0.5f32 * 0.85), _ => 0.0, } } From d97b58fd4a836bd2ba0d5cc4a842c4ef431b3f8a Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:15:49 +0100 Subject: [PATCH 43/84] Send the thrower's entity id with a tracked trident --- crates/horizon-client/src/game/lan_entities.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index 529666590..3c5b11988 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -386,6 +386,9 @@ impl Game<'_> { let mut e = state(t.id, "minecraft:trident", at(t.position), t.yaw, false); e.pitch = t.pitch; e.velocity = at(t.velocity); + // Projectile.getAddEntityPacket: the owner's id; a trident here is + // always the host player's. + e.data = owner(Some(horizon_client::mobs::Who::Player)); e.meta = arrow_meta(false, t.no_physics, 0, t.in_ground); // ThrownTrident.ID_LOYALTY and ID_FOIL. if t.loyalty != 0 { From d0df2389726563ee5d65efb184108c60f2de0df8 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:19:49 +0100 Subject: [PATCH 44/84] Include equipment modifiers in a mob's knockback resistance for the sonic boom push --- crates/horizon-client/src/game/creatures.rs | 2 +- .../horizon-client/src/game/lan_attributes.rs | 31 +++++++++++++++++++ crates/horizon-client/src/mobs/finalize.rs | 11 +++++-- 3 files changed, 40 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index c7b033c03..b7fb75fb4 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -993,7 +993,7 @@ impl Game<'_> { .mobs .iter() .find(|m| m.id == id) - .map_or(0.0, |m| m.attrs.knockback_resistance); + .map_or(0.0, |m| self.mob_knockback_resistance(m)); (hurt, resistance) } }; diff --git a/crates/horizon-client/src/game/lan_attributes.rs b/crates/horizon-client/src/game/lan_attributes.rs index 73942e770..9909c88f6 100644 --- a/crates/horizon-client/src/game/lan_attributes.rs +++ b/crates/horizon-client/src/game/lan_attributes.rs @@ -24,6 +24,37 @@ fn slot_in_group(group: &str, slot: &str) -> bool { } impl Game<'_> { + /// `getAttributeValue(KNOCKBACK_RESISTANCE)` of a mob: its own value plus + /// the modifiers of the items it wears or holds in matching slots. + pub(super) fn mob_knockback_resistance(&self, m: &Mob) -> f64 { + let e = &m.extra; + let slots = [ + ("mainhand", &e.main_hand), + ("offhand", &e.off_hand), + ("feet", &e.feet), + ("legs", &e.legs), + ("chest", &e.chest), + ("head", &e.head), + ]; + let mut extra = Vec::new(); + for (slot, item) in slots { + let Some(info) = item.as_ref().and_then(|i| self.res.items().get(i)) else { + continue; + }; + for (attribute, _, amount, op, group) in &info.modifiers { + if attribute == "minecraft:knockback_resistance" && slot_in_group(group, slot) { + let op = match operation_named(op) { + 1 => Op::AddMultipliedBase, + 2 => Op::AddMultipliedTotal, + _ => Op::AddValue, + }; + extra.push((*amount, op)); + } + } + } + finalize::value_with(m, Attr::KnockbackResistance, &extra) + } + /// The registry id of a client-syncable attribute the entity type has /// (`AttributeMap.getInstance` is null for the others), by name. fn synced_attribute(&self, entity: &str, name: &str) -> Option { diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs index 4eeed885b..be1ff952a 100644 --- a/crates/horizon-client/src/mobs/finalize.rs +++ b/crates/horizon-client/src/mobs/finalize.rs @@ -516,9 +516,13 @@ fn effect_modifiers(m: &Mob, a: Attr) -> impl Iterator + '_ { } /// `AttributeInstance.getValue`: the base, then the modifiers by operation. pub fn value(m: &Mob, a: Attr) -> f64 { - compute(m, a, true) + compute(m, a, true, &[]) } -fn compute(m: &Mob, a: Attr, with_transient: bool) -> f64 { +/// `value` with more modifiers, such as the ones worn equipment grants. +pub fn value_with(m: &Mob, a: Attr, extra: &[(f64, Op)]) -> f64 { + compute(m, a, true, extra) +} +fn compute(m: &Mob, a: Attr, with_transient: bool, extra: &[(f64, Op)]) -> f64 { let mut base = base_value(m, a); let empty = Vec::new(); let mods = m.extra.attributes.as_ref().map_or(&empty, |s| &s.modifiers); @@ -531,6 +535,7 @@ fn compute(m: &Mob, a: Attr, with_transient: bool) -> f64 { ops.extend(transient(m, a)); ops.extend(effect_modifiers(m, a)); } + ops.extend(extra.iter().copied()); for (amount, op) in &ops { if *op == Op::AddValue { base += amount; @@ -573,7 +578,7 @@ fn refresh(m: &mut Mob, a: Attr) { /// The value without the transient baby modifier (`speed_bonus` applies /// that one to movement speed). fn base_with_modifiers(m: &Mob, a: Attr) -> f64 { - compute(m, a, false) + compute(m, a, false, &[]) } /// `AttributeInstance.setBaseValue`. pub fn set_base(m: &mut Mob, a: Attr, v: f64) { From 2d70e55fbbffeb5c8b7105ca970a22d195332ef5 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:21:42 +0100 Subject: [PATCH 45/84] Load the respawn search's candidate chunks instead of skipping unloaded ones --- crates/horizon-client/src/game.rs | 18 ++++- crates/horizon-client/src/game/end.rs | 33 +++++++-- .../horizon-client/src/game/initial_spawn.rs | 73 +++++++++---------- .../horizon-client/src/game/server_travel.rs | 34 +++++++-- 4 files changed, 106 insertions(+), 52 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 2d853cbe5..e6abe53b4 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1366,6 +1366,9 @@ struct Game<'a> { spawn_spiral: horizon_client::world_spawn::ChunkSpiral, /// A new player's spawn search, while its candidates' chunks load. player_spawn: Option, + /// Chunks a respawn search waits for this tick, kept loading beside the + /// player's own (taken by `update_world`). + spawn_wait: Vec<(i32, i32)>, mobs: Vec, creatures: creatures::Creatures, sculk: sculk::SculkState, @@ -4256,8 +4259,12 @@ impl Game<'_> { let column = [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32]; if self.level.world_spawn == Some(column) { // TeleportTransition.missingRespawnBlock: PlayerSpawnFinder - // around the world spawn, not its exact column. - self.respawn_spawn(column) + // around the world spawn, not its exact column; its candidates' + // chunks load first. + let Some(feet) = self.find_player_spawn(column)? else { + return Ok(()); + }; + feet } else { // A spawnpoint: the stored column, lifted onto its current surface. let y = self @@ -11137,8 +11144,14 @@ impl Game<'_> { self.streaming.loading = self.options.execution_role.is_client() && self.loading_reason().is_some(); self.tick_pregen(); + let areas = self.streaming.extra.len(); + let waiting = std::mem::take(&mut self.spawn_wait); + self.streaming + .extra + .extend(waiting.into_iter().map(|chunk| (chunk, 0))); let (uploads, unloaded) = horizon_client::spans::time("streaming", || self.streaming.update(&mut self.world)); + self.streaming.extra.truncate(areas); if let Some(lod) = &mut self.lod { self.lod_observe .extend(uploads.iter().map(|(key, _)| (key.0, key.2))); @@ -12426,6 +12439,7 @@ impl<'a> Game<'a> { spawn_origin: None, spawn_spiral: Default::default(), player_spawn: None, + spawn_wait: Vec::new(), mobs: Vec::new(), creatures: Default::default(), sculk: Default::default(), diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index f11d4a61c..cffe3aa4b 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -11,6 +11,7 @@ use horizon_client::{ motion::PlayerMotion, particles::{ParticleOptions, ParticleType}, vanillagen::VanillaTerrain, + world_spawn::PlayerSpawnFinder, }; use horizon_core::{ geometry::Vec3, @@ -521,7 +522,15 @@ impl Game<'_> { let position = if let Some(job) = self.end.job.take() { self.resolve_gateway(job, target)? } else { - let (position, yaw) = self.end_arrival(target)?; + let mut finder = self.player_spawn.take(); + let arrival = self.end_arrival(target, &mut finder); + self.player_spawn = finder; + let Some((position, yaw)) = arrival? else { + // A spawn candidate's chunk is loading: try again next tick. + self.travelling = Some((player, target)); + self.end_travel = true; + return Ok(()); + }; if let Some(yaw) = yaw { self.yaw = yaw; player.yaw = yaw; @@ -546,7 +555,13 @@ impl Game<'_> { /// Where an End portal's traveller lands once `target` has loaded, and /// the yaw it faces there: the platform below the End's spawn point, /// facing west, or the top of the Overworld's spawn column. - pub(super) fn end_arrival(&mut self, target: Vec3) -> Result<(Vec3, Option)> { + /// None while a candidate of the world spawn's search loads (`finder` + /// keeps it, see `search_spawn`). + pub(super) fn end_arrival( + &mut self, + target: Vec3, + finder: &mut Option, + ) -> Result)>> { if self.dim == Dim::End { // EndPlatformFeature.createEndPlatform below the spawn point. let origin = [END_SPAWN[0], END_SPAWN[1] - 1, END_SPAWN[2]]; @@ -566,14 +581,14 @@ impl Game<'_> { } } // Direction.WEST.toYRot(). - return Ok((target, Some(90.0))); + return Ok(Some((target, Some(90.0)))); } // ServerPlayer.findRespawnPositionAndUseSpawnBlock: where the bed or // anchor puts the player, facing it; else onto the spawn column. let mut target = target; if let Some(c) = self.respawn_config.filter(|c| c.dim == self.dim) { if let Some((at, yaw)) = self.find_respawn_and_use(c, false)? { - return Ok((at, Some(yaw))); + return Ok(Some((at, Some(yaw)))); } let s = self.level.spawn.unwrap_or([0.0, 64.0, 0.0]); target = Vec3::new(s[0].floor() + 0.5, s[1], s[2].floor() + 0.5); @@ -582,10 +597,16 @@ impl Game<'_> { // TeleportTransition.missingRespawnBlock: PlayerSpawnFinder around // the world spawn. if let Some(world) = self.level.world_spawn.filter(|w| w[0] == x && w[2] == z) { - return Ok((self.respawn_spawn(world), None)); + return Ok(match self.search_spawn(world, finder) { + Ok(at) => Some((at, None)), + Err(chunk) => { + self.spawn_wait.push(chunk); + None + } + }); } let y = self.land_column(x, z).map_or(target.y, f64::from); - Ok((Vec3::new(target.x, y, target.z), None)) + Ok(Some((Vec3::new(target.x, y, target.z), None))) } /// Dying away from the Overworld respawns at the world spawn there. diff --git a/crates/horizon-client/src/game/initial_spawn.rs b/crates/horizon-client/src/game/initial_spawn.rs index bcea90337..d4c48c140 100644 --- a/crates/horizon-client/src/game/initial_spawn.rs +++ b/crates/horizon-client/src/game/initial_spawn.rs @@ -145,61 +145,58 @@ impl Game<'_> { entity_random().next_int_bound(n).unwrap_or(0) }) } - /// PlayerSpawnFinder.findSpawn around the world spawn for a player placed - /// at once (TeleportTransition.createDefault and missingRespawnBlock): the - /// first free column within the respawn radius, the suggestion's own - /// column when none is. A candidate whose chunk is not loaded counts as - /// not free; the suggestion's chunk must be. - pub(super) fn respawn_spawn(&self, suggestion: [i32; 3]) -> Vec3 { - let mut finder = self.spawn_finder(suggestion); - while let Some(candidate) = finder.next_candidate() { - let SpawnCandidate::Column(x, z) = candidate else { - break; - }; - if !self.streaming.is_lit(x >> 4, z >> 4) { - continue; - } - if let Some(pos) = level_respawn_pos(&self.spawn_columns(), x, z) - && self.player_fits(pos) - { - return bottom_center(pos); - } - } - self.fixup_spawn_height(suggestion) - } - /// PlayerSpawnFinder.findSpawn around the world spawn: the feet of a - /// player who has no position yet. None while a candidate's chunk loads. - pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result> { - let mut finder = match self.player_spawn { - Some(finder) => finder, - None => self.spawn_finder(suggestion), - }; - let found = loop { + /// PlayerSpawnFinder.findSpawn around the world spawn, as far as the loaded + /// chunks allow: the feet of the first free column within the respawn + /// radius, else the suggestion's own column. The finder waits in `state` + /// (None to begin); Err gives the chunk of the candidate being waited for, + /// which the caller must have loaded (the finder tries at most 1024 + /// columns). + pub(super) fn search_spawn( + &self, + suggestion: [i32; 3], + state: &mut Option, + ) -> std::result::Result { + let mut finder = state + .take() + .unwrap_or_else(|| self.spawn_finder(suggestion)); + let suggestion = finder.suggestion; + loop { let Some(candidate) = finder.next_candidate() else { - break Some(self.fixup_spawn_height(suggestion)); + return Ok(self.fixup_spawn_height(suggestion)); }; let (x, z) = match candidate { SpawnCandidate::Column(x, z) => (x, z), SpawnCandidate::Suggestion => (suggestion[0], suggestion[2]), }; if !self.streaming.is_lit(x >> 4, z >> 4) { - self.streaming.center = (x >> 4, z >> 4); finder.retry(); - break None; + *state = Some(finder); + return Err((x >> 4, z >> 4)); } match candidate { SpawnCandidate::Column(x, z) => { if let Some(pos) = level_respawn_pos(&self.spawn_columns(), x, z) && self.player_fits(pos) { - break Some(bottom_center(pos)); + return Ok(bottom_center(pos)); } } - SpawnCandidate::Suggestion => break Some(self.fixup_spawn_height(suggestion)), + SpawnCandidate::Suggestion => return Ok(self.fixup_spawn_height(suggestion)), } - }; - self.player_spawn = found.is_none().then_some(finder); - Ok(found) + } + } + /// PlayerSpawnFinder.findSpawn around the world spawn: the feet of a + /// player who has no position yet. None while a candidate's chunk loads. + pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result> { + let mut state = self.player_spawn.take(); + match self.search_spawn(suggestion, &mut state) { + Ok(feet) => Ok(Some(feet)), + Err(chunk) => { + self.streaming.center = chunk; + self.player_spawn = state; + Ok(None) + } + } } /// PlayerSpawnFinder.noCollisionNoLiquid: a player's box standing at the /// block's bottom centre touches no block or liquid. diff --git a/crates/horizon-client/src/game/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs index e22cd60e9..ac983dff1 100644 --- a/crates/horizon-client/src/game/server_travel.rs +++ b/crates/horizon-client/src/game/server_travel.rs @@ -11,7 +11,7 @@ use super::end::GatewayJob; use super::nether_portal::{PLAYER_DELAY, Plan}; use super::respawn_anchor::RespawnConfig; use super::{Dim, Game, lan::LanHost}; -use horizon_client::{lan::hub::TickCtx, text::Text}; +use horizon_client::{lan::hub::TickCtx, text::Text, world_spawn::PlayerSpawnFinder}; use horizon_core::{geometry::Vec3, position::BlockPos}; use horizon_protocol::packets::play::{self, Clientbound as C}; @@ -34,6 +34,8 @@ pub(super) struct Trip { /// A respawn at the world spawn, moved onto a free column within the /// respawn radius once the chunks around it have loaded. world_spawn: bool, + /// The search for that column while a candidate's chunk loads. + finder: Option, /// Sent by a command: the player is already where it goes. placed: bool, } @@ -258,6 +260,7 @@ impl Game<'_> { gateway: None, respawn: None, world_spawn: false, + finder: None, placed: false, }); if let Err(e) = self.enter_level(Some(host), source) { @@ -278,6 +281,7 @@ impl Game<'_> { gateway: None, respawn: Some(config), world_spawn: false, + finder: None, placed: false, }); } @@ -327,6 +331,7 @@ impl Game<'_> { gateway: None, respawn: None, world_spawn: true, + finder: None, placed: false, }); } @@ -372,6 +377,7 @@ impl Game<'_> { gateway: Some(job), respawn: None, world_spawn: false, + finder: None, placed: false, }); } @@ -398,7 +404,7 @@ impl Game<'_> { k += 1; continue; } - let trip = self.server_trips.remove(k); + let mut trip = self.server_trips.remove(k); if trip.placed { continue; } @@ -416,7 +422,15 @@ impl Game<'_> { // PlayerSpawnFinder.findSpawn around the world spawn. let suggestion = [trip.target.x, trip.target.y, trip.target.z].map(|v| v.floor() as i32); - (self.respawn_spawn(suggestion), yaw) + match self.search_spawn(suggestion, &mut trip.finder) { + Ok(at) => (at, yaw), + Err(chunk) => { + self.spawn_wait.push(chunk); + self.server_trips.insert(k, trip); + k += 1; + continue; + } + } } else if let Some(job) = trip.gateway { match self.resolve_gateway(job, trip.target) { Ok(at) => (at, yaw), @@ -426,12 +440,19 @@ impl Game<'_> { } } } else if trip.end { - let arrival = match self.as_guest(host, trip.conn, |g| g.end_arrival(trip.target)) { + let arrival = match self.as_guest(host, trip.conn, |g| { + g.end_arrival(trip.target, &mut trip.finder) + }) { Some(arrival) => arrival, - None => self.end_arrival(trip.target), + None => self.end_arrival(trip.target, &mut trip.finder), }; match arrival { - Ok((at, turned)) => (at, turned.unwrap_or(yaw)), + Ok(Some((at, turned))) => (at, turned.unwrap_or(yaw)), + Ok(None) => { + self.server_trips.insert(k, trip); + k += 1; + continue; + } Err(e) => { log::error!("End arrival: {e}"); (trip.target, yaw) @@ -493,6 +514,7 @@ impl Game<'_> { gateway: None, respawn: None, world_spawn: false, + finder: None, placed: true, }); if let Err(e) = self.enter_level(Some(host), source) { From fba004eb3d6b44250fa4e8bcd4d72b700e4a58c5 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:22:41 +0100 Subject: [PATCH 46/84] Skip leaves in the no-leaves heightmap for firefly bush sounds --- crates/horizon-client/src/game/render_tick.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index d106e32ad..70e404a3d 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -33,7 +33,14 @@ fn motion_blocking_leaves( let mut y = from.min(MIN_Y + HEIGHT - 1); while y > MIN_Y { let f = facts.get(world.block(x, y, z)); - if f.full_collision || f.fluid != Fluid::None || leaves && f.name.contains("leaves") { + // #minecraft:leaves block motion, but MOTION_BLOCKING_NO_LEAVES skips them + // (their water still counts). + let blocks = if f.name.ends_with("_leaves") { + leaves + } else { + f.full_collision + }; + if blocks || f.fluid != Fluid::None { return y + 1; } y -= 1; From 1a5e5eb35828554deff92538bc21dd50cb0f0209 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:37:58 +0100 Subject: [PATCH 47/84] Owner combat goals only follow the wolf's own owner --- crates/horizon-client/src/mobs/tame.rs | 28 ++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index b6d0b1bb7..5c59f840d 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -388,7 +388,12 @@ impl Goal for OwnerHurtBy { if !m.extra.tame || m.extra.sitting { return false; } - let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.hurt_by) else { + let Some((who, at)) = + cx.w.player + .as_ref() + .filter(|p| m.extra.owner == Some(p.uuid)) + .and_then(|p| p.hurt_by) + else { return false; }; at != self.timestamp && wants_to_attack(m, cx.w, who) @@ -399,7 +404,12 @@ impl Goal for OwnerHurtBy { .is_some_and(|t| t.alive) } fn start(&mut self, m: &mut Mob, cx: &mut Cx) { - if let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.hurt_by) { + if let Some((who, at)) = + cx.w.player + .as_ref() + .filter(|p| m.extra.owner == Some(p.uuid)) + .and_then(|p| p.hurt_by) + { m.ai.target = Some(who); self.timestamp = at; } @@ -422,7 +432,12 @@ impl Goal for OwnerHurt { if !m.extra.tame || m.extra.sitting { return false; } - let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.last_hurt) else { + let Some((who, at)) = + cx.w.player + .as_ref() + .filter(|p| m.extra.owner == Some(p.uuid)) + .and_then(|p| p.last_hurt) + else { return false; }; at != self.timestamp && wants_to_attack(m, cx.w, who) @@ -433,7 +448,12 @@ impl Goal for OwnerHurt { .is_some_and(|t| t.alive) } fn start(&mut self, m: &mut Mob, cx: &mut Cx) { - if let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.last_hurt) { + if let Some((who, at)) = + cx.w.player + .as_ref() + .filter(|p| m.extra.owner == Some(p.uuid)) + .and_then(|p| p.last_hurt) + { m.ai.target = Some(who); self.timestamp = at; } From be714b38bbc3e27aa2d5aa1b3f0244b490c7d16b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:38:16 +0100 Subject: [PATCH 48/84] Only let a tame parrot land on its saved owner --- crates/horizon-client/src/game/shoulders.rs | 4 ++++ crates/horizon-client/src/mobs/tame.rs | 16 +++++++++++++++- 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/shoulders.rs b/crates/horizon-client/src/game/shoulders.rs index 602c5a5af..7dfc2f355 100644 --- a/crates/horizon-client/src/game/shoulders.rs +++ b/crates/horizon-client/src/game/shoulders.rs @@ -27,6 +27,10 @@ impl Game<'_> { let Some(p) = self.player.as_ref() else { return; }; + // The acting player must be the saved owner (`getOwner`). + if !horizon_client::mobs::tame::owned_by(self.mobs[i].extra.owner, self.acting_uuid()) { + return; + } if self.riding.is_some() || !p.ground.on_ground || p.fluids.was_touching_water diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index 82d808b7f..3002ce1f7 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -123,13 +123,15 @@ impl Goal for LandOnOwnersShoulder { } fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { // ShoulderRidingEntity.canSitOnShoulder: rideCooldownCounter > 100. - owner(m, cx.w).is_some_and(|(_, _, spectator)| !spectator) + is_owner(m, cx.w) + && owner(m, cx.w).is_some_and(|(_, _, spectator)| !spectator) && !m.extra.sitting && m.age > 100 } fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { if !m.extra.sitting && m.extra.leash.is_none() + && is_owner(m, cx.w) && cx .w .player @@ -172,6 +174,18 @@ fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> { let p = w.player.as_ref()?; Some((p.position, p.eye[1], p.spectator)) } +/// Whether the player the mob sees is the one saved as its owner (with +/// guests on, that player is whoever stands nearest). +fn is_owner(m: &Mob, w: &MobWorld) -> bool { + w.player + .as_ref() + .is_some_and(|p| owned_by(m.extra.owner, p.uuid)) +} +/// Whether `uuid` is the saved owner. A host with no UUID yet owns what it +/// tamed under the placeholder `[0, 0, 0, 1]`. +pub fn owned_by(owner: Option<[i32; 4]>, uuid: [i32; 4]) -> bool { + owner.is_some_and(|o| o == uuid || (o == [0, 0, 0, 1] && uuid == [0; 4])) +} /// `TamableAnimal.unableToMoveToOwner`. fn unable_to_move_to_owner(m: &Mob, w: &MobWorld) -> bool { m.extra.sitting || w.player.as_ref().is_some_and(|p| p.spectator) From 7eaa5f592bf777340b949253732253bbb70df1ea Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:38:21 +0100 Subject: [PATCH 49/84] Send jukebox play and stop events to guests so their parrots dance --- crates/horizon-client/src/game.rs | 4 ++++ crates/horizon-client/src/game/jukebox.rs | 14 ++++++++++++-- crates/horizon-client/src/game/lan.rs | 11 +++++++++++ 3 files changed, 27 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 8e4038b80..dafc68cba 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1640,6 +1640,9 @@ struct Game<'a> { guest_use: Option, /// Level events of this tick for the guests, and the guest acting now. lan_events: Vec<(i32, [i32; 3], i32, Option)>, + /// Jukebox level events 1010 (song name) and 1011 (`None`) for the guests; + /// the song's network id is only known once the hub is in hand. + lan_songs: Vec<([i32; 3], Option)>, /// Block events (position, b0, b1, state) and entity events (id, event, /// position) for the guests. lan_block_events: Vec<([i32; 3], i32, i32, u32)>, @@ -12664,6 +12667,7 @@ impl<'a> Game<'a> { forced_hit: None, guest_use: None, lan_events: Vec::new(), + lan_songs: Vec::new(), lan_block_events: Vec::new(), lan_entity_events: Vec::new(), lan_critical_hits: Vec::new(), diff --git a/crates/horizon-client/src/game/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs index 5c55c5f54..895b69490 100644 --- a/crates/horizon-client/src/game/jukebox.rs +++ b/crates/horizon-client/src/game/jukebox.rs @@ -99,7 +99,7 @@ impl Game<'_> { } /// Level event 1010: the song from the jukebox, and the "Now Playing" overlay. fn start_song(&mut self, pos: [i32; 3], song: &str) { - self.stop_song(pos); + self.stop_sound(pos); let Some(s) = self.res.items().songs.get(song).cloned() else { return; }; @@ -112,12 +112,22 @@ impl Game<'_> { .set_overlay(Text::translate("record.nowPlaying", &[description]), true); self.update_song_volumes(); self.notify_record_playing(pos, true); + if self.audio.capture.is_some() { + self.lan_songs.push((pos, Some(song.to_owned()))); + } } - fn stop_song(&mut self, pos: [i32; 3]) { + fn stop_sound(&mut self, pos: [i32; 3]) { if let Some(id) = self.jukebox_sounds.remove(&(pos[0], pos[1], pos[2])) { self.audio.stop_and_release(id); } + } + /// Level event 1011: the song ends, here and for the guests. + fn stop_song(&mut self, pos: [i32; 3]) { + self.stop_sound(pos); self.notify_record_playing(pos, false); + if self.audio.capture.is_some() { + self.lan_songs.push((pos, None)); + } } /// `LevelEventHandler.notifyNearbyEntities` (level events 1010 and 1011): /// parrots within three blocks of the jukebox start or stop dancing. diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 5292cd31b..cb6c0b470 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -664,6 +664,7 @@ impl Game<'_> { self.world.light_log = None; self.audio.capture = None; self.lan_events.clear(); + self.lan_songs.clear(); self.lan_critical_hits.clear(); self.streaming.extra.clear(); if announce { @@ -1255,6 +1256,16 @@ impl Game<'_> { } host.hub.level_event(kind, pos, data, acting); } + // Level events 1010 and 1011: the guests' parrots dance or stop. + for (pos, song) in std::mem::take(&mut self.lan_songs) { + match song { + Some(name) => { + let id = host.hub.registry_id("minecraft:jukebox_song", &name); + host.hub.level_event(1010, pos, id.unwrap_or(0), None); + } + None => host.hub.level_event(1011, pos, 0, None), + } + } for (pos, b0, b1, state) in std::mem::take(&mut self.lan_block_events) { host.hub.block_event(pos, b0, b1, state); } From 512e003cbd50f13572286ee759a26a33ef0b08dc Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:43:50 +0100 Subject: [PATCH 50/84] Wolf armor: check the acting player's UUID and keep the armor's components --- crates/horizon-client/src/entity_nbt.rs | 8 +++++--- crates/horizon-client/src/game/creatures.rs | 11 +++++++---- crates/horizon-client/src/game/lan.rs | 6 +++++- crates/horizon-client/src/game/lan_mobs.rs | 8 ++++++++ crates/horizon-client/src/mobs.rs | 3 +++ crates/horizon-client/src/mobs/drops.rs | 1 + 6 files changed, 29 insertions(+), 8 deletions(-) diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 18f89d884..8e64652c9 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -551,6 +551,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { { let mut stack = crate::items::ItemStack::new(id, 1); stack.damage = m.extra.body_damage.max(0) as u32; + stack.extra = m.extra.body_extra.clone(); equipment.insert(slot.into(), crate::save::item_to_nbt(&stack)); continue; } @@ -790,11 +791,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - crate::mobs::tame::set_tame(&mut m, tame); m.health = health; m.extra.sitting = flag(tag, "Sitting"); - m.extra.body_damage = tag + let armor = tag .get("equipment") .and_then(|e| e.get("body")) - .and_then(crate::save::item_from_nbt) - .map_or(0, |s| s.damage as i32); + .and_then(crate::save::item_from_nbt); + m.extra.body_damage = armor.as_ref().map_or(0, |s| s.damage as i32); + m.extra.body_extra = armor.and_then(|s| s.extra); m.extra.color = number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15); if let Some(Tag::String(v)) = tag.get("variant") { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index a72d53c6b..7f470252c 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2559,10 +2559,11 @@ impl Game<'_> { .items() .get(&item) .is_some_and(|i| i.max_damage > 0); - let me = self.level.player_uuid.or(Some([0, 0, 0, 1])); + let me = self.acting_owner(); let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft) || self.keys.contains(&winit::keyboard::KeyCode::ShiftRight); let held_damage = held.as_ref().map_or(0, |h| h.damage as i32); + let held_extra = held.as_ref().and_then(|h| h.extra.clone()); let m = &mut self.mobs[index]; if !m.alive() { return Ok(false); @@ -2653,6 +2654,7 @@ impl Game<'_> { { let mut stack = ItemStack::new("minecraft:wolf_armor", 1); stack.damage = m.extra.body_damage.max(0) as u32; + stack.extra = m.extra.body_extra.take(); armor_drop = Some(stack); m.extra.head = None; m.extra.body_damage = 0; @@ -2682,6 +2684,7 @@ impl Game<'_> { { m.extra.head = Some(item.as_str().into()); m.extra.body_damage = held_damage; + m.extra.body_extra = held_extra; consume = true; eat = Some(("item.armor.equip_wolf", 1.0, 1.0)); } @@ -2745,7 +2748,7 @@ impl Game<'_> { let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0; if tamed { horizon_client::mobs::tame::set_tame(m, true); - m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1])); + m.extra.owner = me; m.persistent = true; m.nav_stop(); m.ai.target = None; @@ -2821,7 +2824,7 @@ impl Game<'_> { let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0; if tamed { m.extra.tame = true; - m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1])); + m.extra.owner = me; m.extra.sitting = true; } eat = eating_sound(m, &mut self.world.random); @@ -2877,7 +2880,7 @@ impl Game<'_> { let tamed = m.random.next_int_bound(10).unwrap_or(1) == 0; if tamed { m.extra.tame = true; - m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1])); + m.extra.owner = me; } let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 7897b5c57..2000a0db5 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -385,7 +385,11 @@ fn mob_equipment( } else { 0 }, - extra: None, + extra: if slot == 5 && m.species() == horizon_client::mobs::Species::Wolf { + e.body_extra.clone() + } else { + None + }, }; out.push((slot, hub.stack(&Some(stack)))); } diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index 4f53cec60..d1f0e16cd 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -328,6 +328,14 @@ impl Game<'_> { .collect() } /// The UUID of the player acting: the guest `as_guest` runs, else the host. + /// The owner a wolf, cat or parrot gets when the acting player tames it + /// (a host with no UUID yet owns under `[0, 0, 0, 1]`). + pub(super) fn acting_owner(&self) -> Option<[i32; 4]> { + self.lan_acting_uuid + .map(horizon_client::lan::playerdata::uuid_ints) + .or(self.level.player_uuid) + .or(Some([0, 0, 0, 1])) + } pub(super) fn acting_uuid(&self) -> [i32; 4] { self.lan_acting_uuid .map(horizon_client::lan::playerdata::uuid_ints) diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index f9a53f0f2..81f2b90f0 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -663,6 +663,8 @@ pub struct Extra { pub saddled: bool, /// The durability a wolf's body armor (`extra.head`) has lost. pub body_damage: i32, + /// The components (dye, name...) of that armor stack. + pub body_extra: Option>, /// The saddle's components (name, enchantments...) when it is not a bare /// one; `saddled` stays the gameplay flag. pub saddle_stack: Option, @@ -1858,6 +1860,7 @@ impl Mob { if after >= WOLF_ARMOR_DURABILITY { self.extra.head = None; self.extra.body_damage = 0; + self.extra.body_extra = None; self.outbox .push(MobEvent::Sound("item.wolf_armor.break", at, 1.0, 1.0)); } else { diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs index 28ba2a0cd..be3a06174 100644 --- a/crates/horizon-client/src/mobs/drops.rs +++ b/crates/horizon-client/src/mobs/drops.rs @@ -286,6 +286,7 @@ pub fn clear_slot(m: &mut Mob, slot: &str) { "body" if body => { m.extra.head = None; m.extra.body_damage = 0; + m.extra.body_extra = None; return; } "saddle" => { From 4b4361fbc052751a5118192b312d857b4607c5c4 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:48:20 +0100 Subject: [PATCH 51/84] Clear a piglin's hoglin target once it dies or disappears --- crates/horizon-client/src/mobs/piglin.rs | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs index 5b8c17fb3..0644b40e6 100644 --- a/crates/horizon-client/src/mobs/piglin.rs +++ b/crates/horizon-client/src/mobs/piglin.rs @@ -331,8 +331,18 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { if m.species() == Species::Hoglin && m.alive() { hoglin_repellent(m, w); } - if m.species() == Species::Piglin && m.extra.ints[0] > 0 { - m.extra.ints[0] -= 1; + if m.species() == Species::Piglin { + if m.extra.ints[0] > 0 { + m.extra.ints[0] -= 1; + } + // `StopAttackingIfTargetInvalid`: a hoglin handed over by a hunt + // broadcast has no target goal of its own to drop it when it dies. + if let Some(who @ Who::Mob(_)) = m.ai.target + && w.target_info(who) + .is_none_or(|t| !t.alive || !t.can_be_seen_as_enemy) + { + m.ai.target = None; + } } if m.extra.anger > 0 { m.extra.anger -= 1; From e9797d69d0ea0b5ee0b75c68a9b483cdbf13f364 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 21:51:25 +0100 Subject: [PATCH 52/84] Use the berry damage type for sweet berry bushes and check the whole move for contact --- .../horizon-client/src/game/commands/world_cmds.rs | 3 ++- crates/horizon-client/src/game/creatures.rs | 1 + crates/horizon-client/src/mobs.rs | 9 ++++++++- crates/horizon-client/src/mobs/ai.rs | 14 ++++++++++---- crates/horizon-client/src/mobs/sulfur_cube.rs | 1 + 5 files changed, 22 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs index 687eb3f88..859d86397 100644 --- a/crates/horizon-client/src/game/commands/world_cmds.rs +++ b/crates/horizon-client/src/game/commands/world_cmds.rs @@ -117,7 +117,8 @@ impl Game<'_> { "drown" => DamageKind::Drown, "magic" | "indirect_magic" | "dragon_breath" => DamageKind::Magic, "sting" => DamageKind::Sting, - "cactus" | "sweet_berry_bush" => DamageKind::Cactus, + "cactus" => DamageKind::Cactus, + "sweet_berry_bush" => DamageKind::SweetBerryBush, "in_wall" => DamageKind::InWall, "thorns" => DamageKind::Thorns, _ => DamageKind::Generic, diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2b65a3289..04228a722 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -3283,6 +3283,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool) K::Magic => "minecraft:magic", K::Sting => "minecraft:sting", K::Cactus => "minecraft:cactus", + K::SweetBerryBush => "minecraft:sweet_berry_bush", K::Generic => "minecraft:generic", K::InWall => "minecraft:in_wall", K::Thorns => "minecraft:thorns", diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 0edcd3620..4498e9b75 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -518,6 +518,8 @@ pub enum DamageKind { Magic, Sting, Cactus, + /// `sweet_berry_bush`. + SweetBerryBush, Generic, InWall, Thorns, @@ -573,7 +575,11 @@ impl Damage { pub fn causes_panic(&self) -> bool { !matches!( self.kind, - DamageKind::Fall | DamageKind::Drown | DamageKind::Generic | DamageKind::InWall + DamageKind::Fall + | DamageKind::Drown + | DamageKind::Generic + | DamageKind::InWall + | DamageKind::SweetBerryBush ) } /// DamageTypeTags.BYPASSES_ARMOR @@ -608,6 +614,7 @@ impl Damage { | DamageKind::Drown | DamageKind::Magic | DamageKind::Cactus + | DamageKind::SweetBerryBush | DamageKind::Generic | DamageKind::InWall | DamageKind::OutOfWorld diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index ffc74d0b9..458ccd097 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -433,14 +433,20 @@ pub fn tick( /// that hurt or hold a mob: the cactus (`CactusBlock.entityInside`, 1) and the /// sweet berry bush (`SweetBerryBushBlock.entityInside`: stuck at 0.8, 0.75, /// 0.8, and a grown bush pricks for 1 when the mob moved at least 0.003 on X -/// or Z this tick). The blocks are those the mob's box touches where it -/// started the tick and where it ended. +/// or Z this tick). The blocks are those the mob's box touches anywhere along +/// its move this tick, from where it started to where it ended. fn effects_from_blocks(m: &mut Mob, w: &MobWorld) { let mut visited: Vec<[i32; 3]> = Vec::new(); - for at in [m.previous, m.position] { + let travel = m.position.subtract(m.previous); + let longest = travel.x.abs().max(travel.y.abs()).max(travel.z.abs()); + let steps = ((longest / 0.2).ceil() as i32).clamp(1, 100); + for step in 0..=steps { if !m.alive() { return; } + let at = m + .previous + .add_vector(travel.scale(f64::from(step) / f64::from(steps))); let b = m.bounds_at(at).deflate(Vec3::new(1e-5, 1e-5, 1e-5)); for x in b.min_position().x.floor() as i32..=b.max_position().x.floor() as i32 { for y in b.min_position().y.floor() as i32..=b.max_position().y.floor() as i32 { @@ -465,7 +471,7 @@ fn effects_from_blocks(m: &mut Mob, w: &MobWorld) { && (moved.x.abs() >= f64::from(0.003_f32) || moved.z.abs() >= f64::from(0.003_f32)) { - m.damage(1.0, Damage::of(DamageKind::Cactus)); + m.damage(1.0, Damage::of(DamageKind::SweetBerryBush)); } } _ => continue, diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs index 00b846b86..5a5c2f48a 100644 --- a/crates/horizon-client/src/mobs/sulfur_cube.rs +++ b/crates/horizon-client/src/mobs/sulfur_cube.rs @@ -297,6 +297,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool { | DamageKind::Fall | DamageKind::Sting | DamageKind::Cactus + | DamageKind::SweetBerryBush ); if immune { if let Some(from) = source.from { From 024415e09dff8438725dfb68dd5fe78bb691ea91 Mon Sep 17 00:00:00 2001 From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com> Date: Tue, 27 Oct 2026 05:11:35 +0800 Subject: [PATCH 53/84] Inventory: animate every animated block and item sprite The shared atlas packs animated block and item textures as their first frame, and only fire re-drew itself: an animated block held or previewed in the GUI (sculk, magma) sat still, while the same block animated in the world. The atlas now keeps every animated block or item sprite's frame list and re-uploads the current frame into its rect as the animation ticks, with the mcmeta's interpolation mixing the frame into the next one the way the world's sprite arrays already do, so GUI items animate like vanilla's stitched atlas. Co-Authored-By: ZCode --- crates/horizon-client/src/game.rs | 12 ++-- crates/horizon-client/src/gfx.rs | 2 +- crates/horizon-client/src/hud.rs | 114 +++++++++++++++++++----------- 3 files changed, 78 insertions(+), 50 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f9edd98bb..e93911e65 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -13505,10 +13505,10 @@ fn build_renderer( previous, api, ))?; - renderer.hud.fire_animations = atlas - .fire_animations + renderer.hud.sprite_animations = atlas + .sprite_animations .iter() - .map(|(rect, animation)| (*rect, animation.clone(), usize::MAX)) + .map(|(rect, animation)| (*rect, animation.clone(), (usize::MAX, 0, 0))) .collect(); Ok(renderer) } @@ -13558,10 +13558,10 @@ fn loading_renderer( api, ))?; if let Some(atlas) = atlas { - renderer.hud.fire_animations = atlas - .fire_animations + renderer.hud.sprite_animations = atlas + .sprite_animations .iter() - .map(|(rect, animation)| (*rect, animation.clone(), usize::MAX)) + .map(|(rect, animation)| (*rect, animation.clone(), (usize::MAX, 0, 0))) .collect(); } Ok(renderer) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 70d882a98..74c544168 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -3390,7 +3390,7 @@ impl Renderer { if self.animated_textures { self.animate(&mut encoder, frame.ticks); self.hud - .animate_fire(&mut self.uploads, &mut encoder, frame.ticks); + .animate_sprites(&mut self.uploads, &mut encoder, frame.ticks); } self.update_lightmap( &mut encoder, diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 2b6acda41..d2bef127e 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -64,7 +64,10 @@ pub struct HudAtlas { /// Sprites whose `.png.mcmeta` sets `blur` or `clamp`; the others /// sample as vanilla's defaults (nearest, repeat). pub flags: HashMap, - pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>, + /// Every animated block or item sprite the atlas packs: its atlas rect + /// and the mcmeta-driven frame list, re-uploaded into the rect as the + /// frames turn (vanilla's stitched atlas animates all of these). + pub sprite_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>, /// The default font (bitmap sheets in this atlas, unifont rasterized on demand). pub font: crate::font::Font, white: Rect, @@ -373,7 +376,7 @@ impl HudAtlas { let s = p.to_string_lossy(); !s.contains("title/background") && !s.contains("realms") && !s.contains("presets") }); - type Decoded = (PackedImage, Option, Option<(u32, u32)>); + type Decoded = (PackedImage, Option, Option<(u32, u32)>, bool); let decode_one = |path: &PathBuf| -> Option { let name = path .strip_prefix(&textures) @@ -396,14 +399,20 @@ impl HudAtlas { .and_then(|d| png_size(&d.join(format!("{name}.png")))) .map(|(dw, dh)| (dw, if frames { dh.min(dw) } else { dh })) .filter(|&size| size != (w, h)); - let flags = fs::read_to_string(path.with_extension("png.mcmeta")) - .ok() - .and_then(|json| TextureFlags::from_mcmeta(&json)); + let mcmeta = fs::read_to_string(path.with_extension("png.mcmeta")).ok(); + let flags = mcmeta.as_deref().and_then(TextureFlags::from_mcmeta); + let animated = frames + && mcmeta.as_deref().is_some_and(|json| { + serde_json::from_str::(json) + .ok() + .is_some_and(|meta| meta.get("animation").is_some()) + }); let (gw, gh) = gui_size.unwrap_or((w, h)); (gw <= 1024 && (gh <= 512 || name.starts_with("font/"))).then_some(( (name, w, h, pixels), flags, gui_size, + animated, )) }; let threads = std::thread::available_parallelism().map_or(2, |n| n.get()); @@ -422,14 +431,18 @@ impl HudAtlas { }); let mut flags = HashMap::new(); let mut gui_sizes = HashMap::new(); + let mut animated: Vec = Vec::new(); let mut images: Vec = Vec::with_capacity(decoded.len()); - for (image, image_flags, gui_size) in decoded { + for (image, image_flags, gui_size, is_animated) in decoded { if let Some(f) = image_flags { flags.insert(image.0.clone(), f); } if let Some(size) = gui_size { gui_sizes.insert(image.0.clone(), size); } + if is_animated { + animated.push(image.0.clone()); + } images.push(image); } if full { @@ -495,35 +508,32 @@ impl HudAtlas { }, ); } - let mut fire_sprites = crate::sprites::Sprites::default(); - let mut fire_animations = Vec::new(); - for name in [ - "block/fire_0", - "block/fire_1", - "block/soul_fire_0", - "block/soul_fire_1", - ] { - if let Some(rect) = sprites.get(name).copied() { - let layer = fire_sprites.insert(root, &format!("minecraft:{name}"))?; - if let Some(animation) = fire_sprites - .animations - .iter() - .find(|a| a.layer == layer) - .cloned() - { - let (tw, th) = rect.texels((width, height)); - let image = animation.resized_pixels(animation.frame(0), tw, th); - let x = (rect.u0 * width as f32).round() as usize; - let y = (rect.v0 * height as f32).round() as usize; - let row_bytes = tw as usize * 4; - for row in 0..th as usize { - let dst = ((y + row) * width as usize + x) * 4; - let src = row * row_bytes; - pixels[dst..dst + row_bytes].copy_from_slice(&image[src..src + row_bytes]); - } - fire_animations.push((rect, animation)); - } + // Every animated sprite animates: the packed strip is the raw first + // frame, while the mcmeta's frame list may start anywhere, so each + // animation's frame(0) overwrites its atlas rect before drawing. + let mut loaded = crate::sprites::Sprites::default(); + let mut sprite_animations = Vec::new(); + animated.sort(); + for name in animated { + let Some(rect) = sprites.get(&name).copied() else { + continue; + }; + let layer = loaded.insert(root, &format!("minecraft:{name}"))?; + let Some(animation) = loaded.animations.iter().find(|a| a.layer == layer).cloned() + else { + continue; + }; + let (tw, th) = rect.texels((width, height)); + let image = animation.resized_pixels(animation.frame(0), tw, th); + let x = (rect.u0 * width as f32).round() as usize; + let y = (rect.v0 * height as f32).round() as usize; + let row_bytes = tw as usize * 4; + for row in 0..th as usize { + let dst = ((y + row) * width as usize + x) * 4; + let src = row * row_bytes; + pixels[dst..dst + row_bytes].copy_from_slice(&image[src..src + row_bytes]); } + sprite_animations.push((rect, animation)); } let white = sprites["horizon/white"]; let font = crate::font::Font::load( @@ -541,7 +551,7 @@ impl HudAtlas { sprites, translucent, flags, - fire_animations, + sprite_animations, font, white, }) @@ -1033,7 +1043,7 @@ impl HudUniform { } } pub struct HudRenderer { - pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation, usize)>, + pub sprite_animations: Vec<(Rect, crate::sprites::SpriteAnimation, (usize, usize, u32))>, /// The shared atlas texture, for run-time glyph uploads. pub atlas_texture: Option, pipeline: wgpu::RenderPipeline, @@ -1235,7 +1245,7 @@ impl HudRenderer { }); Ok(Self { atlas_texture: None, - fire_animations: Vec::new(), + sprite_animations: Vec::new(), pipeline, invert_pipeline, additive_pipeline, @@ -1248,7 +1258,7 @@ impl HudRenderer { capacity, }) } - pub fn animate_fire( + pub fn animate_sprites( &mut self, uploads: &mut crate::gfx::upload::Uploads, encoder: &mut wgpu::CommandEncoder, @@ -1257,13 +1267,31 @@ impl HudRenderer { let Some(texture) = &self.atlas_texture else { return; }; - for (rect, animation, previous) in &mut self.fire_animations { - let frame = animation.frame(tick); - if frame == *previous { + for (rect, animation, previous) in &mut self.sprite_animations { + // `SpriteContents.AnimationState`: the frame from the mcmeta's + // list, blended into the next one by the sub-frame's thousandths + // when the sprite interpolates. + let blend = animation.blend(tick); + let state = (blend.frame, blend.next, blend.millis); + if state == *previous { continue; } let (w, h) = rect.texels((texture.width(), texture.height())); - let pixels = animation.resized_pixels(frame, w, h); + let pixels = if blend.millis == 0 { + animation.resized_pixels(blend.frame, w, h) + } else { + let current = animation.resized_pixels(blend.frame, w, h); + let next = animation.resized_pixels(blend.next, w, h); + let millis = blend.millis; + current + .iter() + .zip(next) + .map(|(&a, b)| { + ((u32::from(a) * (1000 - millis) + u32::from(b) * millis + 500) / 1000) + as u8 + }) + .collect() + }; uploads.texture( encoder, wgpu::TexelCopyTextureInfo { @@ -1280,7 +1308,7 @@ impl HudRenderer { h, &pixels, ); - *previous = frame; + *previous = state; } } /// Stage the batch's atlas patches, vertices and uniform: before the From ac33fb74ece1bc40ac7c6e28fc69acfdd20ef023 Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Tue, 27 Oct 2026 04:57:27 +0500 Subject: [PATCH 54/84] Add the decorated pot's back-face culling regression test `DecoratedPotRenderer` submits every part with `RenderTypes.entitySolid`, whose pipeline culls back faces. The pot's `top` and `bottom` are flat boxes, so without that cull both sides of each plane are drawn and they z-fight: the pot renders wrong (kacpherek's #2099 draws the cull). The test renders a plain pot and checks that all of vanilla's 28 submitted quads are kept and that every one of them is marked for the cull, so the behaviour cannot silently regress. It fails without the cull. Co-Authored-By: minimax-m3.1-flash (Claude Code) --- .../horizon-client/src/block_entity_render.rs | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index e8447ecf3..3e4e2790d 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -2118,4 +2118,70 @@ mod tests { assert_eq!(first_line("\u{6771}", 3.0, &advance), "\u{6771}"); assert_eq!(first_line("ab\ncd", 100.0, &advance), "ab"); } + /// `DecoratedPotRenderer` submits every part with `RenderTypes.entitySolid`, + /// whose pipeline culls back faces. The pot's `top` and `bottom` are flat + /// boxes, so without that cull both sides of each plane are drawn and they + /// z-fight: the pot renders wrong. + #[test] + fn the_decorated_pot_culls_its_back_faces() { + let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !root.join("entity-models.json").exists() { + return; + } + let assets = crate::assets::Assets::load(&root).unwrap(); + let registry = assets.registry; + let renderer = BlockEntityRenderer::load(&root, ®istry).unwrap(); + let state = registry.default_state("minecraft:decorated_pot").unwrap(); + let sprites: HashMap = [ + "entity/decorated_pot/decorated_pot_base", + "entity/decorated_pot/decorated_pot_side", + ] + .into_iter() + .map(|name| { + ( + name.to_owned(), + Rect { + u0: 0.25, + v0: 0.125, + u1: 0.375, + v1: 0.25, + w: 16, + h: 16, + }, + ) + }) + .collect(); + let world = World::new(BlockStateId(0), 1); + let scene = Scene { + camera: DVec3::ZERO, + orientation: Quat::IDENTITY, + anim: &|_| BlockAnim::default(), + texts: None, + partial: 0.5, + game_time: 0, + max_y: 320, + world: &world, + sprites: &sprites, + nether: false, + lid: &|_| 0.0, + sign: &|_| None, + banner: &|_| Vec::new(), + skull: &|_| None, + glyph: &|_| (None, 0.0), + }; + let mut verts = Vec::new(); + renderer.render_block(&scene, [0; 3], state.0, Mat4::IDENTITY, 0xff, &mut verts); + // Vanilla submits 28 quads for a plain pot, and the cull keeps them all. + assert_eq!( + verts.len() / 4, + 28, + "the pot submits all of vanilla's quads" + ); + assert!( + verts.iter().all(|v| v.normal == CULL_BACK), + "entitySolid culls the pot's back faces" + ); + } } From 7250944a7c79b8c2371fafeb7714b9841ddf3e59 Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Tue, 27 Oct 2026 05:06:20 +0500 Subject: [PATCH 55/84] Test the decorated pot item's back-face culling too The pot in the hand and dropped on the ground is drawn by the same `DecoratedPotRenderer` model, through the item path, so its quads carry the cull as well. The test fails without it. Co-Authored-By: minimax-m3.1-flash (Claude Code) --- .../horizon-client/src/item_render/special.rs | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs index 8a54f49bb..f93a4c6d9 100644 --- a/crates/horizon-client/src/item_render/special.rs +++ b/crates/horizon-client/src/item_render/special.rs @@ -686,4 +686,51 @@ mod tests { ); } } + /// `DecoratedPotRenderer` draws every part with `RenderTypes.entitySolid`, + /// whose pipeline culls back faces: the pot's flat `top` and `bottom` + /// planes would otherwise show both sides and z-fight in the hand too. + #[test] + fn the_decorated_pot_item_culls_its_back_faces() { + let root = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !root.join("entity-models.json").exists() { + return; + } + let renderer = ItemRenderer::load(&root).unwrap(); + let sprite = Rect { + u0: 0.25, + v0: 0.125, + u1: 0.375, + v1: 0.25, + w: 16, + h: 16, + }; + let sprites: HashMap = [ + "entity/decorated_pot/decorated_pot_base", + "entity/decorated_pot/decorated_pot_side", + ] + .into_iter() + .map(|name| (name.to_owned(), sprite)) + .collect(); + let model = SpecialModel { + kind: SpecialKind::DecoratedPot, + }; + let mut quads: Vec = Vec::new(); + submit( + &renderer, + &model, + &Value::Null, + false, + Mat4::IDENTITY, + &sprites, + &super::super::NoHost, + &mut quads, + ); + assert!(!quads.is_empty(), "the pot item draws its parts"); + assert!( + quads.iter().all(|q| q.cull_back), + "entitySolid culls the pot's back faces" + ); + } } From 18b544770fa39df42ccd6c708f4b70d417c2cbff Mon Sep 17 00:00:00 2001 From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com> Date: Tue, 27 Oct 2026 12:17:54 +0800 Subject: [PATCH 56/84] Inventory: frame strips by the mcmeta's frame size `decode_one` cropped an animated block or item strip as `h > w -> w x w`, ignoring the mcmeta's `animation.width`/`height`: a pack texture that names its frame dimensions, or lays its frames along a row, packed the whole image as "frame 0" and was then drawn as a square frame over a rect sized for the image. The first frame now comes from `AnimationMetadataSection.frameSize`, resampled to its longer side the way the world's sprite arrays keep a frame square, and the sprite's GUI size is that square too. The atlas also gains the regression test the review asked for: a synthetic two-frame block strip whose mcmeta starts on the second frame registers in `sprite_animations`, and the atlas holds that frame at the sprite's rect; a row strip with explicit frame dimensions packs only its left frame. Co-Authored-By: ZCode --- crates/horizon-client/src/hud.rs | 136 ++++++++++++++++++++++++++++--- 1 file changed, 123 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index d2bef127e..2abed308e 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -2,6 +2,7 @@ //! textures, and a batch of textured quads in GUI pixels (vanilla's automatic //! GUI scale is applied when drawing). use crate::Result; +use horizon_assets::animation::AnimationMetadata; use std::{ collections::{HashMap, HashSet}, fs, @@ -145,6 +146,21 @@ fn walk(dir: &Path, out: &mut Vec) { } /// A packed atlas image: sprite name, size and RGBA pixels. type PackedImage = (String, u32, u32, Vec); +/// A frame of an animated strip at `x, y`, nearest-resampled to the longer +/// side of the frame: array layers are square, as `Sprites::load` keeps them +/// for the world's sprite arrays. +fn strip_frame(pixels: &[u8], stride: u32, x: u32, y: u32, w: u32, h: u32) -> Vec { + let side = w.max(h); + let mut out = Vec::with_capacity((side * side * 4) as usize); + for row in 0..side { + let source_row = y + row * h / side; + for column in 0..side { + let at = ((source_row * stride + x + column * w / side) * 4) as usize; + out.extend_from_slice(&pixels[at..at + 4]); + } + } + out +} /// `image` inside a one-texel border copied from its opposite edges, the /// texels repeat addressing reads past each edge. fn wrap_border((name, w, h, data): &PackedImage) -> PackedImage { @@ -384,12 +400,35 @@ impl HudAtlas { .with_extension("") .to_string_lossy() .replace('\\', "/"); - let (w, mut h, pixels) = decode(path).ok()?; - // Animated strips keep their first frame. + let (mut w, mut h, pixels) = decode(path).ok()?; + let mcmeta = fs::read_to_string(path.with_extension("png.mcmeta")).ok(); + let animation = mcmeta + .as_deref() + .and_then(|json| serde_json::from_str::(json).ok()) + .and_then(|meta| { + meta.get("animation") + .and_then(|section| AnimationMetadata::from_json(§ion.to_string()).ok()) + }); + // An animated strip keeps its first frame: the region the mcmeta's + // frame size picks (`AnimationMetadataSection.frameSize`), which is + // the top-left square unless it names other dimensions or the + // frames run along a row. let frames = name.starts_with("block/") || name.starts_with("item/"); - let pixels = if frames && h > w { - h = w; - pixels[..(w * w * 4) as usize].to_vec() + let pixels = if frames { + let stride = w; + let [fw, fh] = animation.as_ref().map_or([w.min(h) as i32; 2], |meta| { + meta.frame_size(w as i32, h as i32) + }); + match (u32::try_from(fw), u32::try_from(fh)) { + (Ok(fw), Ok(fh)) + if fw > 0 && fh > 0 && w % fw == 0 && h % fh == 0 && (fw, fh) != (w, h) => + { + let side = fw.max(fh); + (w, h) = (side, side); + strip_frame(&pixels, stride, 0, 0, fw, fh) + } + _ => pixels, + } } else { pixels }; @@ -397,16 +436,13 @@ impl HudAtlas { let gui_size = default_textures .as_ref() .and_then(|d| png_size(&d.join(format!("{name}.png")))) - .map(|(dw, dh)| (dw, if frames { dh.min(dw) } else { dh })) + .map(|(dw, dh)| { + let side = dw.min(dh); + if frames { (side, side) } else { (dw, dh) } + }) .filter(|&size| size != (w, h)); - let mcmeta = fs::read_to_string(path.with_extension("png.mcmeta")).ok(); let flags = mcmeta.as_deref().and_then(TextureFlags::from_mcmeta); - let animated = frames - && mcmeta.as_deref().is_some_and(|json| { - serde_json::from_str::(json) - .ok() - .is_some_and(|meta| meta.get("animation").is_some()) - }); + let animated = frames && animation.is_some(); let (gw, gh) = gui_size.unwrap_or((w, h)); (gw <= 1024 && (gh <= 512 || name.starts_with("font/"))).then_some(( (name, w, h, pixels), @@ -1469,6 +1505,80 @@ impl HudRenderer { mod tests { use super::*; + /// Write a PNG `width x height` whose `frames` stacked rows are solid + /// colours, then its mcmeta beside it. + fn write_strip(path: &Path, width: u32, height: u32, frames: &[[u8; 4]], mcmeta: Option<&str>) { + let file = std::io::BufWriter::new(fs::File::create(path).unwrap()); + let mut encoder = png::Encoder::new(file, width, height); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + let mut writer = encoder.write_header().unwrap(); + let mut pixels = Vec::with_capacity((width * height * 4) as usize); + for frame in frames { + let rows = height / frames.len() as u32; + pixels.extend((0..width * rows).flat_map(|_| *frame)); + } + writer.write_image_data(&pixels).unwrap(); + writer.finish().unwrap(); + if let Some(mcmeta) = mcmeta { + let meta = path.with_extension("png.mcmeta"); + fs::write(meta, mcmeta).unwrap(); + } + } + /// A resource root holding one animated block texture: a strip of two + /// 16x16 frames, red then blue, whose mcmeta starts on the blue one. + fn animated_root() -> PathBuf { + let root = std::env::temp_dir().join(format!("horizon-atlas-anim-{}", std::process::id())); + let block = root.join("assets/minecraft/textures/block"); + fs::create_dir_all(&block).unwrap(); + write_strip( + &block.join("test_anim.png"), + 16, + 32, + &[[255, 0, 0, 255], [0, 0, 255, 255]], + Some(r#"{"animation": {"frames": [1, 0]}}"#), + ); + root + } + fn texel_at(atlas: &HudAtlas, rect: Rect, x: u32, y: u32) -> [u8; 4] { + let px = (rect.u0 * atlas.width as f32).round() as u32 + x; + let py = (rect.v0 * atlas.height as f32).round() as u32 + y; + let at = ((py * atlas.width + px) * 4) as usize; + atlas.pixels[at..at + 4].try_into().unwrap() + } + #[test] + fn animated_block_sprites_register_and_pack_their_first_mcmeta_frame() { + let root = animated_root(); + let atlas = HudAtlas::build(&root).unwrap(); + let (rect, animation) = atlas + .sprite_animations + .iter() + .find(|(_, animation)| animation.frame_count() == 2) + .expect("the animated block sprite"); + // The mcmeta's list starts on the strip's second (blue) frame. + assert_eq!(animation.frame(0), 1); + assert_eq!(rect.texels((atlas.width, atlas.height)), (16, 16)); + assert_eq!(texel_at(&atlas, *rect, 0, 0), [0, 0, 255, 255]); + assert_eq!(texel_at(&atlas, *rect, 15, 15), [0, 0, 255, 255]); + } + #[test] + fn a_strip_frames_size_comes_from_its_mcmeta() { + let root = animated_root(); + let block = root.join("assets/minecraft/textures/block"); + // A row of two frames with the animation's own frame size. + write_strip( + &block.join("test_row.png"), + 32, + 16, + &[[0, 255, 0, 255], [255, 255, 0, 255]], + Some(r#"{"animation": {"width": 16, "height": 16}}"#), + ); + let atlas = HudAtlas::build(&root).unwrap(); + let rect = atlas.sprites["block/test_row"]; + // The first frame is the left 16x16, not the whole row. + assert_eq!(rect.texels((atlas.width, atlas.height)), (16, 16)); + assert_eq!(texel_at(&atlas, rect, 0, 0), [0, 255, 0, 255]); + } /// `count` images of `w x h`; layout reads only their sizes. fn sized(count: usize, w: u32, h: u32) -> Vec { (0..count) From b7749dd0d2b87b29ca01bbf40990cbc467bc34e8 Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Tue, 27 Oct 2026 09:38:03 +0500 Subject: [PATCH 57/84] Fix a needless borrow in the decorated pot's test Clippy's needless_borrow: the registry is already a reference, so the extra & is dereferenced right away. Co-Authored-By: minimax-m3.1-flash (Claude Code) --- crates/horizon-client/src/block_entity_render.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 3e4e2790d..c7ae80b22 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -2132,7 +2132,7 @@ mod tests { } let assets = crate::assets::Assets::load(&root).unwrap(); let registry = assets.registry; - let renderer = BlockEntityRenderer::load(&root, ®istry).unwrap(); + let renderer = BlockEntityRenderer::load(&root, registry).unwrap(); let state = registry.default_state("minecraft:decorated_pot").unwrap(); let sprites: HashMap = [ "entity/decorated_pot/decorated_pot_base", From 6b1d376e6f1fa7d75aabb7e0014e5c56caf2d708 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:22:11 +0100 Subject: [PATCH 58/84] Show the sleeping players count on the action bar of a LAN host or server --- crates/horizon-client/src/game.rs | 6 ++ crates/horizon-client/src/game/lan_actions.rs | 64 +++++++++++++++++-- crates/horizon-client/src/lan/hub.rs | 7 ++ 3 files changed, 71 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 7699e83d7..675b73f17 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1481,6 +1481,8 @@ struct Game<'a> { /// The head of the bed while sleeping; the visual timer also survives waking. sleeping: Option<[i32; 3]>, sleep_timer: u32, + /// `SleepStatus`'s active and sleeping players at the last announcement. + sleep_seen: (i64, i64), dim: Dim, world_root: PathBuf, /// A player carried through a portal, re-placed once the destination loads. @@ -4943,6 +4945,7 @@ impl Game<'_> { self.tick_friends(); horizon_client::spans::time("tick_hand", || self.tick_hand()); horizon_client::spans::time("tick_sleep", || self.tick_sleep()); + self.announce_sleep_status(); horizon_client::spans::time("tick_portal", || self.tick_nether_portal())?; if running { horizon_client::spans::time("tick_end", || self.tick_end())?; @@ -10370,6 +10373,8 @@ impl Game<'_> { self.wake_up(); } self.wake_guests(); + // SleepStatus.removeAllSleepers: waking everyone is not announced. + self.sleep_seen.1 = 0; } } fn creative_origin(batch: &HudBatch) -> (f32, f32) { @@ -12970,6 +12975,7 @@ impl<'a> Game<'a> { lightning_seen: [0; 2], sleeping: None, sleep_timer: 0, + sleep_seen: (0, 0), dim: Dim::Overworld, world_root: PathBuf::new(), travelling: None, diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 8c51a3f2a..561e46533 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -2096,11 +2096,10 @@ impl Game<'_> { } } - /// `SleepStatus.areEnoughSleeping` and `areEnoughDeepSleeping` over the - /// host's player and the guests: of the players not in spectator mode, - /// players_sleeping_percentage of them (at least one) are in bed, and as - /// many have slept 100 ticks. - pub(super) fn enough_slept(&self) -> bool { + /// `SleepStatus.update`'s counts over the host's player and the guests: + /// the players not in spectator mode, how many are in bed, and how many + /// of those have slept 100 ticks. + fn sleep_counts(&self) -> (i64, i64, i64) { let (mut active, mut sleeping, mut deep) = (0i64, 0i64, 0i64); let mut count = |in_bed: bool, timer: u32| { active += 1; @@ -2124,11 +2123,64 @@ impl Game<'_> { count(g.bed.is_some(), g.sleep_timer); } } + (active, sleeping, deep) + } + + /// `SleepStatus.sleepersNeeded`. + fn sleepers_needed(&self, active: i64) -> i64 { let percent = i64::from(self.ui.rules.int("players_sleeping_percentage").max(0)); - let needed = ((active * percent + 99) / 100).max(1); + ((active * percent + 99) / 100).max(1) + } + + /// `SleepStatus.areEnoughSleeping` and `areEnoughDeepSleeping` over the + /// host's player and the guests: of the players not in spectator mode, + /// players_sleeping_percentage of them (at least one) are in bed, and as + /// many have slept 100 ticks. + pub(super) fn enough_slept(&self) -> bool { + let (active, sleeping, deep) = self.sleep_counts(); + let needed = self.sleepers_needed(active); sleeping >= needed && deep >= needed } + /// `ServerLevel.updateSleepingPlayerList` and `announceSleepStatus`: when + /// the players or the sleepers change, a published or dedicated world + /// shows everyone "n/m players sleeping", or "Sleeping through this + /// night" once enough are in bed, on the action bar. + pub(super) fn announce_sleep_status(&mut self) { + let (active, sleeping, _) = self.sleep_counts(); + let (old_active, old_sleeping) = self.sleep_seen; + self.sleep_seen = (active, sleeping); + let changed = (old_sleeping > 0 || sleeping > 0) + && (old_active != active || old_sleeping != sleeping); + let published = self.lan.is_some() || self.options.dedicated.is_some(); + if !changed || !published { + return; + } + // ServerLevel.canSleepThroughNights. + if self.ui.rules.int("players_sleeping_percentage") > 100 { + return; + } + let needed = self.sleepers_needed(active); + let text = if sleeping >= needed { + horizon_client::text::Text::translate("sleep.skipping_night", &[]) + } else { + horizon_client::text::Text::translate( + "sleep.players_sleeping", + &[ + horizon_client::text::Text::literal(sleeping.to_string()), + horizon_client::text::Text::literal(needed.to_string()), + ], + ) + }; + if let Some(host) = self.lan.as_ref() { + host.hub + .overlay_message(horizon_client::lan::data::component_nbt(&text.component())); + } + if self.options.dedicated.is_none() { + self.titles.set_overlay(text, false); + } + } + /// `ServerLevel.wakeUpAllPlayers` for the guests. pub(super) fn wake_guests(&mut self) { if let Some(host) = self.lan.as_mut() { diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index f9b6e8ce7..e19d4fa83 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -470,6 +470,13 @@ impl Hub { overlay: false, })); } + /// `ServerPlayer.sendOverlayMessage` to every guest (the action bar). + pub fn overlay_message(&self, content: Tag) { + self.broadcast(&C::SystemChat(play::SystemChat { + content, + overlay: true, + })); + } /// A chat message from the host (a disguised chat: the host has no /// connection to sign with). pub fn chat(&self, sender: &str, text: &str) { From 5bbb61aec20c2de22f61d9bcebf6136f7a9ba8b5 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:23:23 +0100 Subject: [PATCH 59/84] Angry endermen open their mouth on a server thread --- crates/horizon-client/src/game/lan.rs | 6 +++++- crates/horizon-client/src/game/remote_mob_data.rs | 3 +++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 28ec3fe8a..d4e497628 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -397,7 +397,7 @@ fn mob_meta( } defaults.push((17, serializer::BYTE, Value::Byte(0))); } - // Enderman.DATA_CARRY_STATE. + // Enderman.DATA_CARRY_STATE and DATA_CREEPY (angry: the open mouth). "minecraft:enderman" => { if let Some(state) = e.carried { meta.push(( @@ -406,6 +406,10 @@ fn mob_meta( Value::Id(state.0 as i32), )); } + if e.flag { + meta.push((17, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((17, serializer::BOOLEAN, Value::Bool(false))); } _ => {} } diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index 65bbbfbbe..56302eb8d 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -94,6 +94,9 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti (Species::Slime | Species::MagmaCube, 18, Value::Int(size)) => { m.extra.size = (*size).clamp(1, 127); } + // Enderman.DATA_CREEPY (after DATA_CARRY_STATE): the open mouth + // and raised head of an angry enderman. + (Species::Enderman, 17, Value::Bool(creepy)) => m.extra.flag = *creepy, // Pillager.IS_CHARGING_CROSSBOW: the charge pose (Raider's // IS_CELEBRATING takes 16). (Species::Pillager, 17, Value::Bool(charging)) => m.extra.flag = *charging, From 18217532af91668d2be99db0fecac32a0d9bddd5 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:24:15 +0100 Subject: [PATCH 60/84] Show other players gliding, swimming, spinning and holding a loaded crossbow --- crates/horizon-client/src/game/creatures.rs | 12 ++++++++ crates/horizon-client/src/game/lan.rs | 30 +++++++++++++++++++ crates/horizon-client/src/game/perspective.rs | 29 +++++++++++++----- crates/horizon-client/src/game/remote.rs | 18 +++++++++++ .../src/game/remote_mob_data.rs | 18 +++++++++++ crates/horizon-client/src/lan/hub.rs | 2 +- crates/horizon-client/src/mobs.rs | 21 +++++++++++++ 7 files changed, 122 insertions(+), 8 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2bc40a7af..d377564e7 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -3471,6 +3471,18 @@ impl Game<'_> { &armor, out, ); + if &*mob.kind.id == "minecraft:player" { + // PlayerRenderer's WingsLayer and SpinAttackEffectLayer. + self.player_elytra_geometry( + mob, + mob.extra.chest.as_deref(), + camera, + alpha as f32, + packed, + out, + ); + self.spin_attack_geometry(mob, camera, alpha as f32, packed, out); + } self.mob_block_geometry(mob, camera, alpha, packed, out); // Glowing outlines and a guardian's beam remain visible independently // of whether the body is hidden behind terrain. diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 28ec3fe8a..dd5268a92 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1492,6 +1492,27 @@ impl Game<'_> { .map(|s| s.as_ref().map(|s| s.item.clone())); m.extra.crouching = g.sneaking; m.extra.sprinting = g.sprinting; + // Entity.DATA_POSE and the shared and living flags the others + // get (hub::guest_body): gliding, swimming, Riptide's spin. + let body = lan::hub::guest_body(g); + m.extra.fall_flying = body.gliding; + m.extra.synced_pose = if body.swimming || body.crawling { 3 } else { 0 }; + m.extra.auto_spin_attack = body.spin_attack; + m.velocity = g + .motion + .as_ref() + .map_or(Vec3::new(dx, dy, dz), |motion| motion.velocity); + m.tick_avatar_pose( + g.motion + .as_ref() + .is_some_and(|motion| motion.fluids.was_touching_water), + ); + // CrossbowItem.isCharged: the held crossbow's projectiles. + m.extra.charged = g + .inventory + .get(g.selected) + .and_then(|s| s.as_ref()) + .is_some_and(|s| s.data().is_some_and(|d| !d.charged.is_empty())); // LivingEntity.DATA_EFFECT_PARTICLES: the swirls of its visible effects. let visible = || g.effects.list.iter().filter(|e| e.visible); m.extra.effect_particles = visible() @@ -1558,6 +1579,15 @@ impl Game<'_> { ), out, ); + self.player_elytra_geometry( + m, + m.extra.chest.as_deref(), + camera, + alpha as f32, + packed, + out, + ); + self.spin_attack_geometry(m, camera, alpha as f32, packed, out); self.held_item_geometry(m, camera, alpha, packed, true, out); if !m.glowing { self.cull_entity_vertices(out, entity_start); diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index caf49883b..5b65486d6 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -453,7 +453,14 @@ impl Game<'_> { &self.player_armor_layers(), out, ); - self.player_elytra_geometry(m, camera, alpha as f32, packed, out); + self.player_elytra_geometry( + m, + self.armor[1].as_ref().map(|s| &*s.item), + camera, + alpha as f32, + packed, + out, + ); self.spin_attack_geometry(m, camera, alpha as f32, packed, out); self.held_item_geometry(m, camera, alpha, packed, true, out); } @@ -509,7 +516,14 @@ impl Game<'_> { &self.player_armor_layers(), &mut verts, ); - self.player_elytra_geometry(&m, camera, 1.0, 240 | 240 << 8, &mut verts); + self.player_elytra_geometry( + &m, + self.armor[1].as_ref().map(|s| &*s.item), + camera, + 1.0, + 240 | 240 << 8, + &mut verts, + ); self.held_item_geometry(&m, camera, 1.0, 240 | 240 << 8, false, &mut verts); let height = if m.extra.crouching { 1.5 } else { 1.8 }; // PictureInPictureRenderer: the box centre, (size, size, -size); @@ -548,17 +562,18 @@ impl Game<'_> { } impl Game<'_> { - fn player_elytra_geometry( + /// `WingsLayer` for a player wearing `chest`. + pub(super) fn player_elytra_geometry( &self, m: &Mob, + chest: Option<&str>, camera: glam::DVec3, partial: f32, light: u32, out: &mut Vec, ) { - let Some(asset) = self.armor[1] - .as_ref() - .and_then(|s| self.res.items().get(&s.item)) + let Some(asset) = chest + .and_then(|item| self.res.items().get(item)) .and_then(|i| i.equip_asset.as_ref()) else { return; @@ -598,7 +613,7 @@ impl Game<'_> { } /// `SpinAttackEffectLayer`: Riptide's two boxes turning around a spinning /// player (`SpinAttackEffectModel.setupAnim`). - fn spin_attack_geometry( + pub(super) fn spin_attack_geometry( &self, m: &Mob, camera: glam::DVec3, diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 77e143f9a..3559dbb71 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2029,7 +2029,23 @@ impl Game<'_> { .iter() .map(|(slot, stack)| (*slot, stack.as_ref().map(|s| self.item_name(s.item)))) .collect(); + // CrossbowItem.isCharged: the main hand's `charged_projectiles` + // (AvatarRenderer.getArmPose holds a loaded crossbow up). + let charged = p.slots.iter().find(|(slot, _)| *slot == 0).map(|(_, s)| { + s.as_ref().is_some_and(|s| { + matches!( + s.component(horizon_protocol::item::component::CHARGED_PROJECTILES), + Some(horizon_protocol::item::Component::Stacks(list)) + if !list.is_empty() + ) + }) + }); if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { + if let Some(charged) = charged + && &*m.kind.id == "minecraft:player" + { + m.extra.charged = charged; + } for (slot, item) in items { let e = &mut m.extra; match slot { @@ -3632,6 +3648,8 @@ impl Game<'_> { // a player's body following its walk and look. if player { remote_player_head_turn(m); + // LivingEntity.tick: the glide count, wings and swim amount. + m.tick_avatar_pose(m.fluids.in_water); } else if m.alive() { m.body_rotation_tick(); } diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index 65bbbfbbe..932ecaa32 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -15,6 +15,9 @@ use horizon_protocol::registry::Builtin; fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_entity: i32) { let species = m.species(); let baby = super::lan::baby_index(&m.kind.id); + if &*m.kind.id == "minecraft:player" { + player_poses(m, values); + } for (index, _, value) in values { match (*index, value) { // Entity.DATA_SHARED_FLAGS_ID's FLAG_ONFIRE: Entity.isOnFire on a @@ -115,6 +118,21 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti } } +/// What another player's pose draws from: gliding (Entity.isFallFlying, flag +/// 0x80 of the shared flags), the pose (swimming), Riptide's spin +/// (LivingEntity.isAutoSpinAttack, flag 4) and a loaded crossbow in the +/// hand (the held stack comes with SetEquipment). +fn player_poses(m: &mut Mob, values: &[(u8, i32, Value)]) { + for (index, _, value) in values { + match (*index, value) { + (0, Value::Byte(flags)) => m.extra.fall_flying = flags & -128 != 0, + (6, Value::Id(pose)) => m.extra.synced_pose = (*pose).clamp(0, 17) as u8, + (8, Value::Byte(flags)) => m.extra.auto_spin_attack = flags & 4 != 0, + _ => {} + } + } +} + /// The options of a synched particle list: an entity effect carries its ARGB /// colour, the omens none. fn swirls(list: &[Particle], builtin: &Builtin) -> Vec { diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index f9b6e8ce7..e16d8f36c 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -2714,7 +2714,7 @@ fn ticking_state(rate: f32, frozen: bool) -> C { } /// What the others see of a guest's body, from its server-side state. -fn guest_body(g: &Guest) -> BodyFlags { +pub fn guest_body(g: &Guest) -> BodyFlags { let m = g.motion.as_deref(); BodyFlags { gliding: g.fall_flying, diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 2325c3f5b..00f256343 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -705,6 +705,8 @@ pub struct Extra { pub blocking: bool, pub fall_flying: bool, pub fall_fly_ticks: i32, + /// `Entity.DATA_POSE` of another player, as the server sent it. + pub synced_pose: u8, /// `LivingEntity.isAutoSpinAttack` (Riptide). pub auto_spin_attack: bool, pub main_hand_left: bool, @@ -2321,6 +2323,25 @@ impl SwimAnimation { } } +impl Mob { + /// The part of `LivingEntity.tick` and `aiStep` that animates another + /// player from its synched pose and flags: the glide count, the wings + /// (`elytraAnimationState`) and the swim amount (`updateSwimAmount`). + pub fn tick_avatar_pose(&mut self, in_water: bool) { + let e = &mut self.extra; + e.fall_fly_ticks = if e.fall_flying { + e.fall_fly_ticks + 1 + } else { + 0 + }; + // LivingEntity.isVisuallySwimming: the swimming pose, or the gliding + // pose after the glide ended. + let visually = e.synced_pose == 3 || (!e.fall_flying && e.synced_pose == 1); + e.elytra.tick(e.fall_flying, e.crouching, self.velocity); + e.swim.tick(visually, in_water); + } +} + #[cfg(test)] mod elytra_tests { use super::*; From 1131a2910ddc732a65011d789875cf6d25497090 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:24:43 +0100 Subject: [PATCH 61/84] Apply Haste and Mining Fatigue to the attack speed --- crates/horizon-client/src/game.rs | 3 +-- crates/horizon-client/src/game/dragon.rs | 11 ++++------- crates/horizon-client/src/game/hand.rs | 15 ++++++++++++--- 3 files changed, 17 insertions(+), 12 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 7699e83d7..30c8e5b41 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -7863,8 +7863,7 @@ impl Game<'_> { } /// `Player.getAttackStrengthScale(0.5)`. fn attack_strength_scale(&self) -> f32 { - let speed = self.attack_item_info().map_or(0.0, |i| i.attack_speed); - let delay = 20.0 / (4.0 + speed).max(0.1); + let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed()); ((self.attack_ticks as f32 + 0.5) / delay).clamp(0.0, 1.0) } /// `Player.isSweepAttack`: a charged, grounded sword hit below the movement limit. diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 8f3fdb224..5d8208f5a 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -1031,14 +1031,11 @@ impl Game<'_> { if !self.before_block(d) || self.mob_hit().is_some_and(|m| m.1 < d) { return false; } - let modifiers = self - .attack_item_info() - .map(|i| (i.attack_damage, i.attack_speed)) - .unwrap_or((0.0, 0.0)); - let speed = (4.0 + modifiers.1).max(0.1); - let scale = ((self.attack_ticks as f32 + 0.5) / (20.0 / speed)).clamp(0.0, 1.0); + let hand_damage = self.attack_item_info().map_or(0.0, |i| i.attack_damage); + let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed()); + let scale = ((self.attack_ticks as f32 + 0.5) / delay).clamp(0.0, 1.0); let mut amount = - (1.0 + modifiers.0 + self.effect_attack_bonus()) * (0.2 + scale * scale * 0.8); + (1.0 + hand_damage + self.effect_attack_bonus()) * (0.2 + scale * scale * 0.8); let falling = self .player .as_ref() diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs index d91d3b979..210e62ac5 100644 --- a/crates/horizon-client/src/game/hand.rs +++ b/crates/horizon-client/src/game/hand.rs @@ -289,12 +289,21 @@ impl Game<'_> { // Only alive mobs are hit, so a picked living entity is alive. Some(true) } - /// `Attributes.ATTACK_SPEED` with the main-hand item's modifier. + /// `Attributes.ATTACK_SPEED` with the main-hand item's modifier and the + /// Haste and Mining Fatigue modifiers (`ADD_MULTIPLIED_TOTAL`), clamped to + /// the attribute's range. pub(super) fn main_hand_attack_speed(&self) -> f64 { - horizon_client::attack_strength::BASE_ATTACK_SPEED + let value = horizon_client::attack_strength::BASE_ATTACK_SPEED + self .attack_item_info() - .map_or(0.0, |i| f64::from(i.attack_speed)) + .map_or(0.0, |i| f64::from(i.attack_speed)); + self.potions + .effects + .modifiers() + .into_iter() + .filter(|m| m.0 == "minecraft:attack_speed") + .fold(value, |v, m| v * (1.0 + m.2)) + .clamp(0.0, 1024.0) } /// The item whose attack damage and speed modifiers the player has (`attack_item`). pub(super) fn attack_item_info(&self) -> Option<&horizon_client::items::ItemInfo> { From ffad9e1f0acbde0e338cc8f89c8dda5a1790d588 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:25:21 +0100 Subject: [PATCH 62/84] Keep the styling of the death message on the death screen --- crates/horizon-client/src/game/remote.rs | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 77e143f9a..57e5c7c59 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -191,7 +191,7 @@ pub(super) struct Remote { input: horizon_client::interaction_input::InteractionInput, stop_mining: bool, placing: Option<([i32; 3], u64)>, - death_message: Option, + death_message: Option, player_type: Option>, /// Inventory as last synchronised, for creative-mode slot updates. synced: Vec>, @@ -2233,7 +2233,7 @@ impl Game<'_> { // The component resolves in the client's current language, as // the chat line does, not in the language the session joined // with (`Remote.lang` is the vanilla server-language table). - let message = remote_text(&p.message).plain(); + let message = remote_text(&p.message); let me = self.remote.as_ref().is_some_and(|r| r.entity_id == p.id); if let Some(r) = self.remote.as_mut() { r.death_message = Some(message); @@ -5225,8 +5225,16 @@ impl Game<'_> { if self.screen == Screen::Dead && let Some(message) = &r.death_message { - let tw = HudBatch::text_width(atlas, message); - batch.text(atlas, message, (w - tw) / 2.0, 85.0, u32::MAX, true); + // DeathScreen draws the styled cause component. + let tw = atlas.font.width_text(message); + batch.text_styled( + atlas, + message, + ((w - tw) / 2.0).floor(), + 85.0, + u32::MAX, + true, + ); } } /// Status for `horizon-ctl status`. From 7b84a7ae91fe62175c76024ef497eb7a1d83932a Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:25:43 +0100 Subject: [PATCH 63/84] Let a sweep attack hurt and push back the other players next to the target --- crates/horizon-client/src/game.rs | 35 +++-- crates/horizon-client/src/game/creatures.rs | 3 + crates/horizon-client/src/game/lan.rs | 2 + crates/horizon-client/src/game/lan_pvp.rs | 137 +++++++++++++++++++- 4 files changed, 163 insertions(+), 14 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 7699e83d7..5df9291fe 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -7899,18 +7899,9 @@ impl Game<'_> { self.audio .play("minecraft:entity.player.attack.sweep", from, 1.0, 1.0); } - /// The damage and knockback part of `Player.doSweepAttack` after a sweep - /// hit on the mob at `target`: every other living mob in its box grown by - /// (1, 0.25, 1) and closer than 3 blocks (`distanceToSqr < 9`, in creative - /// too), but the player's allies - /// (`isAlliedTo`), takes `1 + sweeping_damage_ratio * baseDamage` with the - /// weapon's enchantments, scaled by the attack strength, and is pushed 0.4 - /// along the player's yaw. - pub(super) fn sweep_damage(&mut self, target: usize, scale: f32) { - let Some(p) = self.player.as_ref() else { - return; - }; - let from = [p.position.x, p.position.y, p.position.z]; + /// What `Player.doSweepAttack` deals before the target's enchantment + /// bonus and the attack strength: `1 + sweeping_damage_ratio * baseDamage`. + pub(super) fn sweep_base_damage(&self, scale: f32) -> f32 { // `baseDamage` of `Player.attack` before a critical hit (a sweep has // none) and the enchantments: the attack damage attribute with the // strength and weakness effects, scaled by the attack strength. @@ -7926,7 +7917,21 @@ impl Game<'_> { "minecraft:sweeping_damage_ratio", ) .clamp(0.0, 1.0) as f32; - let sweep_damage = 1.0 + ratio * base_damage; + 1.0 + ratio * base_damage + } + /// The damage and knockback part of `Player.doSweepAttack` after a sweep + /// hit on the mob at `target`: every other living mob in its box grown by + /// (1, 0.25, 1) and closer than 3 blocks (`distanceToSqr < 9`, in creative + /// too), but the player's allies + /// (`isAlliedTo`), takes `1 + sweeping_damage_ratio * baseDamage` with the + /// weapon's enchantments, scaled by the attack strength, and is pushed 0.4 + /// along the player's yaw. + pub(super) fn sweep_damage(&mut self, target: usize, scale: f32) { + let Some(p) = self.player.as_ref() else { + return; + }; + let from = [p.position.x, p.position.y, p.position.z]; + let sweep_damage = self.sweep_base_damage(scale); let hit_box = self.mobs[target] .bounds() .inflate(horizon_core::geometry::Vec3::new(1.0, 0.25, 1.0)); @@ -7961,6 +7966,10 @@ impl Game<'_> { .insert(self.mobs[i].id, self.lan_acting); } } + // `getEntitiesOfClass(LivingEntity.class)` takes the other players too. + let mut sweep = self.player_sweep(sweep_damage, scale); + sweep.hit_box = hit_box; + self.sweep_other_players(sweep); } /// `Player.attack`'s sounds when a vehicle takes the hit (it always does, /// and can't be hit critically): knockback when sprinting at full diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2bc40a7af..51437944f 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -46,6 +46,9 @@ pub(super) struct Creatures { pub projectiles: Vec, /// Wind bursts from a guest's turn, waiting for it to end (game/wind.rs). pub wind_bursts: Vec, + /// Sweep attacks from a guest's turn, waiting for it to end + /// (game/lan_pvp.rs). + pub sweeps: Vec, /// Ticks left of the elder guardian's apparition (MobAppearanceParticle). pub elder_apparition: i32, /// The wandering trader spawner's clock. diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 28ec3fe8a..cba61960e 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1166,6 +1166,8 @@ impl Game<'_> { self.lan = Some(host); // A mace's wind burst from a guest's attack. let _ = self.flush_wind_bursts(); + // A sweep attack's reach to the other players from a guest's attack. + self.flush_sweeps(); } fn lan_guest_joined( diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index 65520221a..614d23d79 100644 --- a/crates/horizon-client/src/game/lan_pvp.rs +++ b/crates/horizon-client/src/game/lan_pvp.rs @@ -12,6 +12,7 @@ use horizon_client::{ mobs::Who, projectiles::{Hit, Projectile, ProjectileKind}, }; +use horizon_core::geometry::{Aabb, Vec3}; /// The player projectiles that meet other players: arrows (their hurt), and /// snowballs and eggs, which break on them (`Player.hurtServer` takes no 0 @@ -24,7 +25,7 @@ pub(super) fn meets_players(kind: &ProjectileKind) -> bool { } /// Who a player's attack lands on. -#[derive(Clone, Copy)] +#[derive(Clone, Copy, PartialEq, Eq)] pub(super) enum Victim { Host, Guest(u32), @@ -47,6 +48,26 @@ pub(super) struct Strike { knockback_attack: bool, /// The attacker's team, for the victim's `Player.canHarmPlayer`. team: Option, + /// The sweep's damage to the players around the victim. + sweep_hit: Option, +} + +/// A sweep attack's reach to the other players (`Player.doSweepAttack`), +/// worked out as the attacker. +#[derive(Clone)] +pub(super) struct Sweep { + /// The attacking guest (none: the host). + attacker: Option, + from: [f64; 3], + /// The damage after the enchantments and the attack strength. + damage: f32, + /// The push along the attacker's yaw. + knockback: (f64, f64), + team: Option, + /// The target's box grown by (1, 0.25, 1). + pub(super) hit_box: Aabb, + /// The player the sweep started from, which it spares. + skip: Option, } impl Strike { @@ -113,6 +134,10 @@ impl Game<'_> { let from = [p.position.x, p.position.y, p.position.z]; let (amount, scale, crit, magic) = self.melee_damage("minecraft:player"); let sweep = self.sweep_attack_position(scale, crit); + let sweep_hit = sweep.map(|_| { + let base = self.sweep_base_damage(scale); + self.player_sweep(base, scale) + }); let (strength, knockback_attack) = self.extra_knockback("minecraft:player", scale); let (xd, zd) = self.extra_knockback_direction(); self.attack_ticks = 0; @@ -133,6 +158,7 @@ impl Game<'_> { knockback: (strength, xd, zd), knockback_attack, team: self.player_team().cloned(), + sweep_hit, }) } @@ -300,9 +326,118 @@ impl Game<'_> { }; if let Some(at) = s.sweep.filter(|_| hurt) { self.sweep_attack(at, Some(s.from)); + // The other players next to the victim (Player.doSweepAttack). + let bounds = match victim { + Victim::Host => self.player.as_ref().map(|p| p.bounds()), + Victim::Guest(conn) => host.hub.guest(conn).map(guest_bounds), + }; + if let (Some(sweep), Some(bounds)) = (&s.sweep_hit, bounds) { + self.sweep_players( + host, + &Sweep { + hit_box: bounds.inflate(Vec3::new(1.0, 0.25, 1.0)), + skip: Some(victim), + ..sweep.clone() + }, + ); + } } else { self.audio.play(sound, Some(s.from), 1.0, 1.0); } hurt } + + /// The sweep of the player in place, for the players it reaches: the + /// damage (`1 + ratio * baseDamage`, plus the enchantments against a + /// player, scaled by the attack strength) and who hits. The box is set + /// by the caller. + pub(super) fn player_sweep(&mut self, base: f32, scale: f32) -> Sweep { + let from = self + .player + .as_ref() + .map_or([0.0; 3], |p| [p.position.x, p.position.y, p.position.z]); + let damage = (base + self.enchant_damage_bonus("minecraft:player")) * scale; + Sweep { + attacker: self.lan_acting, + from, + damage, + knockback: self.extra_knockback_direction(), + team: self.player_team().cloned(), + hit_box: Aabb::new(Vec3::ZERO, Vec3::ZERO), + skip: None, + } + } + + /// A sweep from a mob hit reaches the other players. Inside a guest's + /// turn the host holds the other players (`as_guest`), so it waits for + /// the turn to end. + pub(super) fn sweep_other_players(&mut self, sweep: Sweep) { + if self.lan_acting.is_some() { + self.creatures.sweeps.push(sweep); + } else if let Some(mut host) = self.lan.take() { + self.sweep_players(&mut host, &sweep); + self.lan = Some(host); + } + } + + /// The sweeps guests' turns put off. + pub(super) fn flush_sweeps(&mut self) { + for sweep in std::mem::take(&mut self.creatures.sweeps) { + self.sweep_other_players(sweep); + } + } + + /// `Player.doSweepAttack` on the players: each other player in the box, + /// closer than 3 blocks (`distanceToSqr < 9`) and not an ally + /// (`isAlliedTo`), is hurt (`ServerPlayer.canHarmPlayer`: the `pvp` rule) + /// and pushed 0.4 along the attacker's yaw. + pub(super) fn sweep_players(&mut self, host: &mut LanHost, sweep: &Sweep) { + let from = Vec3::new(sweep.from[0], sweep.from[1], sweep.from[2]); + let mut victims = Vec::new(); + if sweep.attacker.is_some() + && self.options.dedicated.is_none() + && !self.spectator() + && let Some(p) = self.player.as_ref() + && !p.health.dead_or_dying() + && p.bounds().intersects(sweep.hit_box) + && p.position.distance_squared(from) < 9.0 + { + victims.push((Victim::Host, self.player_team().cloned())); + } + for g in &host.hub.guests { + if host.hub.here(g) + && g.loaded + && !g.dead + && !g.spectator() + && sweep.attacker != Some(g.conn) + && guest_bounds(g).intersects(sweep.hit_box) + && Vec3::new(g.position[0], g.position[1], g.position[2]).distance_squared(from) + < 9.0 + { + let team = self.score.board.players_team(&g.name).cloned(); + victims.push((Victim::Guest(g.conn), team)); + } + } + let (xd, zd) = sweep.knockback; + let land = |g: &mut Self| { + let hurt = g.mob_hits_player(sweep.damage, sweep.from, "minecraft:player_attack"); + if hurt { + g.knock_back_player(0.4, xd, zd); + } + }; + for (victim, team) in victims { + if sweep.skip == Some(victim) + || horizon_client::scoreboard::teams_allied(team.as_ref(), sweep.team.as_ref()) + || !self.ui.rules.bool("pvp") + { + continue; + } + match victim { + Victim::Host => land(self), + Victim::Guest(conn) => { + self.guest_struck_by(host, conn, land); + } + } + } + } } From 180e2f612a374fc47002465614b7770e806a25be Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:26:12 +0100 Subject: [PATCH 64/84] Chat lines: server message bar and tooltip, item hover, run_command clicks, Shift insertion --- crates/horizon-client-core/src/component.rs | 24 ++++-- crates/horizon-client-core/src/text.rs | 25 +++++- crates/horizon-client/src/chat.rs | 37 +++++--- crates/horizon-client/src/game/chat.rs | 95 ++++++++++++++------- crates/horizon-client/src/game/remote.rs | 6 +- crates/horizon-client/src/item_data.rs | 5 ++ 6 files changed, 140 insertions(+), 52 deletions(-) diff --git a/crates/horizon-client-core/src/component.rs b/crates/horizon-client-core/src/component.rs index 5b828b305..21416e1c9 100644 --- a/crates/horizon-client-core/src/component.rs +++ b/crates/horizon-client-core/src/component.rs @@ -174,19 +174,31 @@ fn object_style(o: &serde_json::Map) -> Style { let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned); style.click = match e.get("action").and_then(Value::as_str) { Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand), + Some("run_command") => text("command").map(crate::text::ClickEvent::RunCommand), Some("copy_to_clipboard") => { text("value").map(crate::text::ClickEvent::CopyToClipboard) } _ => None, }; } - // HoverEvent.ShowText. - if let Some(e) = o.get("hover_event").and_then(Value::as_object) - && e.get("action").and_then(Value::as_str) == Some("show_text") - && let Some(value) = e.get("value") - { - style.hover = Some(Box::new(to_text(value, &mut |s| Text::literal(s)))); + // HoverEvent.ShowText and ShowItem. + if let Some(e) = o.get("hover_event").and_then(Value::as_object) { + match e.get("action").and_then(Value::as_str) { + Some("show_text") => { + if let Some(value) = e.get("value") { + style.hover = Some(Box::new(to_text(value, &mut |s| Text::literal(s)))); + } + } + Some("show_item") if e.get("id").is_some_and(Value::is_string) => { + style.hover_item = Some(Box::new(Value::Object(e.clone()))); + } + _ => {} + } } + style.insertion = o + .get("insertion") + .and_then(Value::as_str) + .map(str::to_owned); style } /// `ComponentSerialization.CODEC` decoding into text. `selector` components diff --git a/crates/horizon-client-core/src/text.rs b/crates/horizon-client-core/src/text.rs index 0a2b6eadb..1f71ae4a9 100644 --- a/crates/horizon-client-core/src/text.rs +++ b/crates/horizon-client-core/src/text.rs @@ -43,6 +43,8 @@ pub fn named_color(name: &str) -> Option { #[derive(Clone, Debug, PartialEq, Eq)] pub enum ClickEvent { SuggestCommand(String), + /// `ClickEvent.RunCommand`: the command, with or without its `/`. + RunCommand(String), CopyToClipboard(String), /// A local file to open with the system handler. /// Only allow this in locally constructed messages, never server/LAN text. @@ -61,6 +63,10 @@ pub struct Style { pub click: Option, /// Hover text. pub hover: Option>, + /// `HoverEvent.ShowItem`: the event's `{id, count?, components?}` object. + pub hover_item: Option>, + /// `Style.insertion`: the text a Shift-click puts in the chat box. + pub insertion: Option, /// The font (`FontDescription.Resource`), a full id like /// `minecraft:alt`; the default font when unset. pub font: Option, @@ -90,6 +96,12 @@ impl Style { if self.hover.is_none() { self.hover.clone_from(&base.hover); } + if self.hover_item.is_none() { + self.hover_item.clone_from(&base.hover_item); + } + if self.insertion.is_none() { + self.insertion.clone_from(&base.insertion); + } if self.font.is_none() { self.font.clone_from(&base.font); } @@ -495,7 +507,7 @@ impl Text { } /// The style fields of a component's JSON. -const STYLE_KEYS: [&str; 9] = [ +const STYLE_KEYS: [&str; 10] = [ "color", "bold", "italic", @@ -504,6 +516,7 @@ const STYLE_KEYS: [&str; 9] = [ "obfuscated", "click_event", "hover_event", + "insertion", "font", ]; /// Style.Serializer: the fields a style sets. @@ -535,6 +548,9 @@ fn style_json(style: &Style) -> Vec<(String, Value)> { ClickEvent::CopyToClipboard(value) => { json!({ "action": "copy_to_clipboard", "value": value }) } + ClickEvent::RunCommand(command) => { + json!({ "action": "run_command", "command": command }) + } ClickEvent::OpenFile(path) => json!({ "action": "open_file", "path": path }), }; out.push(("click_event".to_owned(), event)); @@ -544,6 +560,13 @@ fn style_json(style: &Style) -> Vec<(String, Value)> { "hover_event".to_owned(), json!({ "action": "show_text", "value": hover.component() }), )); + } else if let Some(Value::Object(item)) = style.hover_item.as_deref() { + let mut event = item.clone(); + event.insert("action".into(), "show_item".into()); + out.push(("hover_event".to_owned(), Value::Object(event))); + } + if let Some(insertion) = &style.insertion { + out.push(("insertion".to_owned(), insertion.clone().into())); } if let Some(font) = &style.font { out.push(("font".to_owned(), font.clone().into())); diff --git a/crates/horizon-client/src/chat.rs b/crates/horizon-client/src/chat.rs index 04b9d486c..060bbf303 100644 --- a/crates/horizon-client/src/chat.rs +++ b/crates/horizon-client/src/chat.rs @@ -458,26 +458,34 @@ impl Chat { pub fn hover_at(&self, font: &crate::font::Font, height: i32, x: f64, y: f64) -> Option { self.style_at(font, height, x, y)?.hover.map(|h| *h) } - /// ChatComponent.getClickedComponentStyleAt. - fn style_at( - &self, - font: &crate::font::Font, - height: i32, - x: f64, - y: f64, - ) -> Option { + /// The wrapped line under a GUI-space cursor while chat is focused, and + /// the cursor's x within it (the text starts at 0). + fn line_at(&self, height: i32, x: f64, y: f64) -> Option<(&Line, f64)> { let scale = self.options.scale as f32; - let mut x = x / f64::from(scale) - 4.0; + let x = x / f64::from(scale) - 4.0; let bottom = hud_layout::floor((height - 40) as f32 / scale); let from_bottom = f64::from(bottom) - y / f64::from(scale); - if x < 0.0 || x >= f64::from(self.max_width()) || from_bottom <= 0.0 { + if x >= f64::from(self.max_width()) || from_bottom <= 0.0 { return None; } let row = (from_bottom / f64::from(self.options.line_height())).ceil() as usize - 1; if row >= self.lines_per_page(true) { return None; } - let line = self.lines.get(self.scroll + row)?; + Some((self.lines.get(self.scroll + row)?, x)) + } + /// ChatComponent.getClickedComponentStyleAt. + pub fn style_at( + &self, + font: &crate::font::Font, + height: i32, + x: f64, + y: f64, + ) -> Option { + let (line, mut x) = self.line_at(height, x, y)?; + if x < 0.0 { + return None; + } let content = line.content.resolve_legacy(); for (c, style) in content.chars() { x -= f64::from(font.advance(c, style)); @@ -487,6 +495,13 @@ impl Chat { } None } + /// Whether the cursor is on a line's indicator bar while chat is focused + /// (`DrawingFocusedGraphicsAccess.handleTag`), whose tooltip is the + /// message tag's text. + pub fn indicator_at(&self, height: i32, x: f64, y: f64) -> bool { + self.line_at(height, x, y) + .is_some_and(|(line, x)| line.indicator.is_some() && (-4.0..-2.0).contains(&x)) + } /// Plain text of the newest messages (for tests and the control socket). pub fn recent_lines(&self, n: usize) -> Vec { self.messages diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index 03174c009..ffc09357a 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -682,12 +682,25 @@ impl Game<'_> { } else { return; } - match self.ui.chat.click_at( + let Some(style) = self.ui.chat.style_at( &self.gui.atlas.font, height as i32, cursor.0 as f64, cursor.1 as f64, - ) { + ) else { + return; + }; + // ChatScreen.handleComponentClicked: with Shift held only an + // insertion acts, else only the click event. + if self.has_shift_down() { + if let Some(insertion) = style.insertion + && let Some(screen) = self.ui.chat_screen.as_mut() + { + screen.type_text(&m, &c, &insertion); + } + return; + } + match style.click { Some(ClickEvent::CopyToClipboard(value)) => { use horizon_client::clipboard::Clipboard; self.clipboard.set(&value); @@ -700,9 +713,26 @@ impl Game<'_> { screen.suggest_command(&m, &c, &command); } } + Some(ClickEvent::RunCommand(command)) => self.click_command(&command), None => {} } } + /// `Screen.clickCommandAction`: run a clicked command as the player + /// without adding it to the chat history. A client mod's command goes + /// first, as `ClientPacketListener.sendUnattendedCommand` lets client + /// commands take it. (Vanilla asks first when the command fails to + /// parse; here the server answers it.) + fn click_command(&mut self, command: &str) { + let command = command.strip_prefix('/').unwrap_or(command); + if self.mod_command(command) { + return; + } + if self.remote.is_some() { + self.send_chat(&format!("/{command}")); + } else if !self.local_server_mod_command(command) { + self.run_command(command); + } + } /// Chat lines over the HUD (focused while the chat screen is open). pub(super) fn draw_chat(&mut self, batch: &mut HudBatch) { let focused = self.screen == Screen::Chat; @@ -737,17 +767,39 @@ impl Game<'_> { let draws = screen.draw(&m, mouse, blink, background); horizon_client::screen_draw::paint(batch, &self.gui.atlas, &draws); self.ui.chat_screen = Some(screen); - // The hovered message part's tooltip, one row per line of its text. - if let Some(hover) = self.ui.chat.hover_at( - &self.gui.atlas.font, - batch.height as i32, - f64::from(self.cursor.0), - f64::from(self.cursor.1), - ) { - let lines = hover_rows(&hover); + // The hovered message part's tooltip (`renderComponentHoverEffect`), + // or the text of the message tag under the cursor. + let height = batch.height as i32; + let (cx, cy) = (f64::from(self.cursor.0), f64::from(self.cursor.1)); + let wrap = (batch.width as i32 / 2).max(200); + if let Some(style) = self.ui.chat.style_at(&self.gui.atlas.font, height, cx, cy) { + if let Some(hover) = style.hover { + let lines = self.wrapped_rows(&hover, wrap); + self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1); + } else if let Some(stack) = style + .hover_item + .as_deref() + .and_then(horizon_client::item_data::stack_from_hover) + .filter(|s| self.res.items().get(&s.item).is_some()) + { + self.draw_stack_tooltip(batch, &stack, self.cursor.0, self.cursor.1); + } + } else if self.ui.chat.indicator_at(height, cx, cy) { + // GuiMessageTag.systemSinglePlayer's text, split at 210. + let tag = Text::translate("chat.tag.system_single_player", &[]); + let lines = self.wrapped_rows(&tag, 210); self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1); } } + /// `Font.split`: a tooltip text wrapped at `width`, one white row per line. + fn wrapped_rows(&self, text: &Text, width: i32) -> Vec<(Text, u32)> { + let split = self + .gui + .atlas + .font + .split(&text.resolve_legacy(), width as f32); + split.into_iter().map(|row| (row, u32::MAX)).collect() + } /// Advance the overworld clock (ServerClockManager.tick) when /// `advance_time` allows it. pub(super) fn advance_clock(&mut self) { @@ -1022,26 +1074,3 @@ fn write_difficulty(world: &std::path::Path, difficulty: u8) -> horizon_client:: fn owner_permission(allow_commands: bool) -> u8 { if allow_commands { 4 } else { 0 } } - -/// A hover text's rows for the tooltip: split at line breaks, each in the -/// colour of its first styled character (white without one). -fn hover_rows(hover: &horizon_client::text::Text) -> Vec<(String, u32)> { - let mut rows = vec![(String::new(), None)]; - for (c, style) in hover.resolve_legacy().chars() { - if c == '\n' { - rows.push((String::new(), None)); - continue; - } - let row = rows.last_mut().expect("one row"); - if row.0.is_empty() { - row.1 = style.color; - } - row.0.push(c); - } - rows.into_iter() - .map(|(text, color)| { - let [_, r, g, b] = color.unwrap_or(0xFF_FFFF).to_be_bytes(); - (text, horizon_client::hud::rgba(r, g, b, 255)) - }) - .collect() -} diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 77e143f9a..707159e44 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -666,10 +666,14 @@ impl Game<'_> { } let text = content.plain(); log::info!("[chat] {text}"); + // addServerSystemMessage and addClientSystemMessage both carry + // GuiMessageTag.systemSinglePlayer: the grey bar at the line's left. + let indicator = (source != horizon_client::chat::ChatSource::Player) + .then_some(horizon_client::chat::SYSTEM_INDICATOR); self.ui.chat.add( &self.gui.atlas, content, - None, + indicator, source, self.ticks, self.screen == Screen::Chat, diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs index 253bc6cc5..f706ed812 100644 --- a/crates/horizon-client/src/item_data.rs +++ b/crates/horizon-client/src/item_data.rs @@ -396,6 +396,11 @@ fn template_from(tag: &Tag) -> Option { } } } +/// The stack a `show_item` hover event holds (`HoverEvent.ShowItem`): its +/// `{id, count?, components?}` object. +pub fn stack_from_hover(event: &serde_json::Value) -> Option { + template_from(&crate::scoreboard::json_to_tag(event)) +} /// Sorted-key, type-annotated text of a tag (the differential harnesses /// print the same form from the vanilla side). pub fn canon_tag(tag: &Tag) -> String { From ca83704cbb6d4634b5fe8053668eb0a51b76e71b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:26:12 +0100 Subject: [PATCH 65/84] Add zombie village sieges --- crates/horizon-client/src/game/creatures.rs | 1 + crates/horizon-client/src/game/raids.rs | 146 ++++++++++++++++++++ 2 files changed, 147 insertions(+) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2bc40a7af..e669fc703 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -480,6 +480,7 @@ impl Game<'_> { if self.ui.rules.bool("spawn_mobs") { self.tick_wandering_trader(); self.tick_patrol_spawner(); + self.tick_village_siege(); } self.tick_raids(); self.tick_creature_entities() diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs index da7c79394..e5e3f2790 100644 --- a/crates/horizon-client/src/game/raids.rs +++ b/crates/horizon-client/src/game/raids.rs @@ -23,6 +23,7 @@ use std::collections::{HashMap, HashSet}; #[derive(Default)] pub(super) struct Raiding { patrol: PatrolSpawner, + siege: Siege, /// The raids of the dimension the player is in, and that dimension. raids: Raids, loaded: Option, @@ -38,6 +39,17 @@ pub(super) struct Raiding { homes: HashMap>)>, } +/// `VillageSiege`: whether tonight is a siege, whether the spot is chosen, +/// and the zombies still to spawn there. +#[derive(Default)] +struct Siege { + tonight: bool, + set_up: bool, + zombies_to_spawn: i32, + next_spawn_time: i32, + spot: [i32; 3], +} + impl Raiding { /// Exchange the level-held parts (`ServerLevel.getRaids`) with another /// level's (game/levels.rs). @@ -1187,6 +1199,140 @@ impl Game<'_> { self.spawn_event_mob("minecraft:pillager", at, m.leader, raider::Reason::Patrol); } } + /// `VillageSiege.tick`: at midnight one night in ten, 20 zombies spawn + /// two ticks apart near a village 32 blocks from a player standing in it. + pub(super) fn tick_village_siege(&mut self) { + if self.dim != Dim::Overworld { + return; + } + let enemies = self.ui.rules.bool("spawn_mobs") && self.ui.rules.bool("spawn_monsters"); + if self.sky_darken() < 4 || !enemies { + self.raiding.siege.tonight = false; + self.raiding.siege.set_up = false; + return; + } + // ClockTimeMarkers.ROLL_VILLAGE_SIEGE: tick 18000 of the 24000 tick day. + if self.world.day_time.rem_euclid(24000) == 18000 { + self.raiding.siege.tonight = self.world.random.next_int_bound(10).unwrap_or(1) == 0; + } + if !self.raiding.siege.tonight { + return; + } + if !self.raiding.siege.set_up { + if !self.try_to_setup_siege() { + return; + } + self.raiding.siege.set_up = true; + } + if self.raiding.siege.next_spawn_time > 0 { + self.raiding.siege.next_spawn_time -= 1; + return; + } + self.raiding.siege.next_spawn_time = 2; + if self.raiding.siege.zombies_to_spawn > 0 { + self.try_spawn_siege_zombie(); + self.raiding.siege.zombies_to_spawn -= 1; + } else { + self.raiding.siege.tonight = false; + } + } + /// `ServerLevel.isVillage`: within one section of a village. + fn is_village(centers: &HashSet<(i32, i32, i32)>, pos: [i32; 3]) -> bool { + sections_to_village(centers, section(pos)) <= 1 + } + /// `VillageSiege.tryToSetupSiege`: the first player standing in a village + /// picks a spot 32 blocks away (ten tries); true when one stood in a + /// village, even if no spot was found. + fn try_to_setup_siege(&mut self) -> bool { + let centers = self.village_centers(); + for player in self.level_players() { + if player.spectator { + continue; + } + let center = block_of(player.position); + if !Self::is_village(¢ers, center) + || self.natural_level().biome_tag( + "minecraft:without_zombie_sieges", + center[0], + center[1], + center[2], + ) + { + continue; + } + for _ in 0..10 { + let angle = self.world.random.next_float() * std::f32::consts::TAU; + let spot = [ + center[0] + (angle.cos() * 32.0).floor() as i32, + center[1], + center[2] + (angle.sin() * 32.0).floor() as i32, + ]; + if self.find_siege_spawn_pos(¢ers, spot).is_some() { + self.raiding.siege.spot = spot; + self.raiding.siege.next_spawn_time = 0; + self.raiding.siege.zombies_to_spawn = 20; + break; + } + } + return true; + } + false + } + /// `VillageSiege.trySpawn`: one zombie, in a random yaw. + fn try_spawn_siege_zombie(&mut self) { + let centers = self.village_centers(); + let spot = self.raiding.siege.spot; + let Some(at) = self.find_siege_spawn_pos(¢ers, spot) else { + return; + }; + let Some(id) = self.spawn_event_mob("minecraft:zombie", at, false, raider::Reason::Event) + else { + return; + }; + let yaw = self.world.random.next_float() * 360.0; + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + (m.yaw, m.previous_yaw, m.body_yaw, m.previous_body_yaw) = (yaw, yaw, yaw, yaw); + (m.head_yaw, m.previous_head_yaw) = (yaw, yaw); + } + self.spawn_jockeys(id, false); + } + /// `VillageSiege.findRandomSpawnPos`: ten tries within 8 blocks of the + /// spot for a village column where a zombie may spawn. + fn find_siege_spawn_pos( + &mut self, + centers: &HashSet<(i32, i32, i32)>, + spot: [i32; 3], + ) -> Option<[f64; 3]> { + let mut random = std::mem::replace( + &mut self.world.random, + horizon_core::random::LegacyRandom::new(0), + ); + let mut found = None; + for _ in 0..10 { + let x = spot[0] + random.next_int_bound(16).unwrap_or(0) - 8; + let z = spot[2] + random.next_int_bound(16).unwrap_or(0) - 8; + if !self.world.chunks.contains_key(&(x >> 4, z >> 4)) { + continue; + } + let y = self.surface_height(x, z); + if Self::is_village(centers, [x, y, z]) + && spawn_rules::check_spawn_rules( + Species::Zombie, + &self.natural_level(), + spawn_rules::Reason::Event, + &mut random, + x, + y, + z, + ) + { + found = Some([f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5]); + break; + } + } + self.world.random = random; + found + } /// A raider's ominous banner (drop chance 2.0: always dropped) and a /// patrol captain's ominous bottle (`entities/pillager`). /// `OminousBottleAmplifier.onConsume`: Bad Omen for 100 minutes at the From e74a1fe46155aad64f29ac0ae5d05e151632d0a3 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:31:46 +0100 Subject: [PATCH 66/84] Use every player in the level for patrols, sniffers, allays, trap horses and other world checks on the server thread --- crates/horizon-client/src/entity_nbt.rs | 14 +++++-- crates/horizon-client/src/game/allays.rs | 41 +++++++++++++++++-- crates/horizon-client/src/game/creatures.rs | 14 +++---- crates/horizon-client/src/game/dragon.rs | 13 +++--- crates/horizon-client/src/game/lan_actions.rs | 5 ++- crates/horizon-client/src/game/passengers.rs | 17 +++++--- crates/horizon-client/src/game/raids.rs | 18 ++++---- crates/horizon-client/src/game/sculk.rs | 40 ++++++++---------- crates/horizon-client/src/game/sniffers.rs | 30 ++++++++------ 9 files changed, 119 insertions(+), 73 deletions(-) diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index c49af48c9..d175a14fb 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -450,7 +450,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { "memories", Tag::compound([( "minecraft:liked_player", - Tag::compound([("value", Tag::IntArray(vec![0, 0, 0, 1]))]), + Tag::compound([( + "value", + Tag::IntArray(m.extra.owner.unwrap_or([0, 0, 0, 1]).to_vec()), + )]), )]), )]), ); @@ -994,11 +997,14 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.extra.ints[1] = number(first.get("count")).unwrap_or(1) as i32; } m.extra.egg_time = number(tag.get("DuplicationCooldown")).unwrap_or(0) as i32; - m.extra.tame = tag + let liked = tag .get("Brain") .and_then(|b| b.get("memories")) - .and_then(|b| b.get("minecraft:liked_player")) - .is_some(); + .and_then(|b| b.get("minecraft:liked_player")); + m.extra.tame = liked.is_some(); + m.extra.owner = liked + .and_then(|l| l.get("value")) + .and_then(|v| crate::save::uuid_from_tag(Some(v))); } if crate::mobs::camel::is_camel(m.species()) { let sitting = matches!(tag.get("LastPoseTick"), Some(Tag::Long(v)) if *v < 0); diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs index bed835663..10ad5c315 100644 --- a/crates/horizon-client/src/game/allays.rs +++ b/crates/horizon-client/src/game/allays.rs @@ -8,7 +8,6 @@ use horizon_core::random::RandomSource; impl Game<'_> { pub(super) fn tick_allays(&mut self) { let griefing = self.ui.rules.bool("mob_griefing"); - let player = self.player.as_ref().map(|p| p.position); // The playing jukeboxes, found at the first allay: no allay starts // or stops one, and the block entities run into the thousands. let mut jukeboxes: Option> = None; @@ -58,7 +57,7 @@ impl Game<'_> { }; let Some((j, _)) = wanted else { self.mobs[i].extra.point = None; - self.allay_deliver(i, player); + self.allay_deliver(i); continue; }; let e = &self.dropped[j]; @@ -90,14 +89,46 @@ impl Game<'_> { } } } + /// `AllayAi.getLikedPlayer`: the player the allay was given an item by, + /// found by UUID among the host and the guests of the level (the window + /// is a guest on the server thread), when they are not a spectator and + /// within 64 blocks. + fn allay_liked_player(&self, i: usize) -> Option { + let m = &self.mobs[i]; + if !m.extra.tame { + return None; + } + // An allay saved before its player was kept belongs to the host. + let uuid = m + .extra + .owner + .filter(|u| *u != [0, 0, 0, 1]) + .or(self.level.player_uuid) + .unwrap_or([0, 0, 0, 1]); + let host = self + .player_view() + .filter(|p| !p.spectator && self.level.player_uuid.unwrap_or([0, 0, 0, 1]) == uuid) + .map(|p| p.position); + let found = host.or_else(|| { + self.lan_present() + .into_iter() + .find(|p| p.uuid == uuid && !p.spectator) + .map(|p| { + horizon_core::geometry::Vec3::new(p.position[0], p.position[1], p.position[2]) + }) + }); + found.filter(|p| p.distance_squared(m.position) < 64.0 * 64.0) + } /// `GoAndGiveItemsToTarget` / `AllayAi.throwItem`: within 3 blocks of /// the deposit, one item a tick, each restarting the three-second pause /// before it picks anything up again. - fn allay_deliver(&mut self, i: usize, player: Option) { + fn allay_deliver(&mut self, i: usize) { let m = &self.mobs[i]; if m.extra.ints[1] <= 0 { return; } + let player = self.allay_liked_player(i); + let m = &self.mobs[i]; let target = match m.extra.home.filter(|_| m.extra.ints[2] > 0) { Some(h) => horizon_core::geometry::Vec3::new( f64::from(h[0]) + 0.5, @@ -166,11 +197,14 @@ impl Game<'_> { self.consume_held(); return true; } + let acting = self.acting_uuid(); let holds = m.extra.main_hand.is_some(); if !holds && !item.is_empty() { let m = &mut self.mobs[index]; m.extra.main_hand = Some(item.into()); m.extra.tame = true; + // `Allay.mobInteract` remembers LIKED_PLAYER by UUID. + m.extra.owner = Some(acting); self.audio .play("minecraft:entity.allay.item_given", Some(at), 2.0, 1.0); self.consume_held(); @@ -185,6 +219,7 @@ impl Game<'_> { .unwrap_or_else(|| "minecraft:air".into()); let carried = std::mem::take(&mut m.extra.ints[1]); m.extra.tame = false; + m.extra.owner = None; self.audio .play("minecraft:entity.allay.item_taken", Some(at), 2.0, 1.0); if carried > 0 { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2bc40a7af..b6720b928 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -424,9 +424,10 @@ 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()), + // The first player in the level: a server has no player of its own. difficulty: self.local_difficulty( - self.player - .as_ref() + self.level_players() + .first() .map_or([0.0; 3], |p| [p.position.x, p.position.y, p.position.z]), ), } @@ -3754,13 +3755,10 @@ impl Game<'_> { f64::from((pos[0] >> 4) * 16 + 8), f64::from((pos[2] >> 4) * 16 + 8), ]; - let spectator = self.spectator(); - let Some(close) = self.player.as_ref().filter(|_| !spectator).map(|p| { + let close = self.level_players().iter().any(|p| { let (dx, dz) = (p.position.x - centre[0], p.position.z - centre[1]); - dx * dx + dz * dz < 16384.0 - }) else { - return; - }; + !p.spectator && dx * dx + dz * dz < 16384.0 + }); if !close { return; } diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 8f3fdb224..2970d6e74 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -2859,14 +2859,11 @@ impl Game<'_> { let (a, b) = (room.min_position(), room.max_position()); lo.x < b.x && hi.x > a.x && lo.y < b.y && hi.y > a.y && lo.z < b.z && hi.z > a.z }; - let player = self.player.as_ref().is_some_and(|p| { - let w = f64::from(p.dimensions.width) / 2.0; - let h = f64::from(p.dimensions.height); - touches( - Vec3::new(p.position.x - w, p.position.y, p.position.z - w), - Vec3::new(p.position.x + w, p.position.y + h, p.position.z + w), - ) - }); + // Level.getEntities: the host's player and every guest in the level. + let player = self + .fight_players() + .iter() + .any(|p| !p.spectator && touches(p.bounds.min_position(), p.bounds.max_position())); player || self.crystals.iter().any(|c| { touches( diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 8c51a3f2a..6587ed6b9 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -2321,7 +2321,10 @@ impl Game<'_> { if let Some((at, velocity)) = soul { super::lan_particles::send_soul_particle(host, at, velocity); } - self.as_guest(host, conn, |game| game.tick_player_sculk_events()); + self.as_guest(host, conn, |game| { + game.sculk_step_on_player(); + game.tick_player_sculk_events(); + }); for event in events { match event { MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at), diff --git a/crates/horizon-client/src/game/passengers.rs b/crates/horizon-client/src/game/passengers.rs index 8f205c484..c39a6d1af 100644 --- a/crates/horizon-client/src/game/passengers.rs +++ b/crates/horizon-client/src/game/passengers.rs @@ -279,11 +279,13 @@ impl Game<'_> { /// horse is a trap for fifteen minutes; a player within ten blocks springs /// it. pub(super) fn tick_skeleton_traps(&mut self) { - let player = self - .player - .as_ref() - .filter(|p| !p.health.dead_or_dying()) - .map(|p| p.position); + // `Level.hasNearbyAlivePlayer`: alive, not a spectator, in the level. + let players: Vec<_> = self + .level_players() + .into_iter() + .filter(|p| p.alive && !p.spectator) + .map(|p| p.position) + .collect(); let mut sprung = Vec::new(); for m in &mut self.mobs { if m.species() != Species::SkeletonHorse || !m.extra.trap || !m.alive() { @@ -296,7 +298,10 @@ impl Game<'_> { continue; } } - if player.is_some_and(|p| m.distance_sqr(p) < TRAP_RANGE * TRAP_RANGE) { + if players + .iter() + .any(|&p| m.distance_sqr(p) < TRAP_RANGE * TRAP_RANGE) + { sprung.push(m.id); } } diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs index da7c79394..89fca4571 100644 --- a/crates/horizon-client/src/game/raids.rs +++ b/crates/horizon-client/src/game/raids.rs @@ -102,11 +102,12 @@ impl RaidLevel for Lvl<'_, '_> { && g.res.facts().is_air(g.world.block(x, y, z)) } fn player(&self) -> Option { - let p = self.game.player.as_ref()?; + // The first player in the level: a server has no player of its own. + let p = self.game.level_players().into_iter().next()?; Some(RaidPlayer { position: [p.position.x, p.position.y, p.position.z], block: block_of(p.position), - alive: !p.health.dead_or_dying(), + alive: p.alive, }) } } @@ -174,12 +175,13 @@ impl PatrolLevel for PatrolCx<'_, '_, '_> { fn bright_outside(&self) -> bool { self.level.game.dim == Dim::Overworld && self.level.game.sky_darken() < 4 } + /// `PatrolSpawner.tick` picks from `level.players()`: the local player + /// and every guest in the level. fn patrol_players(&self) -> Vec<([i32; 3], bool)> { - let g = self.level.game; - g.player - .as_ref() - .map(|p| (block_of(p.position), g.spectator())) - .into_iter() + self.level + .players + .iter() + .map(|p| (block_of(p.position), p.spectator)) .collect() } fn sections_to_village(&self, pos: [i32; 3]) -> i32 { @@ -633,7 +635,7 @@ impl Game<'_> { /// `Raid.playSound`: the horn, 13 blocks away from the player toward the /// wave, for players within 64 blocks or in the raid. fn raid_horn(&mut self, id: i32, pos: [i32; 3]) { - let Some(p) = self.player.as_ref().map(|p| p.position) else { + let Some(p) = self.level_players().first().map(|p| p.position) else { return; }; let in_raid = self.raiding.raids.get(id).is_some_and(|r| r.bar.player); diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs index 7916c46a1..d3111a75f 100644 --- a/crates/horizon-client/src/game/sculk.rs +++ b/crates/horizon-client/src/game/sculk.rs @@ -876,17 +876,26 @@ impl Game<'_> { /// `SculkSensorBlock.stepOn` and `SculkShriekerBlock.stepOn`: standing on /// them is heard (or seen) every tick. fn sculk_step_on(&mut self) { + self.sculk_step_on_player(); let mut standing: Vec<(Who, [f64; 3])> = Vec::new(); - if let Some(p) = self.player.as_ref() - && p.ground.on_ground - { - standing.push((Who::Player, [p.position.x, p.position.y, p.position.z])); - } for m in &self.mobs { if m.alive() && m.on_ground { standing.push((Who::Mob(m.id), [m.position.x, m.position.y, m.position.z])); } } + self.sculk_stand_on(standing); + } + /// `stepOn` for the player in place: the host, or a guest swapped in + /// (`guest_server_tick`), as a server has no player of its own. + pub(super) fn sculk_step_on_player(&mut self) { + if let Some(p) = self.player.as_ref() + && p.ground.on_ground + { + let at = [p.position.x, p.position.y, p.position.z]; + self.sculk_stand_on(vec![(Who::Player, at)]); + } + } + fn sculk_stand_on(&mut self, standing: Vec<(Who, [f64; 3])>) { for (who, at) in standing { // getOnPosLegacy: 0.2 below the feet. let key = ( @@ -1108,23 +1117,10 @@ impl Game<'_> { /// in the way (`isUnobstructed`), and no block collision. fn warden_fits(&self, mob: &Mob) -> bool { let bounds = mob.bounds(); - let player_blocks = !self.spectator() - && self.player.as_ref().is_some_and(|p| { - let w = f64::from(p.dimensions.width) / 2.0; - let b = horizon_core::geometry::Aabb::new( - horizon_core::geometry::Vec3::new( - p.position.x - w, - p.position.y, - p.position.z - w, - ), - horizon_core::geometry::Vec3::new( - p.position.x + w, - p.position.y + f64::from(p.dimensions.height), - p.position.z + w, - ), - ); - !p.health.dead_or_dying() && b.intersects(bounds) - }); + let player_blocks = self + .level_players() + .iter() + .any(|p| p.alive && !p.spectator && p.bounds.intersects(bounds)); if player_blocks || self .mobs diff --git a/crates/horizon-client/src/game/sniffers.rs b/crates/horizon-client/src/game/sniffers.rs index 8e851d028..5027f5c2b 100644 --- a/crates/horizon-client/src/game/sniffers.rs +++ b/crates/horizon-client/src/game/sniffers.rs @@ -5,9 +5,8 @@ use super::Game; use horizon_client::{ items::ItemStack, mobs::{Mob, Species, sniffer}, - particles::Particle, }; -use horizon_core::random::RandomSource; +use horizon_core::{geometry::Vec3, random::RandomSource}; impl Game<'_> { /// The egg item at the parent (`Sniffer.spawnChildFromBreeding`; the @@ -46,15 +45,20 @@ impl Game<'_> { /// block's hit sound between the 1.7th and the 6th second of the /// digging animation) and `playSearchingSound`. pub(super) fn tick_sniffer_effects(&mut self) { - let Some(camera) = self.player.as_ref().map(|p| p.position) else { + // Vanilla runs these on each client: a sniffer within 32 blocks of + // any player in the level (the host and the guests) shows them. + let players = self.level_players(); + if players.is_empty() { return; - }; + } for i in 0..self.mobs.len() { let m = &self.mobs[i]; if m.species() != Species::Sniffer || !m.alive() || m.silent - || m.position.distance_squared(camera) > 32.0 * 32.0 + || !players + .iter() + .any(|p| m.position.distance_squared(p.position) <= 32.0 * 32.0) { continue; } @@ -79,20 +83,20 @@ impl Game<'_> { } let head = sniffer::head_block(m); let below = self.world.block(head[0], head[1] - 1, head[2]); - let Some((sprite, tint)) = self.particle_sprite(below, [head[0], head[1] - 1, head[2]]) - else { + if self + .particle_sprite(below, [head[0], head[1] - 1, head[2]]) + .is_none() + { continue; - }; + } let dust = [ f64::from(head[0]) + 0.5, f64::from(head[1]) + 0.5 - f64::from(0.65_f32), f64::from(head[2]) + 0.5, ]; - for _ in 0..30 { - let particle = - Particle::terrain(&mut self.world.random, dust, [0.0; 3], sprite.clone(), tint); - self.particles.push(particle); - } + // Drawn in this window when it has one, and sent to the players + // within 32 blocks (the server thread's window is one of them). + self.landing_dust(None, below, Vec3::new(dust[0], dust[1], dust[2]), 30, 0.0); if self.mobs[i].age.is_multiple_of(10) { let hit = self.res.facts().get(below).sounds.hit.clone(); self.audio.play(&hit, Some(at), 0.5, 0.5); From 306c6625e90649544ecb3373c0126760076b1c67 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:33:07 +0100 Subject: [PATCH 67/84] Shear snow golems and bogged by hand and use vanilla's snowball spread --- crates/horizon-client/src/game/creatures.rs | 37 +++++++++++++++++++ .../horizon-client/src/game/remote_mob_use.rs | 2 + crates/horizon-client/src/mobs/golem.rs | 4 +- 3 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 2bc40a7af..059ee1c30 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -2857,6 +2857,10 @@ impl Game<'_> { self.swing_arm(); return Ok(true); } + if self.interact_shear_mob(index, &item) { + self.swing_arm(); + return Ok(true); + } // AbstractHorse.mobInteract: feed, equip or ride. if self.interact_mount(index, &item) { self.swing_arm(); @@ -3255,6 +3259,39 @@ impl Game<'_> { } Ok(true) } + /// `SnowGolem.mobInteract` and `Bogged.mobInteract` with shears: the + /// pumpkin or the mushrooms come off (the shearing loot table), the shear + /// game event is posted and the tool takes one damage. + fn interact_shear_mob(&mut self, index: usize, item: &str) -> bool { + let m = &self.mobs[index]; + if item != "minecraft:shears" || !m.alive() || m.extra.sheared { + return false; + } + let (sound, table, height) = match m.species() { + Species::SnowGolem => ( + "minecraft:entity.snow_golem.shear", + "minecraft:shearing/snow_golem", + m.eye_height(), + ), + Species::Bogged => ( + "minecraft:entity.bogged.shear", + "minecraft:shearing/bogged", + f64::from(m.height()), + ), + _ => return false, + }; + let at = m.position; + let tool = self.held().cloned(); + self.audio.play(sound, Some([at.x, at.y, at.z]), 1.0, 1.0); + self.mobs[index].extra.sheared = true; + for stack in self.sequence_loot(table, table, tool.as_ref()) { + self.spawn_at_location(at, height, stack); + } + let ctx = self.who_context(Some(horizon_client::mobs::Who::Player), None); + self.post_game_event("minecraft:shear", [at.x, at.y, at.z], ctx); + self.damage_held_tool(); + true + } pub(super) fn damage_held_tool(&mut self) { if self.creative { return; diff --git a/crates/horizon-client/src/game/remote_mob_use.rs b/crates/horizon-client/src/game/remote_mob_use.rs index 9575cf925..31b1c1ad2 100644 --- a/crates/horizon-client/src/game/remote_mob_use.rs +++ b/crates/horizon-client/src/game/remote_mob_use.rs @@ -61,6 +61,8 @@ impl Game<'_> { ) && !baby } Species::Sheep => item == "minecraft:shears" || item.ends_with("_dye"), + // SnowGolem.mobInteract: shears take the pumpkin off. + Species::SnowGolem => item == "minecraft:shears" && !m.extra.sheared, // Bucketable.bucketMobPickup. Species::Cod | Species::Salmon diff --git a/crates/horizon-client/src/mobs/golem.rs b/crates/horizon-client/src/mobs/golem.rs index c41c34f11..593b855c4 100644 --- a/crates/horizon-client/src/mobs/golem.rs +++ b/crates/horizon-client/src/mobs/golem.rs @@ -309,12 +309,12 @@ fn snowball_attack(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) { let zd = t.position.z - m.position.z; let yo = (xd * xd + zd * zd).sqrt() * 0.2; let mut p = Projectile::new(ProjectileKind::Snowball, start, Some(Who::Mob(m.id))); - // rangedAttackUncertainty: 14 - 4 * difficulty (normal: 6). + // SnowGolem.rangedAttackUncertainty: 12 on every difficulty. p.shoot( &mut crate::projectiles::own_random(m), [xd, yd + yo - start.y, zd], 1.6, - 6.0, + 12.0, ); cx.events.push(MobEvent::Projectile(p)); let pitch = 0.4 / (m.random.next_float() * 0.4 + 0.8); From e2a48d1c36b04f0349326dee852bad403a88d92b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:36:00 +0100 Subject: [PATCH 68/84] Implement the spear's use action: charge, stab, knockback, dismount --- crates/horizon-client/src/first_person.rs | 17 + crates/horizon-client/src/game.rs | 34 ++ .../src/game/commands/world_cmds.rs | 3 +- crates/horizon-client/src/game/creatures.rs | 1 + .../src/game/dispense_fixture.rs | 1 + .../src/game/enchant_effects.rs | 6 +- crates/horizon-client/src/game/item_draw.rs | 3 + crates/horizon-client/src/game/lan.rs | 21 +- crates/horizon-client/src/game/lan_actions.rs | 6 + crates/horizon-client/src/game/mace.rs | 24 +- crates/horizon-client/src/game/remote.rs | 12 +- crates/horizon-client/src/game/spear.rs | 330 ++++++++++++++++ crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/mobs.rs | 10 + crates/horizon-client/src/mobs/anim.rs | 49 ++- crates/horizon-client/src/mobs/creaking.rs | 1 + crates/horizon-client/src/mobs/guardian.rs | 5 +- crates/horizon-client/src/mobs/render.rs | 18 +- crates/horizon-client/src/mobs/sulfur_cube.rs | 1 + crates/horizon-client/src/spear.rs | 351 ++++++++++++++++++ 20 files changed, 878 insertions(+), 16 deletions(-) create mode 100644 crates/horizon-client/src/game/spear.rs create mode 100644 crates/horizon-client/src/spear.rs diff --git a/crates/horizon-client/src/first_person.rs b/crates/horizon-client/src/first_person.rs index 0735ce2ba..12c97dfa0 100644 --- a/crates/horizon-client/src/first_person.rs +++ b/crates/horizon-client/src/first_person.rs @@ -26,6 +26,13 @@ pub enum ItemPose { Bow { ticks_used: f32, }, + /// A spear being charged (`ItemUseAnimation.SPEAR`): the time held and + /// the ticks since its last hit's feedback. + Spear { + kinetic: crate::spear::Kinetic, + time_held: f32, + ticks_since_hit: f32, + }, Crossbow { ticks_used: Option, charge_duration: f32, @@ -69,6 +76,16 @@ pub fn item_pose(left: bool, inverse_height: f32, attack: f32, pose: ItemPose) - if matches!(pose, ItemPose::Using) { return m; } + // The spear's own place in the hand, without the equip height. + if let ItemPose::Spear { + kinetic, + time_held, + ticks_since_hit, + } = pose + { + return Mat4::from_translation(Vec3::new(invert * 0.56, -0.52, -0.72)) + * crate::spear::first_person_use(&kinetic, ticks_since_hit, time_held, !left); + } if matches!(pose, ItemPose::SpinAttack) { return m * Mat4::from_translation(Vec3::new(invert * -0.4, 0.8, 0.3)) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 7699e83d7..da8db2cb7 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -165,6 +165,7 @@ mod shield; mod sign_edit; mod sniffers; mod spawner; +mod spear; mod spill; mod startup_menu; mod station_control; @@ -1681,6 +1682,18 @@ struct Game<'a> { lan_entity_events: Vec<(i32, i8, [f64; 3])>, /// Successful crits (attacking guest, hit entity), queued while the hub is taken. lan_critical_hits: Vec<(Option, i32, bool)>, + /// Spear stabs that landed (the stabbing guest), queued while the hub is + /// taken: `broadcastEntityEvent(player, 2)`. + lan_kinetic_hits: Vec>, + /// `LivingEntity.recentKineticEnemies`: when each player (a guest, or the + /// window's own) last stabbed each entity this use. + stabbed: HashMap<(Option, u32), i64>, + /// The movement a guest's client reported this tick + /// (`ServerPlayer.getKnownMovement`), for their turn. + known_movement: Vec3, + /// `LivingEntity.lastKineticHitFeedbackTime` of the entities that felt a + /// spear's hit (`spear::OWN` is this window's player), in game time. + kinetic_feedback: HashMap, /// Global level events for every guest (`ServerLevel.globalLevelEvent`). lan_global_events: Vec<(i32, [i32; 3], i32)>, /// `ContainerOpenersCounter`: how many players (the host and the guests) @@ -3926,6 +3939,7 @@ impl Game<'_> { || self.use_fishing_rod(&stack) || self.use_crossbow(&stack) || self.use_trident(&stack) + || self.use_spear(&stack) || self.boost_firework(&stack) || self.use_empty_map(&stack) || self.use_book(&stack) @@ -4199,6 +4213,12 @@ impl Game<'_> { self.using = Some((slot, ticks + 1)); return; } + // ItemStack.onUseTick: a spear stabs what its speed allows, until released. + if horizon_client::spear::Kinetic::of(&stack.item).is_some() { + self.spear_tick(&stack, ticks); + self.using = Some((slot, ticks + 1)); + return; + } if &*stack.item == "minecraft:spyglass" { // SpyglassItem.USE_DURATION, then finishUsingItem. if ticks + 1 >= 1200 { @@ -9953,7 +9973,17 @@ impl Game<'_> { let ticks_used = owner.use_duration as f32 - (owner.use_item_remaining_ticks as f32 - a + 1.0); use horizon_client::first_person::ItemPose; + // ItemUseAnimation.SPEAR. + let spear = using + .then(|| horizon_client::spear::Kinetic::of(&stack.item)) + .flatten() + .map(|kinetic| ItemPose::Spear { + kinetic, + time_held: ticks_used, + ticks_since_hit: self.kinetic_hit_ticks(a), + }); let pose = match &*stack.item { + _ if let Some(pose) = spear => pose, "minecraft:bow" if using => ItemPose::Bow { ticks_used }, "minecraft:crossbow" => { let charged = stack.data().is_some_and(|d| !d.charged.is_empty()); @@ -13096,6 +13126,10 @@ impl<'a> Game<'a> { lan_block_events: Vec::new(), lan_entity_events: Vec::new(), lan_critical_hits: Vec::new(), + lan_kinetic_hits: Vec::new(), + stabbed: HashMap::new(), + known_movement: Vec3::ZERO, + kinetic_feedback: HashMap::new(), lan_global_events: Vec::new(), lid_openers: HashMap::new(), lan_acting: None, diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs index 559d30db4..2e84769ed 100644 --- a/crates/horizon-client/src/game/commands/world_cmds.rs +++ b/crates/horizon-client/src/game/commands/world_cmds.rs @@ -105,6 +105,7 @@ impl Game<'_> { match ty.trim_start_matches("minecraft:") { "player_attack" => DamageKind::PlayerAttack, "mace_smash" => DamageKind::MaceSmash, + "spear" => DamageKind::Spear, "mob_attack" | "mob_attack_no_aggro" => DamageKind::MobAttack, "arrow" => DamageKind::Arrow, "thrown" | "trident" | "mob_projectile" => DamageKind::Thrown, @@ -1218,7 +1219,7 @@ impl Game<'_> { /// LivingEntity.stopRiding for a mob: off its vehicle /// (Entity.removePassenger), then to where the vehicle lets it out /// (LivingEntity.dismountVehicle). - fn dismount_mob(&mut self, rider: u32) { + pub(in crate::game) fn dismount_mob(&mut self, rider: u32) { let Some(i) = self.mobs.iter().position(|m| m.id == rider) else { return; }; diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2bc40a7af..772d1caf4 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -3683,6 +3683,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool) match kind { K::PlayerAttack => "minecraft:player_attack", K::MaceSmash => "minecraft:mace_smash", + K::Spear => "minecraft:spear", K::MobAttack => "minecraft:mob_attack", K::Arrow => "minecraft:arrow", K::Thrown => "minecraft:thrown", diff --git a/crates/horizon-client/src/game/dispense_fixture.rs b/crates/horizon-client/src/game/dispense_fixture.rs index 33da8b5ce..88e56819a 100644 --- a/crates/horizon-client/src/game/dispense_fixture.rs +++ b/crates/horizon-client/src/game/dispense_fixture.rs @@ -672,6 +672,7 @@ impl Game<'_> { } let source = match source.kind { horizon_client::mobs::DamageKind::MaceSmash => "minecraft:mace_smash", + horizon_client::mobs::DamageKind::Spear => "minecraft:spear", _ => "minecraft:player_attack", }; out.push(format!( diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs index b24a62520..5f021a43f 100644 --- a/crates/horizon-client/src/game/enchant_effects.rs +++ b/crates/horizon-client/src/game/enchant_effects.rs @@ -69,7 +69,7 @@ impl Game<'_> { } /// `getEnchantedDamage - base`: damage bonus of the held weapon against a mob type. pub(super) fn enchant_damage_bonus(&mut self, target: &str) -> f32 { - let Some(held) = self.inventory[self.selected].clone() else { + let Some(held) = self.held().cloned() else { return 0.0; }; let ctx = EffectContext { @@ -102,7 +102,7 @@ impl Game<'_> { /// whether the hit is that knockback attack. pub(super) fn extra_knockback(&mut self, target_kind: &str, scale: f32) -> (f32, bool) { let knockback_attack = scale > 0.9 && self.player.as_ref().is_some_and(|p| p.sprinting); - let enchanted = match self.inventory[self.selected].clone() { + let enchanted = match self.held().cloned() { Some(held) => { let ctx = EffectContext { this: Some(target_kind), @@ -144,7 +144,7 @@ impl Game<'_> { } /// After a successful melee hit: fire aspect and wind burst. pub(super) fn post_attack(&mut self, mob: usize) { - let Some(held) = self.inventory[self.selected].clone() else { + let Some(held) = self.held().cloned() else { return; }; let Some(m) = self.mobs.get(mob) else { return }; diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index b6b7e2fb7..9df59281a 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -170,6 +170,9 @@ fn use_duration(components: &Components) -> i32 { let seconds = c["consume_seconds"].as_f64().unwrap_or(1.6); return (seconds * 20.0) as i32; } + if components.get("minecraft:kinetic_weapon").is_some() { + return 72_000; + } let item_model = components .get("minecraft:item_model") .and_then(Value::as_str) diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 28ec3fe8a..e2ce34e19 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1330,6 +1330,7 @@ impl Game<'_> { /// Send the tick's level events, sounds and mob animations. fn lan_flush_effects(&mut self, host: &mut LanHost) { let critical_hits = std::mem::take(&mut self.lan_critical_hits); + let kinetic_hits = std::mem::take(&mut self.lan_kinetic_hits); for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) { if kind == 2001 { host.broken @@ -1381,7 +1382,12 @@ impl Game<'_> { // A projectile is the direct entity of its hit: not tracked here. let melee = matches!( source.kind, - K::PlayerAttack | K::MaceSmash | K::MobAttack | K::Sting | K::SonicBoom + K::PlayerAttack + | K::MaceSmash + | K::Spear + | K::MobAttack + | K::Sting + | K::SonicBoom ); let direct = cause.filter(|_| melee); host.hub.damage_event(m.id as i32, kind, cause, direct, at); @@ -1402,6 +1408,19 @@ impl Game<'_> { seen.insert(m.id, (m.hurt_time, dead, swing)); } host.mob_state.insert(self.dim, seen); + // Level.broadcastEntityEvent(player, 2) of a spear's stab. + for attacker in kinetic_hits { + let hit = match attacker { + None => self + .player + .as_ref() + .map(|p| (host.host_entity, [p.position.x, p.position.y, p.position.z])), + Some(conn) => host.hub.guest(conn).map(|g| (g.entity_id, g.position)), + }; + if let Some((id, at)) = hit { + host.hub.entity_event(id, 2, at); + } + } for (attacker, target, magic) in critical_hits { let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| { host.hub.guest(conn).map(|g| g.entity_id) diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 8c51a3f2a..4aeb25563 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1935,7 +1935,13 @@ impl Game<'_> { let using = play.using.is_some(); let delayed = play.destroy_delay > 0 || play.use_delay > 0 || play.attack_ticks < 100; if digging.is_some() || using || delayed { + // ServerPlayer.getKnownMovement: the move their client just sent. + let movement = host.hub.guests[gi] + .moves + .last() + .map_or(Vec3::ZERO, |m| Vec3::new(m.0[0], m.0[1], m.0[2])); self.as_guest(host, conn, |g| { + g.known_movement = movement; g.attack_ticks = g.attack_ticks.saturating_add(1); if let Some((pos, face)) = digging { g.forced_hit = Some(Hit { diff --git a/crates/horizon-client/src/game/mace.rs b/crates/horizon-client/src/game/mace.rs index 34c968980..87868d636 100644 --- a/crates/horizon-client/src/game/mace.rs +++ b/crates/horizon-client/src/game/mace.rs @@ -6,6 +6,7 @@ use super::Game; use horizon_client::{ enchant::EffectContext, + items::ItemStack, mobs::{Damage, Mob, Species}, particles::{ParticleOptions, ParticleType}, }; @@ -100,7 +101,7 @@ impl Game<'_> { /// `LivingEntity.hurtServer` of the mob at `index` by the player's hit: /// the weapon's `armor_effectiveness` enchantments (Breach) thin its armor. pub(super) fn hurt_by_player(&mut self, index: usize, amount: f32, source: Damage) -> bool { - let held = self.inventory[self.selected].clone(); + let held = self.held().cloned(); let kind = self.mobs[index].kind.id.clone(); let ctx = EffectContext { this: Some(&kind), @@ -109,6 +110,7 @@ impl Game<'_> { is_direct: true, damage_type: Some(match source.kind { horizon_client::mobs::DamageKind::MaceSmash => "minecraft:mace_smash", + horizon_client::mobs::DamageKind::Spear => "minecraft:spear", _ => "minecraft:player_attack", }), items: Some(self.res.items()), @@ -138,7 +140,7 @@ impl Game<'_> { /// the post-attack enchantments, then `postHurtEnemy` with the weapon's /// wear. pub(super) fn weapon_hit(&mut self, index: usize) { - let Some(stack) = self.inventory[self.selected].clone() else { + let Some(stack) = self.held().cloned() else { return; }; let weapon = self @@ -158,16 +160,26 @@ impl Game<'_> { if smash && let Some(p) = self.player.as_mut() { p.fall_distance = 0.0; } - // ItemStack.postHurtEnemy: hurtAndBreak(weapon.itemDamagePerAttack). + self.weapon_wear(&stack); + } + /// `ItemStack.postHurtEnemy`: `hurtAndBreak(weapon.itemDamagePerAttack)` of + /// the weapon in the acting hand. + pub(super) fn weapon_wear(&mut self, stack: &ItemStack) { + let weapon = self + .res + .items() + .get(&stack.item) + .and_then(|i| i.weapon_damage.map(|d| (d, i.max_damage))); if let Some((per_attack, max)) = weapon && max > 0 && !self.creative { - let loss = self.durability_loss(&stack, per_attack); - if let Some(held) = self.inventory[self.selected].as_mut() { + let loss = self.durability_loss(stack, per_attack); + let cell = self.held_mut(); + if let Some(held) = cell.as_mut() { held.damage += loss; if held.damage >= max { - self.inventory[self.selected] = None; + *cell = None; } } } diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 77e143f9a..3707b9945 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2123,6 +2123,10 @@ impl Game<'_> { self.remote_firework_explosion(p.id); } self.remote_fangs_event(p.id as u32, p.event); + // LivingEntity.handleEntityEvent 2: a spear's hit felt. + if p.event == 2 { + self.remote_kinetic_hit(p.id); + } // LocalPlayer.setPermissions also refreshes an open World Options screen. if (24..=28).contains(&p.event) && self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) @@ -4394,6 +4398,8 @@ impl Game<'_> { } // SpyglassItem.use (its sound is the server's). "minecraft:spyglass" => true, + // Item.use: a kinetic weapon starts being used. + id if horizon_client::spear::Kinetic::of(id).is_some() => true, // ShieldItem.use: anything that blocks attacks, off cooldown. _ => { self.raise_shield(self.held_slot()); @@ -4410,7 +4416,8 @@ impl Game<'_> { matches!( &*stack.item, "minecraft:bow" | "minecraft:crossbow" | "minecraft:trident" | "minecraft:spyglass" - ) || self.blocks_attacks(stack).is_some() + ) || horizon_client::spear::Kinetic::of(&stack.item).is_some() + || self.blocks_attacks(stack).is_some() } /// The rest of Minecraft.startUseItem once the main hand's target passed: @@ -5516,7 +5523,8 @@ fn hand_id(hand: Hand) -> i32 { /// server decides; this is the client's guess of whether to go on. fn item_has_use(info: &horizon_client::items::ItemInfo) -> bool { let id = info.id.trim_start_matches("minecraft:"); - info.consumable.is_some() + id.ends_with("_spear") + || info.consumable.is_some() || info.equip_slot.is_some() || info.blocks_attacks.is_some() || horizon_client::items::bucket_contents(&info.id).is_some() diff --git a/crates/horizon-client/src/game/spear.rs b/crates/horizon-client/src/game/spear.rs new file mode 100644 index 000000000..13df3aed9 --- /dev/null +++ b/crates/horizon-client/src/game/spear.rs @@ -0,0 +1,330 @@ +//! Spears (`KineticWeapon`): holding the use button charges the spear, and +//! from `delay_ticks` on every living entity along the view that the +//! player's speed allows is stabbed: the damage grows with the speed +//! relative to the target, the knockback and the dismount need the +//! attacker's own speed, and each condition runs out after its time +//! (`Item.use`, `ItemStack.onUseTick`, `KineticWeapon.damageEntities`, +//! `Player.stabAttack`). The hit's feedback (`onKineticHit`) reaches the +//! players around as entity event 2. +use super::{Game, view_vector}; +use horizon_client::{ + collisions::SceneCollisions, + items::ItemStack, + mobs::Damage, + spear::{HIT_FEEDBACK_TICKS, Kinetic, REACH}, +}; +use horizon_core::{ + geometry::{Aabb, Vec3, traverse_blocks}, + position::BlockPos, +}; + +/// The key of this window's own player in `Game::kinetic_feedback`. +pub(super) const OWN: i32 = i32::MIN; + +impl Game<'_> { + /// `Item.use` of a kinetic weapon: `startUsingItem` with a new + /// `recentKineticEnemies`, and `KineticWeapon.makeSound` at the user. + pub(super) fn use_spear(&mut self, stack: &ItemStack) -> bool { + let Some(kinetic) = Kinetic::of(&stack.item) else { + return false; + }; + if self.using.is_none() { + self.using = Some((self.held_slot(), 0)); + let actor = self.lan_acting; + self.stabbed.retain(|(who, _), _| *who != actor); + if let Some(p) = &self.player { + let at = [p.position.x, p.position.y, p.position.z]; + self.audio.play(kinetic.sound, Some(at), 1.0, 1.0); + } + } + true + } + + /// `ServerPlayer.getKnownMovement` of the acting player: what they moved + /// in the last tick. A guest's comes with their moves. + fn known_player_movement(&self) -> Vec3 { + if self.lan_acting.is_some() { + return self.known_movement; + } + self.player + .as_ref() + .map_or(Vec3::ZERO, |p| p.position.subtract(self.previous_position)) + } + + /// `Entity.getKnownSpeed` of the mob at `index`, per second: its root + /// vehicle's (`KineticWeapon.getMotion`). + fn mob_speed(&self, index: usize) -> Vec3 { + let mut mob = &self.mobs[index]; + while let Some(vehicle) = mob + .extra + .mount + .and_then(|v| self.mobs.iter().find(|m| m.id == v)) + { + mob = vehicle; + } + mob.position.subtract(mob.previous).scale(20.0) + } + + /// `Level.clip` with COLLIDER shapes and no fluids: where the segment + /// first meets a block, if it does (tall grass lets a stab through). + fn clip_collider(&self, from: Vec3, to: Vec3) -> Option { + let mut scene = SceneCollisions { + world: &self.world, + binding: self.collision, + subject: None, + }; + traverse_blocks(from, to, 512, |p: BlockPos| { + let state = self.world.block(p.x, p.y, p.z); + if self.res.facts().is_air(state) { + return None; + } + let shape = self + .collision + .collision_shape(&mut scene, state, [p.x, p.y, p.z]) + .ok()?; + shape.clip(from, to, p).map(|hit| hit.location) + }) + .ok() + .flatten() + } + + /// `ProjectileUtil.getHitEntitiesAlong` for the mobs: those whose box the + /// segment `from`..`to` meets, or comes within the margin of with no + /// block between. + fn mobs_along(&self, from: Vec3, to: Vec3, margin: f64) -> Vec { + let grow = Vec3::new(margin, margin, margin); + let mut hits = Vec::new(); + for (i, m) in self.mobs.iter().enumerate() { + // PiercingWeapon.canHitEntity: alive, and not the vehicle ridden. + if !m.alive() || m.removed || self.riding == Some(m.id) { + continue; + } + let bounds: Aabb = m.bounds(); + let hit = bounds.contains(from) + || bounds.clip(from, to).is_some() + || (margin > 0.0 + && bounds.inflate(grow).clip(from, to).is_some_and(|outside| { + let centre = bounds.center(); + let toward = self.clip_collider(outside, centre).unwrap_or(centre); + bounds.clip(outside, toward).is_some() + })); + if hit { + hits.push(i); + } + } + hits + } + + /// `KineticWeapon.damageEntities`: one tick of the spear in use, `ticks` + /// ticks into the use. + pub(super) fn spear_tick(&mut self, stack: &ItemStack, ticks: u32) { + let Some(kinetic) = Kinetic::of(&stack.item) else { + return; + }; + let used = ticks as i32 - kinetic.delay_ticks; + let (Some(eye), Some(feet)) = ( + self.eye_position(), + self.player.as_ref().map(|p| p.position), + ) else { + return; + }; + if used < 0 || self.spectator() { + return; + } + let eye = Vec3::new(eye[0], eye[1], eye[2]); + let look = view_vector(self.yaw, self.pitch); + let look = Vec3::new(look[0], look[1], look[2]); + let movement = self.known_player_movement(); + let attacker_speed = look.dot(movement.scale(20.0)); + // AttackRange.effectiveMinRange and effectiveMaxRange for a player. + let (min, max) = if self.creative { + (REACH.min_creative, REACH.max_creative) + } else { + (REACH.min, REACH.max) + }; + let from = eye.add_vector(look.scale(f64::from(min))); + let mut to = eye.add_vector(look.scale(f64::from(max) + movement.dot(look).max(0.0))); + // A block closer than the minimum reach takes the whole stab. + if let Some(block) = self.clip_collider(eye, to) { + to = block; + if eye.distance_squared(to) < eye.distance_squared(from) { + return; + } + } + let now = self.world.game_time; + let actor = self.lan_acting; + let mut affected = false; + for i in self.mobs_along(from, to, f64::from(REACH.hitbox_margin)) { + let key = (actor, self.mobs[i].id); + let recent = self + .stabbed + .get(&key) + .is_some_and(|&t| now - t < i64::from(kinetic.contact_cooldown_ticks)); + if recent { + continue; + } + self.stabbed.insert(key, now); + let target_speed = look.dot(self.mob_speed(i)); + let relative = (attacker_speed - target_speed).max(0.0); + // An entity factor of 1 for a player. + let dismounts = kinetic.dismount.test(used, attacker_speed, relative, 1.0); + let pushes = kinetic.knockback.test(used, attacker_speed, relative, 1.0); + let damages = kinetic.damage.test(used, attacker_speed, relative, 1.0); + if dismounts || pushes || damages { + // The attack damage attribute's base value (1) and the speed. + let amount = 1.0 + (relative * f64::from(kinetic.damage_multiplier)).floor() as f32; + affected |= self.stab_mob(i, amount, damages, pushes, dismounts); + } + } + if affected { + // Level.broadcastEntityEvent(player, 2), felt by the player too. + if self.audio.capture.is_some() { + self.lan_kinetic_hits.push(actor); + } + let who = actor.map_or(OWN, |conn| conn as i32); + self.kinetic_hit_feedback(who, &kinetic, [feet.x, feet.y, feet.z]); + } + } + + /// `Player.stabAttack` on the mob at `index`: whether it was affected. + fn stab_mob( + &mut self, + index: usize, + base_damage: f32, + deals_damage: bool, + deals_knockback: bool, + dismounts: bool, + ) -> bool { + let kind = format!( + "minecraft:{}", + self.mobs[index].kind.id.trim_start_matches("minecraft:") + ); + let id = self.mobs[index].id; + let Some(p) = self.player.as_ref() else { + return false; + }; + let from = [p.position.x, p.position.y, p.position.z]; + // The enchantments' share, with no attack strength scaling for a + // weapon in use. + let magic_boost = self.enchant_damage_bonus(&kind); + let total = if deals_damage { + base_damage + magic_boost + } else { + 0.0 + }; + let old_health = self.mobs[index].health; + let hurt = deals_damage && self.hurt_by_player(index, total, Damage::spear(from)); + // causeExtraKnockback: a push of 0.4, then the weapon's Knockback. + if deals_knockback { + let (xd, zd) = self.extra_knockback_direction(); + self.mobs[index].knockback(0.4, xd, zd); + let (strength, _) = self.extra_knockback(&kind, 0.0); + self.mobs[index].knockback(f64::from(strength), xd, zd); + } + let dismounted = dismounts && self.mobs[index].extra.mount.is_some(); + if dismounted { + self.dismount_mob(id); + } + if !hurt && !deals_knockback && !dismounted { + return false; + } + let mob = &self.mobs[index]; + let (feet, width, height) = ( + [mob.position.x, mob.position.y, mob.position.z], + mob.kind.width, + mob.kind.height, + ); + // attackVisualEffects: no attack sound, the enchantments' magic crit. + if magic_boost > 0.0 { + self.critical_hit(self.lan_acting, id as i32, feet, width, height, true); + } + self.combat.last_hurt_mob = Some((id, self.world.game_time)); + // itemAttackInteraction: hurtEnemy (statistic, wear), and the + // post-attack enchantments when the target was hurt. + if let Some(stack) = self.held().cloned() { + self.stats.add("used", &stack.item, 1); + if hurt { + self.post_attack(index); + } + self.weapon_wear(&stack); + } + // damageStatsAndHearts. + let actual = old_health - self.mobs[index].health; + self.stats + .custom("damage_dealt", (actual * 10.0).round() as i32); + if actual > 2.0 { + let indicator = horizon_client::particles::ParticleOptions::simple( + horizon_client::particles::ParticleType::DamageIndicator, + ); + self.particles.send_particles( + &indicator, + [feet[0], feet[1] + height * 0.5, feet[2]], + [0.1, 0.0, 0.1], + 0.2, + (actual * 0.5) as u32, + ); + } + if hurt { + self.last_hurt_by_player.insert(id, self.lan_acting); + } + if let Some(p) = self.player.as_mut() + && !self.creative + { + p.cause_food_exhaustion(0.1); + } + true + } + + /// `LivingEntity.onKineticHit` for `entity`: the hit feels (the spear + /// moves back, `kinetic_hit_ticks`) and sounds, at most once every ten + /// ticks. + pub(super) fn kinetic_hit_feedback(&mut self, entity: i32, kinetic: &Kinetic, at: [f64; 3]) { + let now = self.world.game_time; + if self + .kinetic_feedback + .get(&entity) + .is_none_or(|&t| now - t > HIT_FEEDBACK_TICKS) + { + self.kinetic_feedback.insert(entity, now); + self.audio + .play_unshared(kinetic.hit_sound, Some(at), 1.0, 1.0); + } + } + + /// `getTicksSinceLastKineticHitFeedback` of this window's player. + pub(super) fn kinetic_hit_ticks(&self, partial: f32) -> f32 { + self.kinetic_feedback + .get(&OWN) + .map_or(0.0, |&t| (self.world.game_time - t) as f32 + partial) + } + + /// `LivingEntity.handleEntityEvent(2)` on a server's client: the + /// player `id` (this one, or another) was hit by the spear it uses. + pub(super) fn remote_kinetic_hit(&mut self, id: i32) { + let own = self.remote.as_ref().is_some_and(|r| r.entity_id == id); + let (item, at) = if own { + let item = self + .using + .and_then(|(slot, _)| self.stack_in(slot)) + .map(|s| s.item.clone()); + let at = self.player.as_ref().map(|p| p.position); + (item, at) + } else { + let mob = self + .mobs + .iter() + .find(|m| m.id == id as u32 && m.extra.using_item > 0); + let item = mob.and_then(|m| { + if m.extra.using_off_hand { + m.extra.off_hand.clone() + } else { + m.extra.main_hand.clone() + } + }); + (item, mob.map(|m| m.position)) + }; + if let (Some(kinetic), Some(at)) = (item.as_deref().and_then(Kinetic::of), at) { + self.kinetic_hit_feedback(if own { OWN } else { id }, &kinetic, [at.x, at.y, at.z]); + } + } +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index fa5ef1c4d..fdbd4ce8d 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -167,6 +167,7 @@ pub mod skins; pub mod sound_engine; pub mod sound_events; pub mod spans; +pub mod spear; pub mod sprint; pub mod sprites; pub mod stations; diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 2325c3f5b..fffcad823 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -507,6 +507,8 @@ pub enum DamageKind { PlayerAttack, /// `mace_smash`: a mace hit after a fall (the player attack tags too). MaceSmash, + /// `spear`: a stab of a spear (the player attack tags too). + Spear, MobAttack, Arrow, Thrown, @@ -567,6 +569,14 @@ impl Damage { from: Some(from), } } + /// `DamageSources.spear`: a player's stab with a spear. + pub fn spear(from: [f64; 3]) -> Self { + Self { + kind: DamageKind::Spear, + attacker: Some(Who::Player), + from: Some(from), + } + } pub fn mob(id: u32, from: [f64; 3]) -> Self { Self { kind: DamageKind::MobAttack, diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index a4c27960e..2eccd31f0 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -244,6 +244,8 @@ pub enum ArmPose { CrossbowCharge, /// Raising a trident to throw it (or to launch with Riptide). ThrowTrident, + /// A spear held out (`HumanoidModel.ArmPose.SPEAR`), at rest or charging. + Spear, } /// HumanoidModel.setupAnim with empty hands (endermen). pub fn humanoid_pub(p: &mut Poses, s: &State, _m: &Mob) { @@ -295,6 +297,10 @@ pub struct Hum { pub swing_right_arm: Option, /// `mainArm` is the left one (`Mob.isLeftHanded`): a mob's swing uses it. pub left_main: bool, + /// The spear each arm (right, left) holds, and how long that arm has + /// been using it (`ticksUsingItem(arm)`, 0 when it is not). + pub spear: [Option; 2], + pub spear_ticks: [f32; 2], } impl Hum { pub fn new(right: ArmPose, left: ArmPose) -> Self { @@ -313,6 +319,8 @@ impl Hum { using_item: false, swing_right_arm: None, left_main: false, + spear: [None; 2], + spear_ticks: [0.0; 2], } } } @@ -388,6 +396,23 @@ fn pose_arm(p: &mut Poses, pose: ArmPose, right: bool, h: &Hum) { } ArmPose::CrossbowHold => crossbow_hold(p, hx, hy, right), ArmPose::CrossbowCharge => crossbow_charge(p, h.charge.0, h.charge.1, right), + // SpearAnimations.thirdPersonHandUse. + ArmPose::Spear => { + let side = usize::from(!right); + let Some(kinetic) = h.spear[side] else { + return; + }; + let (x, y, z) = crate::spear::third_person_arm( + &kinetic, + h.spear_ticks[side], + right, + (hx, hy), + h.fall_flying || h.swim > 0.0, + ); + p.xrot(arm, x); + p.yrot(arm, y); + p.get(arm)[5] += z; + } } } /// `HumanoidModel.setupAnim` (and `ZombieModel.setupAttackAnimation`). @@ -687,6 +712,14 @@ pub fn setup( ArmPose::Empty }; let using_main = m.extra.using_item > 0 && !m.extra.using_off_hand; + // AvatarRenderer.getArmPose: an arm holding a spear (at rest too). + let spear_in = |hand: &Option>| { + hand.as_deref() + .filter(|_| player) + .and_then(crate::spear::Kinetic::of) + }; + let (main_spear, off_spear) = + (spear_in(&m.extra.main_hand), spear_in(&m.extra.off_hand)); let pose = if player { match m.extra.main_hand.as_deref() { Some(_) if using_main && m.extra.blocking => ArmPose::Block, @@ -698,6 +731,7 @@ pub fn setup( Some("minecraft:crossbow") if m.extra.charged && s.swing == 0.0 => { ArmPose::CrossbowHold } + Some(_) if main_spear.is_some() => ArmPose::Spear, Some(_) => ArmPose::Item, None => ArmPose::Empty, } @@ -705,7 +739,9 @@ pub fn setup( right }; let off = if player && m.extra.off_hand.is_some() && !pose.affects_offhand() { - if m.extra.using_item > 0 && m.extra.using_off_hand && m.extra.blocking { + if off_spear.is_some() { + ArmPose::Spear + } else if m.extra.using_item > 0 && m.extra.using_off_hand && m.extra.blocking { ArmPose::Block } else { ArmPose::Item @@ -731,6 +767,17 @@ pub fn setup( h.using_item = m.extra.using_item > 0; h.swing_right_arm = m.extra.swing_right_arm; h.left_main = m.main_arm_left(); + let main_side = usize::from(m.main_arm_left()); + h.spear[main_side] = main_spear; + h.spear[1 - main_side] = off_spear; + if m.extra.using_item > 0 { + let using_side = if m.extra.using_off_hand { + 1 - main_side + } else { + main_side + }; + h.spear_ticks[using_side] = m.extra.using_item as f32 + s.partial; + } humanoid(p, s, &h); if m.ai.aggressive && !bow { // SkeletonModel melee pose. diff --git a/crates/horizon-client/src/mobs/creaking.rs b/crates/horizon-client/src/mobs/creaking.rs index fd6248d2b..e32136703 100644 --- a/crates/horizon-client/src/mobs/creaking.rs +++ b/crates/horizon-client/src/mobs/creaking.rs @@ -118,6 +118,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage) -> bool { source.kind, DamageKind::PlayerAttack | DamageKind::MaceSmash + | DamageKind::Spear | DamageKind::MobAttack | DamageKind::Arrow | DamageKind::Thrown diff --git a/crates/horizon-client/src/mobs/guardian.rs b/crates/horizon-client/src/mobs/guardian.rs index 880655361..8f543e2b4 100644 --- a/crates/horizon-client/src/mobs/guardian.rs +++ b/crates/horizon-client/src/mobs/guardian.rs @@ -294,7 +294,10 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { && let Some((d, _)) = m.last_damage && matches!( d.kind, - DamageKind::PlayerAttack | DamageKind::MaceSmash | DamageKind::MobAttack + DamageKind::PlayerAttack + | DamageKind::MaceSmash + | DamageKind::Spear + | DamageKind::MobAttack ) { let from = [m.position.x, m.position.y, m.position.z]; diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 077fd38a6..7303ea9d2 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -1292,7 +1292,23 @@ pub fn held_item_transform( .unwrap_or_else(|| m.kind.model.clone()); let mut poses = Poses::new(&model); anim::setup(m, &s, &mut poses, &data.animations); - hand_base(m, &model, base, &poses, left) + let mut t = hand_base(m, &model, base, &poses, left)?; + // ItemInHandLayer: a spear in use (ArmPose.SPEAR's animateUseItem). + let off_hand = left != m.main_arm_left(); + if m.extra.using_item > 0 + && m.extra.using_off_hand == off_hand + && let Some(kinetic) = (if off_hand { + &m.extra.off_hand + } else { + &m.extra.main_hand + }) + .as_deref() + .and_then(crate::spear::Kinetic::of) + { + let time_held = m.extra.using_item as f32 + s.partial; + t *= crate::spear::third_person_use_item(&kinetic, time_held, s.swing, 0.0, !left); + } + Some(t) } #[cfg(test)] diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs index 00b846b86..f479bf076 100644 --- a/crates/horizon-client/src/mobs/sulfur_cube.rs +++ b/crates/horizon-client/src/mobs/sulfur_cube.rs @@ -290,6 +290,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool { source.kind, DamageKind::PlayerAttack | DamageKind::MaceSmash + | DamageKind::Spear | DamageKind::MobAttack | DamageKind::Arrow | DamageKind::Thrown diff --git a/crates/horizon-client/src/spear.rs b/crates/horizon-client/src/spear.rs new file mode 100644 index 000000000..ae6d8f80d --- /dev/null +++ b/crates/horizon-client/src/spear.rs @@ -0,0 +1,351 @@ +//! Spears: `KineticWeapon` (what holding the use button does: the speed +//! conditions of a stab, `Item.Properties.spear`'s numbers) and +//! `SpearAnimations` (how the spear is held in first and third person while +//! it charges). +use glam::{Mat4, Vec3}; +use horizon_core::{geometry::trig::Mth, jmath::pow}; +use std::f32::consts::PI; + +/// `KineticWeapon.Condition`. +#[derive(Clone, Copy, Debug)] +pub struct Condition { + pub max_duration_ticks: i32, + pub min_speed: f32, + pub min_relative_speed: f32, +} +impl Condition { + pub fn test( + self, + ticks_used: i32, + attacker_speed: f64, + relative_speed: f64, + entity_factor: f64, + ) -> bool { + ticks_used <= self.max_duration_ticks + && attacker_speed >= f64::from(self.min_speed) * entity_factor + && relative_speed >= f64::from(self.min_relative_speed) * entity_factor + } +} + +/// `KineticWeapon`: a spear's charge. +#[derive(Clone, Copy, Debug)] +pub struct Kinetic { + pub contact_cooldown_ticks: i32, + pub delay_ticks: i32, + pub dismount: Condition, + pub knockback: Condition, + pub damage: Condition, + pub forward_movement: f32, + pub damage_multiplier: f32, + pub sound: &'static str, + pub hit_sound: &'static str, +} + +/// `AttackRange` of a spear: the reach of its stabs. +pub struct Reach { + pub min: f32, + pub max: f32, + pub min_creative: f32, + pub max_creative: f32, + pub hitbox_margin: f32, + pub mob_factor: f32, +} +pub const REACH: Reach = Reach { + min: 2.0, + max: 4.5, + min_creative: 2.0, + max_creative: 6.5, + hitbox_margin: 0.125, + mob_factor: 0.5, +}; + +impl Kinetic { + /// The `kinetic_weapon` of a spear item (`Item.Properties.spear`). + pub fn of(item: &str) -> Option { + // (damage multiplier, delay, dismount time and speed, knockback time + // and speed, damage time and speed): seconds and blocks per second. + let (multiplier, delay, dismount, knockback, damage) = match item { + "minecraft:wooden_spear" => (0.7, 0.75, (5.0, 14.0), (10.0, 5.1), (15.0, 4.6)), + "minecraft:stone_spear" => (0.82, 0.7, (4.5, 13.0), (9.0, 5.1), (13.75, 4.6)), + "minecraft:copper_spear" => (0.82, 0.65, (4.0, 12.0), (8.25, 5.1), (12.5, 4.6)), + "minecraft:iron_spear" => (0.95, 0.6, (2.5, 11.0), (6.75, 5.1), (11.25, 4.6)), + "minecraft:golden_spear" => (0.7, 0.7, (3.5, 13.0), (8.5, 5.1), (13.75, 4.6)), + "minecraft:diamond_spear" => (1.075, 0.5, (3.0, 10.0), (6.5, 5.1), (10.0, 4.6)), + "minecraft:netherite_spear" => (1.2, 0.4, (2.5, 9.0), (5.5, 5.1), (8.75, 4.6)), + _ => return None, + }; + let wood = item == "minecraft:wooden_spear"; + let ticks = |seconds: f32| (seconds * 20.0) as i32; + Some(Self { + contact_cooldown_ticks: 10, + delay_ticks: ticks(delay), + // `Condition.ofAttackerSpeed`, and `ofRelativeSpeed` for the damage. + dismount: Condition { + max_duration_ticks: ticks(dismount.0), + min_speed: dismount.1, + min_relative_speed: 0.0, + }, + knockback: Condition { + max_duration_ticks: ticks(knockback.0), + min_speed: knockback.1, + min_relative_speed: 0.0, + }, + damage: Condition { + max_duration_ticks: ticks(damage.0), + min_speed: 0.0, + min_relative_speed: damage.1, + }, + forward_movement: 0.38, + damage_multiplier: multiplier, + sound: if wood { + "minecraft:item.spear_wood.use" + } else { + "minecraft:item.spear.use" + }, + hit_sound: if wood { + "minecraft:item.spear_wood.hit" + } else { + "minecraft:item.spear.hit" + }, + }) + } +} + +/// `KineticWeapon.HIT_FEEDBACK_TICKS`. +pub const HIT_FEEDBACK_TICKS: i64 = 10; + +/// `Mth.clamp` on floats (a NaN stays one). +fn clamp(v: f32, lo: f32, hi: f32) -> f32 { + if v < lo { lo } else { v.min(hi) } +} +/// `SpearAnimations.progress`. +fn progress(time: f32, start: f32, end: f32) -> f32 { + clamp((time - start) / (end - start), 0.0, 1.0) +} +fn square(x: f32) -> f32 { + x * x +} +fn cube(x: f32) -> f32 { + x * x * x +} +fn p(x: f32, y: f64) -> f64 { + pow(f64::from(x), y) +} + +// `net.minecraft.util.Ease`. +fn in_quad(x: f32) -> f32 { + x * x +} +fn out_quart(x: f32) -> f32 { + 1.0 - square(square(1.0 - x)) +} +fn out_cubic(x: f32) -> f32 { + 1.0 - cube(1.0 - x) +} +fn out_back(x: f32) -> f32 { + 1.0 + 2.70158 * cube(x - 1.0) + 1.70158 * square(x - 1.0) +} +fn in_out_sine(x: f32) -> f32 { + -((PI * x).mcos() - 1.0) / 2.0 +} +fn in_out_expo(x: f32) -> f32 { + if x < 0.5 { + if x == 0.0 { + 0.0 + } else { + (p(2.0, f64::from(20.0 * x - 10.0)) / 2.0) as f32 + } + } else if x == 1.0 { + 1.0 + } else { + ((2.0 - p(2.0, f64::from(-20.0 * x + 10.0))) / 2.0) as f32 + } +} +fn in_out_back(x: f32) -> f32 { + if x < 0.5 { + return 4.0 * x * x * (7.189_819 * x - 2.594_909_4) / 2.0; + } + let dt = 2.0 * x - 2.0; + (dt * dt * (3.594_909_4 * dt + 2.594_909_4) + 2.0) / 2.0 +} +fn in_out_elastic(x: f32) -> f32 { + if x == 0.0 { + return 0.0; + } + if x == 1.0 { + return 1.0; + } + let sin = (f64::from(20.0 * x - 11.125) * f64::from(PI * 4.0 / 9.0)).sin(); + if x < 0.5 { + (-(p(2.0, f64::from(20.0 * x - 10.0)) * sin) / 2.0) as f32 + } else { + (p(2.0, f64::from(-20.0 * x + 10.0)) * sin / 2.0 + 1.0) as f32 + } +} +fn out_circ(x: f32) -> f32 { + f64::from(1.0 - square(x - 1.0)).sqrt() as f32 +} +fn in_circ(x: f32) -> f32 { + (-f64::from(1.0 - x * x).sqrt()) as f32 + 1.0 +} + +/// `SpearAnimations.UseParams`. +struct UseParams { + raise: f32, + raise_start: f32, + raise_middle: f32, + raise_end: f32, + sway: f32, + lower: f32, + raise_back: f32, + sway_intensity: f32, + sway_slow: f32, + sway_fast: f32, +} +impl UseParams { + fn of(k: &Kinetic, time: f32) -> Self { + let finish_raising = k.delay_ticks; + let finish_swaying = k.dismount.max_duration_ticks + finish_raising; + let start_swaying = finish_swaying - 20; + let finish_lowering = k.knockback.max_duration_ticks + finish_raising; + let start_lowering = finish_lowering - 40; + let finish_raising_back = k.damage.max_duration_ticks + finish_raising; + let raise = progress(time, 0.0, finish_raising as f32); + let sway = progress(time, start_swaying as f32, finish_swaying as f32); + let lower = out_cubic(in_out_elastic(progress( + time - 20.0, + start_lowering as f32, + finish_lowering as f32, + ))); + let raise_back = progress( + time, + (finish_raising_back - 5) as f32, + finish_raising_back as f32, + ); + let sway_intensity = 2.0 * out_circ(sway) - 2.0 * in_circ(raise_back); + let degrees = PI / 180.0; + Self { + raise, + raise_start: progress(raise, 0.0, 0.5), + raise_middle: progress(raise, 0.5, 0.8), + raise_end: progress(raise, 0.8, 1.0), + sway, + lower, + raise_back, + sway_intensity, + sway_slow: (time * 19.0 * degrees).msin() * sway_intensity, + sway_fast: (time * 30.0 * degrees).msin() * sway_intensity, + } + } +} + +/// `SpearAnimations.hitFeedbackAmount`. +fn hit_feedback(ticks_since: f32) -> f32 { + 0.4 * (out_quart(progress(ticks_since, 1.0, 3.0)) + - in_out_sine(progress(ticks_since, 3.0, 10.0))) +} + +/// `PoseStack.rotateAround`. +fn rotate_around(rotation: Mat4, about: Vec3) -> Mat4 { + Mat4::from_translation(about) * rotation * Mat4::from_translation(-about) +} + +/// `SpearAnimations.firstPersonUse`, after the hand's own +/// `translate(invert * 0.56, -0.52, -0.72)`. +pub fn first_person_use(k: &Kinetic, ticks_since_hit: f32, time_held: f32, right: bool) -> Mat4 { + let u = UseParams::of(k, time_held); + let invert = if right { 1.0 } else { -1.0 }; + let degrees = |d: f32| d.to_radians(); + let mut m = Mat4::from_translation(Vec3::new( + invert * (u.raise * 0.15 + u.raise_end * -0.05 + u.sway * -0.1 + u.sway_slow * 0.005), + u.raise * -0.075 + u.raise_middle * 0.075 + u.sway_fast * 0.01, + u.raise_start * 0.05 + u.raise_end * -0.05 + u.sway_slow * 0.005, + )); + m *= rotate_around( + Mat4::from_rotation_x(degrees( + -65.0 * in_out_back(u.raise) - 35.0 * u.lower + + 100.0 * u.raise_back + + -0.5 * u.sway_fast, + )), + Vec3::new(0.0, 0.1, 0.0), + ); + // Axis.YN: a turn the other way round. + m *= rotate_around( + Mat4::from_rotation_y(-degrees( + invert * (-90.0 * progress(u.raise, 0.5, 0.55) + 90.0 * u.sway + 2.0 * u.sway_slow), + )), + Vec3::new(invert * 0.15, 0.0, 0.0), + ); + m * Mat4::from_translation(Vec3::new(0.0, -hit_feedback(ticks_since_hit), 0.0)) +} + +/// `SpearAnimations.thirdPersonHandUse`: the angles (x, y and the z added to +/// the arm's own) of the arm holding a spear. `ticks_using` is the time the +/// item has been in use by this arm (0 when it is not). +pub fn third_person_arm( + k: &Kinetic, + ticks_using: f32, + right: bool, + head: (f32, f32), + gliding_or_swimming: bool, +) -> (f32, f32, f32) { + let invert = if right { 1.0 } else { -1.0 }; + let degrees = PI / 180.0; + let mut y = -0.1 * invert + head.1; + let mut x = -PI / 2.0 + head.0 + 0.8; + if gliding_or_swimming { + x -= 0.959_931_1; + } + y = degrees * clamp(180.0 / PI * y, -60.0, 60.0); + x = degrees * clamp(180.0 / PI * x, -120.0, 30.0); + let mut z = 0.0; + if ticks_using > 0.0 { + let u = UseParams::of(k, ticks_using); + y += -invert * u.sway_fast * degrees * u.sway_intensity; + z = -invert * u.sway_slow * degrees * u.sway_intensity * 0.5; + x += degrees + * (-40.0 * u.raise_start + + 30.0 * u.raise_middle + + -20.0 * u.raise_end + + 20.0 * u.lower + + 10.0 * u.raise_back + + 0.6 * u.sway_slow * u.sway_intensity); + } + (x, y, z) +} + +/// `SpearAnimations.thirdPersonUseItem`: the spear's own pose in the hand +/// held for `time_held` ticks, `swing` into the current swing. +pub fn third_person_use_item( + k: &Kinetic, + time_held: f32, + swing: f32, + ticks_since_hit: f32, + right: bool, +) -> Mat4 { + if time_held == 0.0 { + return Mat4::IDENTITY; + } + let attack = in_quad(progress(swing, 0.05, 0.2)); + let retract = in_out_expo(progress(swing, 0.4, 1.0)); + let u = UseParams::of(k, time_held); + let invert = if right { 1.0 } else { -1.0 }; + let raise_modified = 1.0 - out_back(1.0 - u.raise); + let hit = hit_feedback(ticks_since_hit); + let degrees = |d: f32| d.to_radians(); + Mat4::from_translation(Vec3::new( + 0.0, + -hit * 0.4, + -k.forward_movement * (raise_modified - u.raise_back) + hit, + )) * rotate_around( + Mat4::from_rotation_x(-degrees( + 70.0 * (u.raise - u.raise_back) - 40.0 * (attack - retract), + )), + Vec3::new(0.0, -0.031_25, 0.125), + ) * rotate_around( + Mat4::from_rotation_y(degrees( + invert * 90.0 * (u.raise - u.sway + 3.0 * retract + attack), + )), + Vec3::new(0.0, 0.0, 0.125), + ) +} From 28b72d46c593284804f7c9c4883ce95a24052d95 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:36:15 +0100 Subject: [PATCH 69/84] Give turtles vanilla's goals: panic, tempt, go to water, travel and stroll --- crates/horizon-client/src/mobs/ai.rs | 8 +- crates/horizon-client/src/mobs/goals.rs | 18 +- crates/horizon-client/src/mobs/nav.rs | 5 + crates/horizon-client/src/mobs/turtle.rs | 232 ++++++++++++++++++++++- 4 files changed, 253 insertions(+), 10 deletions(-) diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 26b94eeac..4f17dc580 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -180,14 +180,13 @@ pub fn register(m: &mut Mob) { Family::Undead => undead::register(m), Family::Hostile => hostile::register(m), Family::Aquatic => aquatic::register(m), + // Turtle.registerGoals has its own list, none of the generic goals. + Family::Generic if m.species() == Species::Turtle => super::turtle::register(m), Family::Generic => { generic(m); if m.species() == Species::Rabbit { super::rabbit::register(m); } - if m.species() == Species::Turtle { - super::turtle::register(m); - } } Family::Inert => {} Family::Witch => super::witch::register(m), @@ -1298,6 +1297,9 @@ pub fn walk_target_value(m: &Mob, w: &MobWorld, p: [i32; 3]) -> f32 { if m.species() == Species::Strider { return super::strider::walk_target_value(m, w, p); } + if m.species() == Species::Turtle { + return super::turtle::walk_target_value(m, w, p, light()); + } // Hoglin.getWalkTargetValue: nowhere near a repellent, crimson nylium best. if m.species() == Species::Hoglin { let near = m.extra.repellent.is_some_and(|r| { diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs index d0b784166..135a57fb0 100644 --- a/crates/horizon-client/src/mobs/goals.rs +++ b/crates/horizon-client/src/mobs/goals.rs @@ -654,15 +654,24 @@ impl Goal for Float { #[derive(Clone, Debug)] pub struct Panic { pub speed: f64, + /// `TurtlePanicGoal`: always look for water this far away, not only + /// when on fire. + pub water_range: Option, pos: [f64; 3], } impl Panic { pub fn new(speed: f64) -> Self { Self { speed, + water_range: None, pos: [0.0; 3], } } + /// `TurtlePanicGoal`. + pub fn looking_for_water(mut self, range: i32) -> Self { + self.water_range = Some(range); + self + } } pub fn should_panic(m: &Mob) -> bool { m.last_damage @@ -678,18 +687,19 @@ impl Goal for Panic { if !should_panic(m) { return false; } - if m.fire_ticks > 0 { + let range = self.water_range.or((m.fire_ticks > 0).then_some(5)); + if let Some(range) = range { let (bx, by, bz) = ( m.position.x.floor() as i32, m.position.y.floor() as i32, m.position.z.floor() as i32, ); if cx.w.data.state(cx.w.world.block(bx, by, bz)).top == 0.0 { - // findBlocksInBoxByManhattanDistance(pos, 5, 1) for water. + // findBlocksInBoxByManhattanDistance(pos, range, 1) for water. let mut best: Option<([i32; 3], i32)> = None; for dy in -1i32..=1 { - for dx in -5i32..=5 { - for dz in -5i32..=5 { + for dx in -range..=range { + for dz in -range..=range { let d = dx.abs() + dy.abs() + dz.abs(); if cx.w.fluid(bx + dx, by + dy, bz + dz) == crate::blocks::Fluid::Water && best.is_none_or(|b| d < b.1) diff --git a/crates/horizon-client/src/mobs/nav.rs b/crates/horizon-client/src/mobs/nav.rs index 178751ff6..d63035a61 100644 --- a/crates/horizon-client/src/mobs/nav.rs +++ b/crates/horizon-client/src/mobs/nav.rs @@ -580,6 +580,11 @@ impl Mob { if self.species() == super::Species::Bee { return super::bee::stable_destination(w, p); } + if self.species() == super::Species::Turtle + && let Some(stable) = super::turtle::stable_destination(self, w, p) + { + return stable; + } // StriderPathNavigation: lava too. if self.kind.flags.lava_walker && w.block_name(p[0], p[1], p[2]) == "minecraft:lava" { return true; diff --git a/crates/horizon-client/src/mobs/turtle.rs b/crates/horizon-client/src/mobs/turtle.rs index 98dd5b558..324a84a3a 100644 --- a/crates/horizon-client/src/mobs/turtle.rs +++ b/crates/horizon-client/src/mobs/turtle.rs @@ -1,18 +1,73 @@ //! Turtles (`Turtle`): the egg a bred mother carries (`TurtleBreedGoal`), her //! walk home (`TurtleGoHomeGoal`) and the egg she digs into the sand //! (`TurtleLayEggGoal`). `extra.flag` is `hasEgg`, `extra.flag2` `isLayingEgg`, -//! `extra.counter` `layEggCounter` and `extra.home` `homePos`. +//! `extra.counter` `layEggCounter`, `extra.home` `homePos`, `extra.counter2` +//! `goingHome` and `extra.point` `travelPos`. use super::{ Mob, MobEvent, MobWorld, - goals::{Breed, Cx, Goal, JUMP, MOVE, MoveToBlock, goal_clone, reduced}, + goals::{ + Breed, Cx, Goal, JUMP, LookAtPlayer, MOVE, MoveToBlock, Panic, Stroll, Tempt, goal_clone, + reduced, + }, + nav::NavKind, + path::PathType, }; +use crate::blocks::Fluid; use horizon_core::random::RandomSource; +/// `Turtle.registerGoals`, and the path maluses and navigation `Turtle` and +/// `TurtlePathNavigation` give it. pub fn register(m: &mut Mob) { + m.set_malus(PathType::Water, 0.0); + for t in [ + PathType::DoorIronClosed, + PathType::DoorWoodClosed, + PathType::DoorOpen, + ] { + m.set_malus(t, -1.0); + } + m.ai.nav.kind = NavKind::Amphibious; + let food = m.kind.food.clone(); let g = &mut m.ai.goals; + g.add(0, Panic::new(1.2).looking_for_water(7)); g.add(1, Breed::new(1.0)); g.add(1, LayEgg(MoveToBlock::new(1.0, 16, 1))); + g.add(2, Tempt::new(1.1, food, false)); + g.add( + 3, + GoToWater(MoveToBlock { + vertical_start: -1, + ..MoveToBlock::new(1.0, 24, 1) + }), + ); g.add(4, GoHome::default()); + g.add(7, Travel::default()); + g.add(8, LookAtPlayer::new(8.0)); + g.add(9, RandomStroll(Stroll::new(1.0).interval(100))); +} +/// `Turtle.goingHome`. +fn going_home(m: &Mob) -> bool { + m.extra.counter2 != 0 +} +fn set_going_home(m: &mut Mob, on: bool) { + m.extra.counter2 = i32::from(on); +} +/// `Turtle.getWalkTargetValue`; `light` is `getPathfindingCostFromLightLevels`. +pub fn walk_target_value(m: &Mob, w: &MobWorld, p: [i32; 3], light: f32) -> f32 { + if !going_home(m) && w.fluid(p[0], p[1], p[2]) == Fluid::Water + || is_sand(w, [p[0], p[1] - 1, p[2]]) + { + 10.0 + } else { + light + } +} +/// `TurtlePathNavigation.isStableDestination` while travelling: water only. +/// `None` without a `travelPos`, the amphibious rule then. +pub fn stable_destination(m: &Mob, w: &MobWorld, p: [i32; 3]) -> Option { + m.extra + .point + .map(|_| w.block_name(p[0], p[1], p[2]) == "minecraft:water") } /// `Turtle.hasEgg`. pub fn has_egg(m: &Mob) -> bool { @@ -165,10 +220,14 @@ impl Goal for GoHome { m.random.next_int_bound(reduced(700)).unwrap_or(1) == 0 && !close_to_home(m, 64.0) } } - fn start(&mut self, _m: &mut Mob, _cx: &mut Cx) { + fn start(&mut self, m: &mut Mob, _cx: &mut Cx) { + set_going_home(m, true); self.stuck = false; self.close_to_home_try_ticks = 0; } + fn stop(&mut self, m: &mut Mob, _cx: &mut Cx) { + set_going_home(m, false); + } fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { !close_to_home(m, 7.0) && !self.stuck && self.close_to_home_try_ticks <= reduced(600) } @@ -207,3 +266,170 @@ impl Goal for GoHome { } } } + +/// `Turtle.TurtleGoToWaterGoal`: a turtle on land walks to water within 24 +/// blocks, unless it is going home or carries an egg. +#[derive(Clone, Debug)] +struct GoToWater(MoveToBlock); +impl GoToWater { + fn valid(w: &MobWorld, p: [i32; 3]) -> bool { + w.block_name(p[0], p[1], p[2]) == "minecraft:water" + } +} +impl Goal for GoToWater { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | JUMP + } + fn name(&self) -> &'static str { + "TurtleGoToWaterGoal" + } + fn every_tick(&self) -> bool { + true + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let wanted = if m.is_baby() && !m.fluids.in_water { + true + } else { + !going_home(m) && !m.fluids.in_water && !has_egg(m) + }; + if !wanted { + return false; + } + // MoveToBlockGoal.canUse. + if self.0.next_start > 0 { + self.0.next_start -= 1; + return false; + } + self.0.next_start = reduced(200 + m.random.next_int_bound(200).unwrap_or(0)); + self.0.find_nearest(m, cx.w, Self::valid) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + !m.fluids.in_water && self.0.try_ticks <= 1200 && Self::valid(cx.w, self.0.block) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.start(m, cx.w); + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + // MoveToBlockGoal.tick, with shouldRecalculatePath every 160 ticks. + let b = self.0.block; + let d = [ + f64::from(b[0]) + 0.5 - m.position.x, + f64::from(b[1] + 1) + 0.5 - m.position.y, + f64::from(b[2]) + 0.5 - m.position.z, + ]; + if d[0] * d[0] + d[1] * d[1] + d[2] * d[2] >= 1.0 { + self.0.reached = false; + self.0.try_ticks += 1; + if self.0.try_ticks % 160 == 0 { + let at = [ + f64::from(b[0]) + 0.5, + f64::from(b[1] + 1), + f64::from(b[2]) + 0.5, + ]; + m.nav_move_to(cx.w, at, self.0.speed); + } + } else { + self.0.reached = true; + self.0.try_ticks -= 1; + } + } +} + +/// `Turtle.TurtleTravelGoal`: a turtle in water swims towards a spot up to +/// 512 blocks away, a leg at a time. +#[derive(Clone, Debug, Default)] +struct Travel { + stuck: bool, +} +impl Goal for Travel { + goal_clone!(); + fn flags(&self) -> u8 { + 0 + } + fn name(&self) -> &'static str { + "TurtleTravelGoal" + } + fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + !going_home(m) && !has_egg(m) && m.fluids.in_water + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + let xt = m.random.next_int_bound(1025).unwrap_or(0) - 512; + let mut yt = m.random.next_int_bound(9).unwrap_or(0) - 4; + let zt = m.random.next_int_bound(1025).unwrap_or(0) - 512; + if f64::from(yt) + m.position.y > f64::from(cx.w.sea_level - 1) { + yt = 0; + } + m.extra.point = Some([ + (f64::from(xt) + m.position.x).floor(), + (f64::from(yt) + m.position.y).floor(), + (f64::from(zt) + m.position.z).floor(), + ]); + self.stuck = false; + } + fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + !m.ai.nav.is_done() && !self.stuck && !going_home(m) && m.extra.in_love <= 0 && !has_egg(m) + } + fn stop(&mut self, m: &mut Mob, _cx: &mut Cx) { + m.extra.point = None; + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(travel) = m.extra.point else { + self.stuck = true; + return; + }; + if !m.ai.nav.is_done() { + return; + } + // Vec3.atBottomCenterOf(travelPos). + let to = [travel[0] + 0.5, travel[1], travel[2] + 0.5]; + let tenth = f64::from((std::f64::consts::PI / 10.0) as f32); + let half = f64::from(std::f32::consts::FRAC_PI_2); + let mut next = m + .default_random_pos_towards(cx.w, 16, 3, to, tenth) + .or_else(|| m.default_random_pos_towards(cx.w, 8, 7, to, half)); + if let Some(n) = next { + let (xc, zc) = (n[0].floor() as i32, n[2].floor() as i32); + // Level.hasChunksAt(xc - 34, zc - 34, xc + 34, zc + 34). + let loaded = ((xc - 34) >> 4..=(xc + 34) >> 4).all(|chunk_x| { + ((zc - 34) >> 4..=(zc + 34) >> 4) + .all(|chunk_z| cx.w.world.chunks.contains_key(&(chunk_x, chunk_z))) + }); + if !loaded { + next = None; + } + } + match next { + Some(at) => { + m.nav_move_to(cx.w, at, 1.0); + } + None => self.stuck = true, + } + } +} + +/// `Turtle.TurtleRandomStrollGoal`: no stroll in water, going home or with an +/// egg. +#[derive(Clone, Debug)] +struct RandomStroll(Stroll); +impl Goal for RandomStroll { + goal_clone!(); + fn flags(&self) -> u8 { + self.0.flags() + } + fn name(&self) -> &'static str { + "TurtleRandomStrollGoal" + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + !m.fluids.in_water && !going_home(m) && !has_egg(m) && self.0.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.0.can_continue(m, cx) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.start(m, cx); + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.stop(m, cx); + } +} From bca4513187c8697ced3a13d709ae75d74498b5ee Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:37:08 +0100 Subject: [PATCH 70/84] Keep withers out of Peaceful, raiders out of the spawn count, and use local difficulty for skeleton traps --- crates/horizon-client/src/game/lightning.rs | 8 ++++++-- crates/horizon-client/src/game/natural_spawning.rs | 4 +++- crates/horizon-client/src/game/wither.rs | 3 ++- crates/horizon-client/src/mobs/raider.rs | 4 ++++ 4 files changed, 15 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 8a3ac2745..ef3bef611 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -46,8 +46,12 @@ impl Game<'_> { if !self.with_level(|b, level, _| b.is_raining_at(level, p)) { continue; } - // Skeleton trap: effective difficulty / 100 (regional difficulty approximated). - let difficulty = f64::from(self.ui.difficulty) * 0.75; + // Skeleton trap: the local effective difficulty / 100 + // (`getCurrentDifficultyAt(pos)`). + let difficulty = f64::from( + self.local_difficulty([f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])]) + .effective, + ); let below = &self .res .facts() diff --git a/crates/horizon-client/src/game/natural_spawning.rs b/crates/horizon-client/src/game/natural_spawning.rs index 0035f5082..6a2cbcb70 100644 --- a/crates/horizon-client/src/game/natural_spawning.rs +++ b/crates/horizon-client/src/game/natural_spawning.rs @@ -504,7 +504,9 @@ impl<'a> Game<'a> { m.position.z.floor() as i32, ], is_mob: true, - persistent: m.persistent, + // isPersistenceRequired or requiresCustomPersistence + // (a raider in a raid). + persistent: m.persistent || horizon_client::mobs::raider::in_raid(m), }) .collect(); let players = players diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs index 8084425ca..ed9b97aa9 100644 --- a/crates/horizon-client/src/game/wither.rs +++ b/crates/horizon-client/src/game/wither.rs @@ -29,7 +29,8 @@ impl Game<'_> { /// After a wither skeleton skull is placed: the T of soul sand (or soul /// soil) under three skulls, upright along X or Z, becomes a wither. pub(super) fn check_wither_spawn(&mut self, placed: [i32; 3]) -> horizon_client::Result<()> { - if !self.is_wither_skull(placed) { + // Nothing is built in Peaceful (`level.getDifficulty() != PEACEFUL`). + if self.ui.difficulty == 0 || !self.is_wither_skull(placed) { return Ok(()); } // Pattern rows top to bottom: "^^^", "###", "~#~" ('~' air). diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs index d2ed62374..011ac2006 100644 --- a/crates/horizon-client/src/mobs/raider.rs +++ b/crates/horizon-client/src/mobs/raider.rs @@ -100,6 +100,10 @@ pub fn state(m: &Mob) -> Option<&State> { pub fn state_mut(m: &mut Mob) -> &mut State { m.extra.raider.get_or_insert_with(Box::default) } +/// `Raider.getCurrentRaid() != null`. +pub fn in_raid(m: &Mob) -> bool { + state(m).is_some_and(|s| s.raid_id.is_some()) +} pub fn has_active_raid(m: &Mob) -> bool { state(m).is_some_and(|s| s.active_raid) } From fc06585938b4c0a4386e3c43b7ff8352158e35df Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 06:33:43 +0100 Subject: [PATCH 71/84] Send mob particles to clients the way vanilla does --- crates/horizon-client/src/game.rs | 1 + crates/horizon-client/src/game/creatures.rs | 17 +++++ .../horizon-client/src/game/lan_particles.rs | 34 ++++++++++ crates/horizon-client/src/game/remote.rs | 17 +++++ .../src/game/remote_mob_particles.rs | 50 +++++++++++++++ crates/horizon-client/src/mobs.rs | 17 +++++ crates/horizon-client/src/mobs/ai.rs | 10 +-- crates/horizon-client/src/mobs/cube.rs | 62 +++++++++++-------- crates/horizon-client/src/mobs/illusioner.rs | 57 ++++++++++++----- crates/horizon-client/src/mobs/nautilus.rs | 19 ++++-- crates/horizon-client/src/mobs/ravager.rs | 9 ++- crates/horizon-client/src/mobs/undead.rs | 21 ++++--- crates/horizon-client/src/mobs/wither.rs | 20 ++++++ 13 files changed, 277 insertions(+), 57 deletions(-) create mode 100644 crates/horizon-client/src/game/remote_mob_particles.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 7699e83d7..b371d1a50 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -143,6 +143,7 @@ mod recipe_book; mod remote; mod remote_chunks; mod remote_mob_data; +mod remote_mob_particles; mod remote_mob_use; mod remote_objects; mod remote_projectiles; diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 2bc40a7af..02154e713 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -933,6 +933,23 @@ impl Game<'_> { match e { MobEvent::SquidCycle { mob, at } => self.lan_entity_event(mob as i32, 19, at), MobEvent::RabbitHop { mob, at } => self.lan_entity_event(mob as i32, 1, at), + MobEvent::EntityEvent { mob, event, at } => { + self.lan_entity_event(mob as i32, event, at) + } + MobEvent::LevelParticles { + kind, + at, + spread, + speed, + count, + } => { + if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) { + let options = horizon_client::particles::ParticleOptions::simple(ty); + self.particles + .send_particles(&options, at, spread, speed, count); + self.lan_level_particles(&options, at, spread, speed, count); + } + } MobEvent::Sound(name, at, volume, pitch) | MobEvent::LocalSound(name, at, volume, pitch) => { self.audio diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs index 648cef962..909ef8c36 100644 --- a/crates/horizon-client/src/game/lan_particles.rs +++ b/crates/horizon-client/src/game/lan_particles.rs @@ -82,6 +82,40 @@ impl Game<'_> { } } + /// `ServerLevel.sendParticles` of a mob's particles: a packet to each + /// player within 32 blocks. The window draws its own copy. + pub(super) fn lan_level_particles( + &self, + options: &ParticleOptions, + at: [f64; 3], + spread: [f64; 3], + speed: f64, + count: u32, + ) { + let (Some(host), Some(particle)) = (&self.lan, self.network_particle(options, None)) else { + return; + }; + let packet = C::LevelParticles(play::LevelParticles { + particle, + override_limiter: false, + always_show: false, + pos: at, + dist: spread.map(|d| d as f32), + max_speed: [speed as f32; 3], + count: count as i32, + randomization: 0, + }); + for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) { + // ServerLevel compares the player's block centre, strictly within 32. + let distance: f64 = (0..3) + .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2)) + .sum(); + if distance < 32.0 * 32.0 { + g.send(&packet); + } + } + } + /// `LivingEntity.checkFallDamage`'s `ServerLevel.sendParticles` of the /// landing block's crumbs: drawn in this window, when it has one, and /// sent to each player within 32 blocks. `host` is the hub of a guest's diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 77e143f9a..7daffdc44 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2130,6 +2130,10 @@ impl Game<'_> { self.ui.registries.permission = (p.event - 24) as u8; self.remote_world_options_permission(p.event >= 26); } + // Ravager.handleEntityEvent 69: the roar's puff and push. + if p.event == 69 { + self.remote_ravager_roar(p.id); + } if p.event == 1 && let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) && m.species() == horizon_client::mobs::Species::Rabbit @@ -3537,6 +3541,7 @@ impl Game<'_> { let head_lerps = &mut r.head_lerps; let players = &r.level_players; let mut using = Vec::new(); + let mut mob_fx = Vec::new(); for m in &mut self.mobs { let player = players.contains_key(&(m.id as i32)); if !running && !player { @@ -3576,6 +3581,17 @@ impl Game<'_> { if m.species() == horizon_client::mobs::Species::PolarBear { horizon_client::mobs::polar_bear::client_tick(m); } + // The particles these mobs' own ticks draw on the client side. + { + use horizon_client::mobs::{Species as S, cube, illusioner, nautilus, wither}; + match m.species() { + S::Slime | S::MagmaCube | S::SulfurCube => cube::client_tick(m, &mut mob_fx), + S::Nautilus | S::ZombieNautilus => nautilus::client_tick(m, &mut mob_fx), + S::Illusioner => illusioner::client_tick(m, &mut mob_fx), + S::Wither => wither::client_tick(m, &mut mob_fx), + _ => {} + } + } if m.hurt_time > 0 { m.hurt_time -= 1; } @@ -3672,6 +3688,7 @@ impl Game<'_> { d.tick(world, facts, collision, false, &self.res.motion().fluids); } head_lerps.retain(|_, (_, steps)| *steps > 0); + let _ = self.handle_mob_events(mob_fx); for (item, ticks, at, eye, pitch, yaw) in using { self.remote_player_eating(&item, ticks, at, eye, pitch, yaw); } diff --git a/crates/horizon-client/src/game/remote_mob_particles.rs b/crates/horizon-client/src/game/remote_mob_particles.rs new file mode 100644 index 000000000..e3daf284d --- /dev/null +++ b/crates/horizon-client/src/game/remote_mob_particles.rs @@ -0,0 +1,50 @@ +//! Particles a client of a server draws for a mob's entity event, which the +//! server does not send as a particle packet. +use super::Game; +use horizon_client::{ + mobs::Species, + particles::{ParticleOptions, ParticleType}, +}; +use horizon_core::{geometry::Vec3, random::RandomSource}; + +impl Game<'_> { + /// `Ravager.handleEntityEvent(69)`: forty puffs of smoke from the middle + /// of its box, then `applyRoarKnockbackClient`: this client's own player + /// within 4 blocks is thrown away from it. + pub(super) fn remote_ravager_roar(&mut self, id: i32) { + let Some(m) = self + .mobs + .iter() + .find(|m| m.id == id as u32 && m.species() == Species::Ravager) + else { + return; + }; + let (center, at, area) = ( + m.center(), + m.position, + m.bounds().inflate(Vec3::new(4.0, 4.0, 4.0)), + ); + let options = ParticleOptions::simple(ParticleType::Poof); + for _ in 0..40 { + let r = self.particles.random(); + let v = [ + r.next_gaussian() * 0.2, + r.next_gaussian() * 0.2, + r.next_gaussian() * 0.2, + ]; + self.particles.add(&options, center, v); + } + if let Some(view) = self.player_view() + && view.alive + && view.bounds.intersects(area) + && let Some(p) = self.player.as_mut() + { + // strongKnockback. + let (xd, zd) = (p.position.x - at.x, p.position.z - at.z); + let dd = (xd * xd + zd * zd).max(0.001); + p.velocity = p + .velocity + .add_vector(Vec3::new(xd / dd * 4.0, 0.2, zd / dd * 4.0)); + } + } +} diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 2325c3f5b..cc9a34641 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -903,6 +903,23 @@ pub enum MobEvent { mob: u32, at: [f64; 3], }, + /// `Level.broadcastEntityEvent` for a mob: guests run its + /// `handleEntityEvent`. + EntityEvent { + mob: u32, + event: i8, + at: [f64; 3], + }, + /// `ServerLevel.sendParticles`: drawn here and sent to the players within + /// 32 blocks, which spread and speed the way the client does for a count + /// (a count of 0 is one particle moving by speed times spread). + LevelParticles { + kind: &'static str, + at: [f64; 3], + spread: [f64; 3], + speed: f64, + count: u32, + }, Sound(&'static str, [f64; 3], f32, f32), /// `ChestBlockEntity.startOpen` / `stopOpen` by a copper golem: the /// chest's opener count goes up or down (interaction range 3). diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 26b94eeac..7790e2ce1 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -727,8 +727,8 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: & if m.kind.flags.climber { m.climbing = m.horizontal_collision; } - // AgeableMob.aiStep: a forced age-up's particles (positions drawn on the - // server too), then the age. + // AgeableMob.aiStep: a forced age-up's particles (`sendParticles`, so the + // players are sent them), then the age. if m.extra.forced_age_timer > 0 { if m.extra.forced_age_timer % 4 == 0 { let (w, h) = (f64::from(m.width()), f64::from(m.height())); @@ -737,10 +737,12 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: & let y = m.position.y + h * r.next_double() + 0.5; let z = m.position.z + w * (2.0 * r.next_double() - 1.0); // sendParticles(HAPPY_VILLAGER, x, y, z, 1, 0, 0, 0, 0): exactly there, at rest. - events.push(MobEvent::Particles { + events.push(MobEvent::LevelParticles { kind: "happy_villager", at: [x, y, z], - count: 0, + spread: [0.0; 3], + speed: 0.0, + count: 1, }); } m.extra.forced_age_timer -= 1; diff --git a/crates/horizon-client/src/mobs/cube.rs b/crates/horizon-client/src/mobs/cube.rs index ea8a05392..3cc16463c 100644 --- a/crates/horizon-client/src/mobs/cube.rs +++ b/crates/horizon-client/src/mobs/cube.rs @@ -151,37 +151,49 @@ pub fn jump(m: &mut Mob) { }; m.velocity.y = f64::from(m.jump_power() + boost); } +/// `AbstractCubeMob.tick`'s landing splash: crumbs of goo (or flames) around +/// the cube's feet, drawn by the side that ticks the mob. +fn landing_splash(m: &mut Mob, events: &mut Vec) { + let size = m.width() * 2.0; + let radius = size / 2.0; + let kind = match m.species() { + Species::MagmaCube => "flame", + Species::SulfurCube => "sulfur_cube_goo", + _ => "item_slime", + }; + let mut i = 0; + while (i as f32) < size * 16.0 { + let dir = m.random.next_float() * std::f64::consts::TAU as f32; + let d = m.random.next_float() * 0.5 + 0.5; + let xd = trig::sin(f64::from(dir)) * radius * d; + let zd = trig::cos(f64::from(dir)) * radius * d; + events.push(MobEvent::Particles { + kind, + at: [ + m.position.x + f64::from(xd), + m.position.y, + m.position.z + f64::from(zd), + ], + count: 0, + }); + i += 1; + } +} +/// `AbstractCubeMob.tick` on a client of a server: the landing splash follows +/// the on-ground flag the server sends. +pub fn client_tick(m: &mut Mob, events: &mut Vec) { + if m.on_ground && !m.extra.flag2 { + landing_splash(m, events); + } + m.extra.flag2 = m.on_ground; +} /// AbstractCubeMob.tick squish and landing sounds, plus contact damage. pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { let v = &mut m.anim.v; v[SQUISH] += (v[TARGET_SQUISH] - v[SQUISH]) * 0.5; let was = m.extra.flag2; if m.on_ground && !was { - // The landing splash: drawn on the server too, where it spawns nothing. - let size = m.width() * 2.0; - let radius = size / 2.0; - let kind = match m.species() { - Species::MagmaCube => "flame", - Species::SulfurCube => "sulfur_cube_goo", - _ => "item_slime", - }; - let mut i = 0; - while (i as f32) < size * 16.0 { - let dir = m.random.next_float() * std::f64::consts::TAU as f32; - let d = m.random.next_float() * 0.5 + 0.5; - let xd = trig::sin(f64::from(dir)) * radius * d; - let zd = trig::cos(f64::from(dir)) * radius * d; - events.push(MobEvent::Particles { - kind, - at: [ - m.position.x + f64::from(xd), - m.position.y, - m.position.z + f64::from(zd), - ], - count: 0, - }); - i += 1; - } + landing_splash(m, events); let squish = match (m.species(), tiny(m)) { (Species::SulfurCube, _) => super::sulfur_cube::squish_sound(m), (Species::MagmaCube, true) => "entity.magma_cube.squish_small", diff --git a/crates/horizon-client/src/mobs/illusioner.rs b/crates/horizon-client/src/mobs/illusioner.rs index ec17abad7..b98e56920 100644 --- a/crates/horizon-client/src/mobs/illusioner.rs +++ b/crates/horizon-client/src/mobs/illusioner.rs @@ -152,20 +152,7 @@ pub fn tick(m: &mut Mob, events: &mut Vec) { if !m.has_effect(INVISIBILITY) { return; } - let hurt = m.hurt_time; - let age = m.age; - let mut il = m.extra.illusions.take().unwrap_or_default(); - il.ticks = (il.ticks - 1).max(0); - if hurt == 1 || age.is_multiple_of(1200) { - il.ticks = 3; - for i in 0..COPIES { - il.offsets[0][i] = il.offsets[1][i]; - let r = &mut m.random; - let x = (-6 + r.next_int_bound(13).unwrap_or(0)) as f64 * 0.5; - let y = (r.next_int_bound(6).unwrap_or(0) - 4).max(0) as f64; - let z = (-6 + r.next_int_bound(13).unwrap_or(0)) as f64 * 0.5; - il.offsets[1][i] = [x, y, z]; - } + if step(m) { events.push(MobEvent::Particles { kind: "minecraft:cloud", at: [m.position.x, m.position.y + 0.9, m.position.z], @@ -177,6 +164,47 @@ pub fn tick(m: &mut Mob, events: &mut Vec) { 1.0, 1.0, )); + } +} + +/// `Illusioner.aiStep` on a client of a server: invisible is the synched +/// shared flag. The puff is drawn here exactly (sixteen `addParticle`s); the +/// sound comes from the server. +pub fn client_tick(m: &mut Mob, events: &mut Vec) { + if !m.invisible || !step(m) { + return; + } + let (w, h) = (f64::from(m.width()), f64::from(m.height())); + for _ in 0..16 { + // getRandomX(0.5), getRandomY() and getZ(0.5), which is not random. + let x = m.position.x + w * (2.0 * m.random.next_double() - 1.0) * 0.5; + let y = m.position.y + h * m.random.next_double(); + events.push(MobEvent::ParticleAt { + kind: "cloud", + at: [x, y, m.position.z + w * 0.5], + velocity: [0.0; 3], + }); + } +} + +/// The image offsets' clock of an invisible illusioner. True when the images +/// jumped to new offsets (hurt, or once a minute), which the puff goes with. +fn step(m: &mut Mob) -> bool { + let hurt = m.hurt_time; + let age = m.age; + let mut il = m.extra.illusions.take().unwrap_or_default(); + il.ticks = (il.ticks - 1).max(0); + let jumped = hurt == 1 || age.is_multiple_of(1200); + if jumped { + il.ticks = 3; + for i in 0..COPIES { + il.offsets[0][i] = il.offsets[1][i]; + let r = &mut m.random; + let x = (-6 + r.next_int_bound(13).unwrap_or(0)) as f64 * 0.5; + let y = (r.next_int_bound(6).unwrap_or(0) - 4).max(0) as f64; + let z = (-6 + r.next_int_bound(13).unwrap_or(0)) as f64 * 0.5; + il.offsets[1][i] = [x, y, z]; + } } else if hurt == 9 { il.ticks = 3; for i in 0..COPIES { @@ -185,6 +213,7 @@ pub fn tick(m: &mut Mob, events: &mut Vec) { } } m.extra.illusions = Some(il); + jumped } /// `Illusioner.getIllusionOffsets`. diff --git a/crates/horizon-client/src/mobs/nautilus.rs b/crates/horizon-client/src/mobs/nautilus.rs index 2fcf7eb46..864865846 100644 --- a/crates/horizon-client/src/mobs/nautilus.rs +++ b/crates/horizon-client/src/mobs/nautilus.rs @@ -293,19 +293,28 @@ fn bubbles(m: &mut Mob, events: &mut Vec) { f64::from(yaw.cos() * pitch.cos()), ]; let spread = m.random.next_double() * 0.8 * (1.0 + speed); - for _ in 0..3 { - let _ = (f64::from(m.random.next_float()) - 0.5) * spread; - } - events.push(MobEvent::Particles { + let velocity = [ + (f64::from(m.random.next_float()) - 0.5) * spread, + (f64::from(m.random.next_float()) - 0.5) * spread, + (f64::from(m.random.next_float()) - 0.5) * spread, + ]; + events.push(MobEvent::ParticleAt { kind: "bubble", at: [ m.position.x - dir[0] * 1.1, m.position.y - dir[1] + 0.25, m.position.z - dir[2] * 1.1, ], - count: 1, + velocity, }); } +/// `AbstractNautilus.tick` on a client of a server: the bubbles of a nautilus +/// in the water, from the motion the server sent. +pub fn client_tick(m: &mut Mob, events: &mut Vec) { + if m.fluids.in_water { + bubbles(m, events); + } +} fn in_water_at(w: &MobWorld, p: Vec3) -> bool { w.fluid(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32) == Fluid::Water } diff --git a/crates/horizon-client/src/mobs/ravager.rs b/crates/horizon-client/src/mobs/ravager.rs index 49bac4d9f..2db86e42a 100644 --- a/crates/horizon-client/src/mobs/ravager.rs +++ b/crates/horizon-client/src/mobs/ravager.rs @@ -197,7 +197,14 @@ fn roar(m: &mut Mob, w: &MobWorld, events: &mut Vec) { velocity: fling(s.position), }); } - // Entity event 69: a puff of smoke. + // Entity event 69: a puff of smoke, and the client's own push. A client + // of this server (the window of the server thread) gets the event; + // this window draws the puff itself. + events.push(MobEvent::EntityEvent { + mob: m.id, + event: 69, + at: from, + }); events.push(MobEvent::Particles { kind: "poof", at: [ diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs index 3707f4bbe..51a5cb0d2 100644 --- a/crates/horizon-client/src/mobs/undead.rs +++ b/crates/horizon-client/src/mobs/undead.rs @@ -978,16 +978,21 @@ impl Goal for AttackTurtleEgg { pos: eat, drop: false, }); + // `sendParticles(POOF, ..., 1, xa, ya, za, 0.15)`, twenty times. for _ in 0..20 { - m.random.next_gaussian(); - m.random.next_gaussian(); - m.random.next_gaussian(); + let spread = [ + m.random.next_gaussian() * 0.02, + m.random.next_gaussian() * 0.02, + m.random.next_gaussian() * 0.02, + ]; + cx.events.push(MobEvent::LevelParticles { + kind: "poof", + at: [center[0], f64::from(eat[1]), center[2]], + spread, + speed: 0.15, + count: 1, + }); } - cx.events.push(MobEvent::Particles { - kind: "poof", - at: [center[0], f64::from(eat[1]), center[2]], - count: 20, - }); // The break sound's pitch draws from the level random. cx.events.push(MobEvent::Sound( "block.turtle_egg.break", diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs index 6702686c5..f962f574f 100644 --- a/crates/horizon-client/src/mobs/wither.rs +++ b/crates/horizon-client/src/mobs/wither.rs @@ -169,6 +169,26 @@ fn target_pos(w: &MobWorld, id: i32) -> Option<([f64; 3], f64, bool)> { .map(|s| ([s.position.x, s.position.y, s.position.z], s.eye_y, false)), } } +/// `WitherBoss.aiStep` on a client of a server: the smoke about each head +/// (`radius` 0.3 of the wither's scale, which is 1 here). The heads' turning +/// and the coloured particles need the server's targets and invulnerable +/// ticks, which a client is not sent. +pub fn client_tick(m: &mut Mob, events: &mut Vec) { + for i in 0..3 { + let h = head_pos(m, i); + let r = &mut m.random; + let at = [ + h[0] + r.next_gaussian() * 0.3, + h[1] + r.next_gaussian() * 0.3, + h[2] + r.next_gaussian() * 0.3, + ]; + events.push(MobEvent::ParticleAt { + kind: "smoke", + at, + velocity: [0.0; 3], + }); + } +} /// `WitherBoss.aiStep` after `super.aiStep()`: the side heads turn, smoke /// rises from the heads (the particle offsets are drawn on the server too). pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { From 50cd5576f9fcaedd7373535afa1dbf4f94b6712c Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 11:06:03 +0100 Subject: [PATCH 72/84] Clear a flying player's fall distance on the server tick --- crates/horizon-client/src/game/lan_actions.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index ef177d26d..c7bd59f68 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -2211,6 +2211,7 @@ impl Game<'_> { let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height()); let at = g.position; let (sneaking, sleeping) = (g.sneaking, g.sleeping); + let riding = g.vehicle.is_some(); let mut soul = None; let events = self.as_guest(host, conn, |game| { let (rules, motion) = (game.world.health_rules, game.motion); @@ -2230,6 +2231,12 @@ impl Game<'_> { w.player.health.advance_clock(); let _ = w.fluid_base_tick(); w.player.ground.on_ground = from_ground; + // Player.aiStep: a flying player that isn't riding starts every tick + // with no fall distance, so flying down in creative and switching to + // survival lands without the flight's distance. + if w.player.flying && !riding { + w.player.fall_distance = 0.0; + } let travelled: Vec<[f64; 3]> = moves.iter().map(|m| m.0).collect(); // Entity.move's movementThisTick: each move, from where the // tick's first one started. From a23a7ec35af7afadf309ba240ac5843cf0f45c32 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 11:06:35 +0100 Subject: [PATCH 73/84] Drop the whole stack on Ctrl+Q by the physical Control key only --- crates/horizon-client/src/game/remote.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index e41aca43b..3dacecebd 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -4695,7 +4695,9 @@ impl Game<'_> { match key { KeyCode::KeyF if !self.spectator() => self.remote_swap_hands(), KeyCode::KeyQ if !self.spectator() => { - let all = self.keys.contains(&KeyCode::ControlLeft); + // Minecraft.hasControlDown: the physical keys, so a toggled + // sprint on Left Control does not make Q drop the stack. + let all = self.has_control_down(); self.remote_drop(all); } KeyCode::KeyE if self.riding_mount_with_menu() => { From 377fecbf7914e49fc3bdceece33252b234db599c Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 11:07:53 +0100 Subject: [PATCH 74/84] Draw a quad over fully opaque texels without the alpha cutout A dirt path's side faces skip the clear top row of their texture, but the cutout still ran on them: mip filtering blended that row into the top edge and dropped it. Vanilla bakes each quad's layer from the texels under its UVs, so these quads are solid. --- crates/horizon-client/src/mesher.rs | 7 ++++--- crates/horizon-client/src/models/catalog.rs | 4 +++- crates/horizon-client/src/sprites.rs | 23 +++++++++++++++++++++ 3 files changed, 30 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index 48d2f08bd..74a117d08 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -55,7 +55,7 @@ pub struct TerrainVertex { /// UV within the sprite, `UV_STEPS` per unit (`TerrainVertex::new`, /// `terrain.wgsl`'s `terrain_uv`). pub(crate) uv: [u16; 2], - /// Sprite array layer, with `OPAQUE_LAYER` for opaque leaves. + /// Sprite array layer, with `OPAQUE_LAYER` for opaque leaves and quads over opaque texels. pub layer: u16, /// Smooth light, 16x fixed point: sky in the low byte, block in the high one. pub light: u16, @@ -890,8 +890,9 @@ impl Mesher<'_> { target.push(TerrainVertex::new( [p[0] + origin[0], p[1] + origin[1], p[2] + origin[2]], q.uv[i], - // Opaque leaves (forceOpaque) draw in the solid layer: no alpha cutout. - if !self.cutout_leaves && state.leaves { + // Opaque leaves (forceOpaque) and quads over opaque texels draw in the + // solid layer: no alpha cutout (a dirt path's side skips its clear top row). + if face.opaque && !face.translucent || !self.cutout_leaves && state.leaves { face.layer as u16 | OPAQUE_LAYER } else { face.layer as u16 diff --git a/crates/horizon-client/src/models/catalog.rs b/crates/horizon-client/src/models/catalog.rs index 2e6326c40..c02e97240 100644 --- a/crates/horizon-client/src/models/catalog.rs +++ b/crates/horizon-client/src/models/catalog.rs @@ -28,6 +28,8 @@ use std::{ pub struct BakedFace { pub quad: ModelQuad, pub layer: u32, + /// The texels under the quad's UVs are all opaque (`SpriteContents.computeTransparency`): + /// drawn in the solid layer without an alpha test. pub opaque: bool, /// Fractional alpha: drawn in the sorted translucent pass. pub translucent: bool, @@ -230,9 +232,9 @@ impl StateModels { Ok(BakedFace { translucent: quad.material.force_translucent || sprites.translucent[layer as usize], + opaque: sprites.region_opaque(layer, &quad.uv), quad, layer, - opaque: sprites.opaque[layer as usize], }) }) .collect::>()?; diff --git a/crates/horizon-client/src/sprites.rs b/crates/horizon-client/src/sprites.rs index b720c5bfd..0d5871915 100644 --- a/crates/horizon-client/src/sprites.rs +++ b/crates/horizon-client/src/sprites.rs @@ -115,6 +115,29 @@ impl Sprites { pub fn count(&self) -> usize { self.native.len() } + /// `SpriteContents.computeTransparency(u0, v0, u1, v1)` is NONE: every texel under + /// the quad's UV box is fully opaque in every frame, so the quad needs no alpha test. + pub fn region_opaque(&self, layer: u32, uv: &[[f32; 2]; 4]) -> bool { + if self.opaque[layer as usize] { + return true; + } + let (side, frames, _) = &self.native[layer as usize]; + let side = *side as usize; + let range = |axis: usize| { + let lo = uv.iter().map(|p| p[axis]).fold(f32::INFINITY, f32::min); + let hi = uv.iter().map(|p| p[axis]).fold(f32::NEG_INFINITY, f32::max); + let clamp = |v: f32| (v.max(0.0) as usize).min(side); + clamp((lo * side as f32).floor())..clamp((hi * side as f32).ceil()) + }; + let (columns, rows) = (range(0), range(1)); + frames.iter().all(|frame| { + rows.clone().all(|y| { + columns + .clone() + .all(|x| frame[(y * side + x) * 4 + 3] == 255) + }) + }) + } /// Lay every layer out at one size: the largest texture's (resource packs /// may ship 32x, 64x... textures, like vanilla's stitched atlas), rounded /// up to a power of two and limited to [`MAX_ARRAY_BYTES`]. Smaller From 5d68512994628613d8962c1ce446d11a63a376e9 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 11:08:07 +0100 Subject: [PATCH 75/84] Keep the body facing forward when a player walks backwards --- crates/horizon-client/src/game/lan.rs | 14 +++++++++++--- crates/horizon-client/src/game/perspective.rs | 10 +++++++++- 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index a0f99bfca..1c9ee2dc1 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1520,10 +1520,18 @@ impl Game<'_> { m.head_yaw = g.head_yaw; m.head_pitch = g.pitch; let mut target = m.body_yaw; - if dx * dx + dz * dz > 0.002_500_000_2 { - target = (dz.atan2(dx) as f32).to_degrees() - 90.0; - } let wrap = |a: f32| (a + 180.0).rem_euclid(360.0) - 180.0; + if dx * dx + dz * dz > 0.002_500_000_2 { + // LivingEntity.tick: walking backwards the body faces away + // from the walk direction, not along it. + let walk = (dz.atan2(dx) as f32).to_degrees() - 90.0; + let facing = (wrap(g.yaw) - walk).abs(); + target = if 95.0 < facing && facing < 265.0 { + walk - 180.0 + } else { + walk + }; + } m.body_yaw += wrap(target - m.body_yaw) * 0.3; let diff = wrap(g.yaw - m.body_yaw); if diff.abs() > 50.0 { diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index caf49883b..2956f8162 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -372,7 +372,15 @@ impl Game<'_> { m.head_pitch = pitch; let mut target = m.body_yaw; if dx * dx + dz * dz > 0.002_500_000_2 { - target = (dz.atan2(dx) as f32).to_degrees() - 90.0; + // LivingEntity.tick: walking backwards the body faces away from + // the walk direction, not along it. + let walk = (dz.atan2(dx) as f32).to_degrees() - 90.0; + let facing = (wrap(yaw) - walk).abs(); + target = if 95.0 < facing && facing < 265.0 { + walk - 180.0 + } else { + walk + }; } if swinging { target = yaw; From a05dc35c3906ed7b2364e4de18b9474222578059 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 11:08:49 +0100 Subject: [PATCH 76/84] Launch a Riptide trident on a server's client when the use is released --- crates/horizon-client/src/game/remote.rs | 13 ++++++++++++- crates/horizon-client/src/game/trident.rs | 17 ++++++++++++++--- 2 files changed, 26 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index e41aca43b..588fbfdeb 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -5751,7 +5751,18 @@ impl horizon_client::interaction_input::InteractionWorld for RemoteInputWorld<'_ direction: 0, sequence: 0, })); - self.0.using = None; + // MultiPlayerGameMode.releaseUsingItem also runs `Item.releaseUsing` here: the + // player moves by itself, so a Riptide launch happens on the client. + let hand = self.0.used_hand(); + if let Some((slot, ticks)) = self.0.using.take() + && let Some(hand) = hand + && self + .0 + .stack_in(slot) + .is_some_and(|s| &*s.item == "minecraft:trident") + { + self.0.with_hand(hand, |g| g.release_trident(ticks)); + } } fn start_attack(&mut self) -> bool { self.0.remote_start_attack() diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs index 9d6b3f9c5..0ab873f40 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -240,7 +240,12 @@ impl Game<'_> { if !self.in_water_or_rain() || self.riding.is_some() { return; } - self.hurt_held_without_breaking(1); + // `hurtWithoutBreaking` and the sound belong to the server; a server's + // client only launches. + let server_client = self.remote.is_some(); + if !server_client { + self.hurt_held_without_breaking(1); + } // trident_spin_attack_strength: 1.5 + 0.75 per level above the first. let strength = 1.5 + 0.75 * (riptide as f32 - 1.0); let d = view_vector(self.yaw, self.pitch); @@ -257,8 +262,14 @@ impl Game<'_> { p.position.y += 1.2; } } - let sound = format!("minecraft:item.trident.riptide_{}", riptide.min(3)); - self.audio.play(&sound, at, 1.0, 1.0); + if !server_client { + let sound = format!("minecraft:item.trident.riptide_{}", riptide.min(3)); + self.audio.play(&sound, at, 1.0, 1.0); + } + return; + } + // The server throws the trident. + if self.remote.is_some() { return; } // hurtWithoutBreaking (Unbreaking applies), then the thrown copy. From 3c85d2558bddad95e736215b5dda428ed2396297 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 11:11:36 +0100 Subject: [PATCH 77/84] Tell a server player's client about its velocity after a mace smash --- crates/horizon-client/src/game/lan_actions.rs | 18 +++++++++++++++--- crates/horizon-client/src/game/mace.rs | 3 +++ 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index ef177d26d..1a1ebaadb 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1567,9 +1567,21 @@ impl Game<'_> { if self.look_at_entity(host, gi, id, None).is_none() { return; } - self.as_guest(host, conn, |g| { - g.attack(); - }); + // A mace's smash sets the attacker's velocity and sends it at once, before the + // Wind Burst's push (MaceItem.hurtEnemy, then the post-attack effects). + let sent = self + .as_guest(host, conn, |g| { + let marked = g + .player + .as_mut() + .is_some_and(|p| std::mem::take(&mut p.health.sync_velocity)); + g.attack(); + let p = g.player.as_mut()?; + let sent = std::mem::replace(&mut p.health.sync_velocity, marked); + sent.then_some(p.velocity) + }) + .flatten(); + self.send_guest_motion(host, conn, sent); // The mob now answers to this guest (game/lan_mobs.rs). if let Ok(id) = u32::try_from(id) { host.mob_players.insert(id, conn); diff --git a/crates/horizon-client/src/game/mace.rs b/crates/horizon-client/src/game/mace.rs index 34c968980..b7d04b265 100644 --- a/crates/horizon-client/src/game/mace.rs +++ b/crates/horizon-client/src/game/mace.rs @@ -181,6 +181,9 @@ impl Game<'_> { return; }; p.velocity = Vec3::new(p.velocity.x, f64::from(0.01f32), p.velocity.z); + // A server player's client is told (ClientboundSetEntityMotionPacket): it moves by + // itself, so without it a Wind Burst's push would add to the speed of the fall. + p.health.sync_velocity = true; // calculateImpactPosition: an earlier impact below the player stays. let impact = match p.impulse.impact_position { Some(at) if at.y <= p.position.y => at, From e350b87b3c28480c672943e832ff38aae5fce02a Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 27 Oct 2026 15:07:40 +0100 Subject: [PATCH 78/84] End portal exits pass no spawn finder main's item and mob End portal exit calls end_arrival, which now takes the respawn search's finder; in the End it only builds the platform. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/nether_portal.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/nether_portal.rs b/crates/horizon-client/src/game/nether_portal.rs index c8142284a..261e0cd10 100644 --- a/crates/horizon-client/src/game/nether_portal.rs +++ b/crates/horizon-client/src/game/nether_portal.rs @@ -297,7 +297,8 @@ impl Game<'_> { let p = plan.approximate; let centre = Vec3::new(f64::from(p.x) + 0.5, f64::from(p.y), f64::from(p.z) + 0.5); if plan.dim == Dim::End { - if let Err(e) = self.end_arrival(centre) { + // In the End the arrival only builds the platform: no spawn search. + if let Err(e) = self.end_arrival(centre, &mut None) { log::error!("End platform: {e}"); } return centre; From 0879f3dbd2cb1a822946cded7f607607f5eb67ce Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 27 Oct 2026 15:37:04 +0100 Subject: [PATCH 79/84] parity: a host's exclude list also holds on its own CI runner playhorizon's runner fails remote_fireball and remote_fireworks even alone and at bare main (3b19c386c: 2 of 2 runs and the retry), while the Mac mini passes them; every fork PR whose parity lands there stopped on them. The host's exclude list only kept harnesses off workers sent there, not off the runner's own jobs: platform_skips now adds the local host's exclude, skipped with its reason unless named. The two harnesses join playhorizon's list; the Mac mini's runner and the nightly audit (macOS) keep running them. Co-Authored-By: Claude Opus 5.5 --- docs/parity-workflow.md | 2 +- tests/test_parity_runner.py | 7 +++++++ tools/parity.py | 14 ++++++++------ tools/parity_hosts.json | 4 +++- 4 files changed, 19 insertions(+), 8 deletions(-) diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md index 5c83c6a33..f527c9476 100644 --- a/docs/parity-workflow.md +++ b/docs/parity-workflow.md @@ -42,7 +42,7 @@ The game logs into `HORIZON_HOME` and falls back to the player's own game folder Harnesses can also run on the Mac mini, the desktop and playhorizon (`tools/parity_hosts.json` describes them; `desktop` and `playhorizon` use their CI runner's environment and vanilla data, and the desktop refuses work, or stops it, while someone uses it: docs/release-flow.md, "The desktop's runner"; its `default` list is empty, so pass `--hosts macmini,playhorizon` or set `PARITY_HOSTS`, after copying `shared-local/` to `~/code/horizon-parity/shared-local` on each host). The runner mirrors the worktree there with rsync (not `.git`, `.local`, `target` or ignored files) into `~/code/horizon-parity/remote/`, whose `.local` links to the vanilla data in `~/code/horizon-parity/shared-local`, and starts `tools/parity.py --worker` over ssh. The worker builds the probes (about 80 s the first time) and runs what it is sent under the same tracer, admitting harnesses against its own free memory. One queue, longest first, feeds every machine, remote ones first: the Mac takes up to 14 harnesses, the desktop 8, playhorizon 3 (on CPUs 0-3: its CI runner has 4-7). Each pass comes back with the content hash of every file it depended on, so it is keyed on exactly what ran, and logs come back to `.local/parity-runner/logs/`; state, sharing and `gate.py` work as before. If a host can't be reached, or drops out, its harnesses run here. -Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip` runs the game on a virtual screen) and each host's `exclude`. The Mac excludes nothing: vanilla's `Math.sin`, `pow`, `log` and the like don't round the same on an Apple silicon Mac as on Linux (HotSpot uses fdlibm there, Intel's stubs on x86-64), and Rust's float functions round like neither (they call the platform libm), so code that mirrors a vanilla `Math` call uses `horizon_core::jmath`, which computes what HotSpot computes on the host architecture. The ThinkPad no longer runs harnesses (2026-10-26): playhorizon is the Linux host that is always on. +Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip` runs the game on a virtual screen) and each host's `exclude`. A host's `exclude` also holds when `parity.py` runs on that host itself, as its CI runner does: the harness is skipped there with its reason (playhorizon skips `remote_fireball` and `remote_fireworks`, which its CPU-starved CI slice fails even on bare main), unless named on the command line. The Mac mini's runner and the nightly audit still run them. The Mac excludes nothing: vanilla's `Math.sin`, `pow`, `log` and the like don't round the same on an Apple silicon Mac as on Linux (HotSpot uses fdlibm there, Intel's stubs on x86-64), and Rust's float functions round like neither (they call the platform libm), so code that mirrors a vanilla `Math` call uses `horizon_core::jmath`, which computes what HotSpot computes on the host architecture. The ThinkPad no longer runs harnesses (2026-10-26): playhorizon is the Linux host that is always on. The file's `solo` list names harnesses that drive game windows (`remote_fireworks`, `server_player_sculk`, `world_reopen`, ...). On a machine where `parity.py` has 4 CPUs or fewer, such as playhorizon's CI runner, each of them runs alone, after the others: there frames are drawn on the CPU, and beside other harnesses a screenshot or a control request took more ticks than the check allows. `PARITY_SOLO=1` or `0` forces this on or off. diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py index fdc636a24..f26cbd5da 100644 --- a/tests/test_parity_runner.py +++ b/tests/test_parity_runner.py @@ -145,6 +145,13 @@ class ParityRunnerTests(unittest.TestCase): with mock.patch.object(parity.sys, "platform", "darwin"): self.assertEqual(parity.platform_skips(config), {"options": "libm"}) + def test_a_hosts_excludes_are_skipped_when_it_runs_parity_itself(self): + config = {"hosts": {"playhorizon": {"exclude": {"remote_fireworks": "starved"}}, "macmini": {"exclude": {}}}} + with mock.patch.object(parity.sys, "platform", "linux"): + self.assertEqual(parity.platform_skips(config, "playhorizon"), {"remote_fireworks": "starved"}) + self.assertEqual(parity.platform_skips(config, "macmini"), {}) + self.assertEqual(parity.platform_skips(config, "elsewhere"), {}) + def test_named_only_harnesses_are_listed_from_the_host_config(self): self.assertEqual(parity.named_only({"named_only": {"lan_integration": "slow"}}), {"lan_integration": "slow"}) self.assertEqual(parity.named_only({}), {}) diff --git a/tools/parity.py b/tools/parity.py index 38d113cab..f8f48fbcf 100644 --- a/tools/parity.py +++ b/tools/parity.py @@ -1454,11 +1454,13 @@ def affected_harnesses(found, records, changed, reach=True, base=None): return affected -def platform_skips(config): - """Harnesses tools/parity_hosts.json marks as giving different results on this platform: {name: reason}.""" - if sys.platform == "linux": - return {} - return dict(config.get("linux_only", {})) +def platform_skips(config, host=None): + """Harnesses tools/parity_hosts.json marks as giving different results on this platform, and those this host's + entry excludes (playhorizon's CI runner runs its own pull request jobs here, not only workers sent to it): + {name: reason}.""" + skips = {} if sys.platform == "linux" else dict(config.get("linux_only", {})) + skips.update(config.get("hosts", {}).get(HOST if host is None else host, {}).get("exclude", {})) + return skips def known_flaky(config): @@ -1593,7 +1595,7 @@ def main(): chosen = [name for name in found if stale(name, state, hasher, environment)] skips = platform_skips(host_config()) for name in [name for name in chosen if base_name(name) in skips and not args.names]: - print(f"skipped on {sys.platform}: {name}: {skips[base_name(name)]}", flush=True) + print(f"skipped on {HOST} ({sys.platform}): {name}: {skips[base_name(name)]}", flush=True) chosen.remove(name) manual = {} if args.names or args.all else named_only(host_config()) for name in [name for name in chosen if base_name(name) in manual]: diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json index cec022194..2df32ba41 100644 --- a/tools/parity_hosts.json +++ b/tools/parity_hosts.json @@ -31,7 +31,9 @@ "exclude": { "mob_ai": "the vanilla oracle runs out of its 3 GB heap here (OutOfMemoryError in IO workers; passes on the desktop and the Mac) - 2026-10-26 trial", "lan_integration": "two clients rendered on the CPU (lavapipe): different timing subtests fail on each run (elytra, consume-release, barter, critical-hits) - 2026-10-26 trial", - "world_reopen": "failed twice here (no Save and Quit button after reopening; the minecart-count flake), passes on the desktop - 2026-10-26 trial" + "world_reopen": "failed twice here (no Save and Quit button after reopening; the minecart-count flake), passes on the desktop - 2026-10-26 trial", + "remote_fireball": "fails here even alone, at bare main 3b19c386c (2 of 2 runs and the retry), and passes on the Mac mini: the guest's egg is seen in 2 of 6 samples. CPU-starved: the whole horizon-ci slice (runner on 4-7, workers on 0-3) shares a 700% quota and was throttled in 27% of periods, so lavapipe frames and screenshots outlast the projectile's flight - 2026-10-27", + "remote_fireworks": "fails here even alone, at bare main 3b19c386c (2 of 2 runs and the retry), and passes on the Mac mini: the guest's sparks are gone by its trail screenshot (same CPU starvation as remote_fireball; a private Xvfb on CPUs 0-3 did not help) - 2026-10-27" }, "note": "a partner's server (Ubuntu, 8 EPYC threads, 30 GB, Detroit; tailnet only), its CI runner has CPUs 4-7, so workers get 0-3 (as tools/remote.sh runs do) and 3 jobs, in the CI runner's environment, slice and Xvfb screen (tools/ci/linux-runner.sh); the always-on Linux host since the ThinkPad stopped running harnesses (2026-10-26)" } From 967a9363ceec4e58f8dd6a42e32aca6d2fd28898 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 27 Oct 2026 16:35:07 +0100 Subject: [PATCH 80/84] entity_death_loot: give wolves their gear in the body slot Horizon now keeps a wolf's body armour in its head slot, as for the other BODY types. Co-Authored-By: Claude Opus 5.5 --- tools/test_entity_death_loot_parity.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/test_entity_death_loot_parity.py b/tools/test_entity_death_loot_parity.py index 2bb53ebbb..39aa6edda 100644 --- a/tools/test_entity_death_loot_parity.py +++ b/tools/test_entity_death_loot_parity.py @@ -31,7 +31,7 @@ SKIPPED = {'player', 'mannequin', 'armor_stand', 'ender_dragon', 'giant'} # Types Horizon keeps body armour for in the head slot: their corpus wears # body items instead of helmets. BODY = {'horse', 'donkey', 'mule', 'skeleton_horse', 'zombie_horse', 'camel', 'camel_husk', 'llama', 'trader_llama', - 'happy_ghast', 'nautilus', 'zombie_nautilus', 'sulfur_cube'} + 'happy_ghast', 'nautilus', 'zombie_nautilus', 'sulfur_cube', 'wolf'} WEAPONS = ['minecraft:iron_sword', 'minecraft:diamond_sword;looting:1', 'minecraft:diamond_sword;looting:2', 'minecraft:netherite_sword;looting:3', 'minecraft:golden_sword;fire_aspect:2', 'minecraft:diamond_axe;looting:3;fire_aspect:1'] ARMOUR = {'head': 'minecraft:iron_helmet', 'chest': 'minecraft:chainmail_chestplate', 'legs': 'minecraft:golden_leggings', From 1bd74d1b2f358bb878ddf432539fc5bcc015d6cd Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 27 Oct 2026 16:35:07 +0100 Subject: [PATCH 81/84] Skip the world spawn trip's teleport when the respawn already put the player there Vanilla teleports a respawning player once; the second, identical move showed up in the dedicated_server, pearl_death and cursor_death harnesses. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/server_travel.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/horizon-client/src/game/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs index ac983dff1..e516d3f67 100644 --- a/crates/horizon-client/src/game/server_travel.rs +++ b/crates/horizon-client/src/game/server_travel.rs @@ -423,6 +423,9 @@ impl Game<'_> { let suggestion = [trip.target.x, trip.target.y, trip.target.z].map(|v| v.floor() as i32); match self.search_spawn(suggestion, &mut trip.finder) { + // The respawn already put the player on this column: + // vanilla teleports once, so no second move. + Ok(at) if host.hub.guests[i].position == [at.x, at.y, at.z] => continue, Ok(at) => (at, yaw), Err(chunk) => { self.spawn_wait.push(chunk); From 854bcb158f78d8af9c6cfea262603bca6ad5c245 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 27 Oct 2026 16:35:08 +0100 Subject: [PATCH 82/84] random_tick probe: a fresh suspicious block's reset check changes nothing Co-Authored-By: Claude Opus 5.5 --- crates/horizon-world/examples/probe/block_update_fixture.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/crates/horizon-world/examples/probe/block_update_fixture.rs b/crates/horizon-world/examples/probe/block_update_fixture.rs index 5be9be731..fdb5e20e0 100644 --- a/crates/horizon-world/examples/probe/block_update_fixture.rs +++ b/crates/horizon-world/examples/probe/block_update_fixture.rs @@ -427,9 +427,11 @@ pub fn main() -> Result<(), Box> { // A fresh shrieker has warning level 0 and so never responds, // and no player is near enough for a portal to spawn a piglin. // A fresh command block has no command and is neither powered - // nor always active: `CommandBlock.tick` changes nothing. + // nor always active: `CommandBlock.tick` changes nothing. A + // fresh suspicious block was never brushed, so + // `BrushableBlockEntity.checkReset` has nothing to reset. LevelEvent::BlockEvent { - kind: "shrieker_respond" | "portal_spawn" | "command_block", + kind: "shrieker_respond" | "portal_spawn" | "command_block" | "brushable", .. } => {} LevelEvent::BlockEvent { kind, .. } => { From 9914a8af4113d595361cad8c02c576e4f30e1667 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 27 Oct 2026 16:47:06 +0100 Subject: [PATCH 83/84] Name the wither's client smoke tick client_smoke #2685 adds wither::client_tick for the side heads' turning on a client; a distinct name lets both land without a clash. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/remote.rs | 2 +- crates/horizon-client/src/mobs/wither.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7e145b952..8d6479076 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3796,7 +3796,7 @@ impl Game<'_> { S::Slime | S::MagmaCube | S::SulfurCube => cube::client_tick(m, &mut mob_fx), S::Nautilus | S::ZombieNautilus => nautilus::client_tick(m, &mut mob_fx), S::Illusioner => illusioner::client_tick(m, &mut mob_fx), - S::Wither => wither::client_tick(m, &mut mob_fx), + S::Wither => wither::client_smoke(m, &mut mob_fx), _ => {} } } diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs index c8248106c..0a429b135 100644 --- a/crates/horizon-client/src/mobs/wither.rs +++ b/crates/horizon-client/src/mobs/wither.rs @@ -173,7 +173,7 @@ fn target_pos(w: &MobWorld, id: i32) -> Option<([f64; 3], f64, bool)> { /// (`radius` 0.3 of the wither's scale, which is 1 here). The heads' turning /// and the coloured particles need the server's targets and invulnerable /// ticks, which a client is not sent. -pub fn client_tick(m: &mut Mob, events: &mut Vec) { +pub fn client_smoke(m: &mut Mob, events: &mut Vec) { for i in 0..3 { let h = head_pos(m, i); let r = &mut m.random; From 674596103f0ef695d8cb77ccf6a00fbbd4c755c3 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 27 Oct 2026 17:56:36 +0100 Subject: [PATCH 84/84] nightly: Online5277 is the third trusted reviewer, not levzzz5154 Ludovic asked for his top three contributors by merged pull requests: kacpherek, rdbtCVS and Online5277. Co-Authored-By: Claude Opus 5.5 --- .github/nightly-reviewers.txt | 2 +- docs/release-flow.md | 2 +- tests/test_nightly_set.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/nightly-reviewers.txt b/.github/nightly-reviewers.txt index 5b737439c..a2f9606aa 100644 --- a/.github/nightly-reviewers.txt +++ b/.github/nightly-reviewers.txt @@ -4,4 +4,4 @@ # A line with only `paused` stops every reviewer's `/nightly` (Ludovic's still work). kacpherek # added by Ludovic, 2026-10-27 rdbtCVS # added by Ludovic, 2026-10-27 -levzzz5154 # added by Ludovic, 2026-10-27 +Online5277 # added by Ludovic, 2026-10-27 (his top three by merged pull requests) diff --git a/docs/release-flow.md b/docs/release-flow.md index 1089b9444..5377b27bc 100644 --- a/docs/release-flow.md +++ b/docs/release-flow.md @@ -423,7 +423,7 @@ before the gate. ### Trusted reviewers pick the pull requests The Nightly is where contributors test pull requests before the gate. The trusted reviewers listed in -`.github/nightly-reviewers.txt` (kacpherek, rdbtCVS and levzzz5154 since 2026-10-27) and Ludovic pick them with a +`.github/nightly-reviewers.txt` (kacpherek, rdbtCVS and Online5277 since 2026-10-27) and Ludovic pick them with a comment on any issue or pull request (`.github/workflows/nightly-command.yml`, `tools/ci/nightly_set.py`): ```text diff --git a/tests/test_nightly_set.py b/tests/test_nightly_set.py index a235a29c1..4ba8d43d3 100644 --- a/tests/test_nightly_set.py +++ b/tests/test_nightly_set.py @@ -73,7 +73,7 @@ class AllowTests(unittest.TestCase): def test_the_repos_list_names_the_three_reviewers(self): reviewers = ns.read_reviewers((ROOT / ns.REVIEWERS).read_text()) - self.assertEqual(reviewers.logins, {"kacpherek", "rdbtcvs", "levzzz5154"}) + self.assertEqual(reviewers.logins, {"kacpherek", "rdbtcvs", "online5277"}) self.assertFalse(reviewers.paused) class RefusalTests(unittest.TestCase):