diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index c84000fe5..99bed480e 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -7774,7 +7774,9 @@ impl Game<'_> { self.yaw }; for m in &self.mobs { - if m.fire_ticks > 0 && !m.removed { + // Blaze.isOnFire: a charged blaze burns. + let blazing = m.species() == horizon_client::mobs::Species::Blaze && m.extra.flag; + if (m.fire_ticks > 0 || blazing) && !m.removed { let at = m.previous.lerp(m.position, alpha); horizon_client::fire_render::flames( [at.x, at.y, at.z], diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 506409b1d..33ab22425 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -14,7 +14,7 @@ use horizon_client::{ hub::{BodyFlags, HostEvent, HostState, Hub, HubConfig, TickCtx}, playerdata, }, - mobs::{Mob, Who, leash::Holder}, + mobs::{Mob, Species, Who, leash::Holder}, text::Text, }; use horizon_core::geometry::Vec3; @@ -168,6 +168,7 @@ pub(super) fn baby_index(kind: &str) -> Option { | "minecraft:zombie_villager" | "minecraft:zombified_piglin" | "minecraft:hoglin" + | "minecraft:zoglin" | "minecraft:goat" | "minecraft:ocelot" | "minecraft:turtle" @@ -324,9 +325,13 @@ fn mob_meta( defaults: &mut Vec<(u8, i32, Value)>, ) { let kind = m.kind.id.as_str(); - // Entity.DATA_SHARED_FLAGS_ID: on fire 0x01, glowing 0x40 - // (LivingEntity.updateGlowingStatus). - let shared = i8::from(m.fire_ticks > 0) | i8::from(m.is_currently_glowing()) << 6; + // Entity.DATA_SHARED_FLAGS_ID: on fire 0x01, swimming 0x10 (a drowned + // under water, `Drowned.setSwimming`), invisible 0x20 (the effect's flag) + // and glowing 0x40 (LivingEntity.updateGlowingStatus). + let shared = i8::from(m.fire_ticks > 0) + | i8::from(m.species() == Species::Drowned && m.extra.flag) << 4 + | i8::from(m.invisible || horizon_client::mobs::trader::is_invisible(m)) << 5 + | i8::from(m.is_currently_glowing()) << 6; if shared != 0 { meta.push((0, serializer::BYTE, Value::Byte(shared))); } @@ -336,6 +341,12 @@ fn mob_meta( if pose != 0 { meta.push((6, serializer::POSE, Value::Id(i32::from(pose)))); } + // LivingEntity.DATA_SLEEPING_POS_ID: the bed a sleeping villager lies in. + if horizon_client::mobs::villager::sleeping(m) + && let Some(bed) = m.extra.bed + { + meta.push((14, serializer::OPTIONAL_BLOCK_POS, Value::OptPos(Some(bed)))); + } if let Some(name) = &m.custom_name { meta.push(( 2, @@ -430,8 +441,14 @@ fn mob_meta( } defaults.push((17, serializer::INT, Value::Int(0))); } - // Piglin.DATA_IS_DANCING (after the baby flag and the crossbow charge). + // AbstractPiglin.DATA_IMMUNE_TO_ZOMBIFICATION (16: with the dimension it + // makes it shake) and Piglin.DATA_IS_DANCING (after the baby flag and + // the crossbow charge). "minecraft:piglin" => { + if e.flag2 { + meta.push((16, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((16, serializer::BOOLEAN, Value::Bool(false))); if e.scratch[0] > 0 { meta.push((19, serializer::BOOLEAN, Value::Bool(true))); } @@ -518,10 +535,16 @@ fn mob_meta( | "minecraft:skeleton_horse" | "minecraft:zombie_horse" | "minecraft:camel" => { - // AbstractHorse.DATA_ID_FLAGS: tame 2. - if e.tame { - meta.push((18, serializer::BYTE, Value::Byte(2))); + // AbstractHorse.DATA_ID_FLAGS: tame 2, eating 16 (grazing), standing + // 32 (rearing). + let grazes = horizon_client::mobs::equine::grazes(m.species()); + let flags = if e.tame { 2 } else { 0 } + | if grazes && e.flag { 16 } else { 0 } + | if grazes && e.counter > 0 { 32 } else { 0 }; + if flags != 0 { + meta.push((18, serializer::BYTE, Value::Byte(flags))); } + defaults.push((18, serializer::BYTE, Value::Byte(0))); if kind == "minecraft:horse" { let v = i32::from(e.variant) | i32::from(e.variant2) << 8; if v != 0 { @@ -554,6 +577,15 @@ fn mob_meta( // Villager.DATA_VILLAGER_DATA and ZombieVillager's (after Zombie's three). "minecraft:villager" | "minecraft:zombie_villager" => { use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; + if kind == "minecraft:villager" { + unhappy_counter(m, meta, defaults); + } else { + // ZombieVillager.DATA_CONVERTING_ID: the cure's shaking. + if horizon_client::mobs::zombie_villager::is_converting(m) { + meta.push((19, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((19, serializer::BOOLEAN, Value::Bool(false))); + } let villager_type = VILLAGER_TYPES[e.variant as usize % VILLAGER_TYPES.len()]; let profession = PROFESSIONS[e.variant2 as usize % PROFESSIONS.len()]; if let (Some(t), Some(p)) = ( @@ -761,6 +793,60 @@ fn mob_meta( meta.push((17, serializer::BOOLEAN, Value::Bool(true))); } defaults.push((17, serializer::BOOLEAN, Value::Bool(false))); + defaults.push((16, serializer::OPTIONAL_BLOCK_STATE, Value::Id(0))); + } + // Zombie.DATA_DROWNED_CONVERSION_ID (after DATA_BABY_ID and + // DATA_SPECIAL_TYPE_ID): the shaking of the conversion under water. + "minecraft:zombie" | "minecraft:husk" => { + if e.counter2 > 0 { + meta.push((18, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((18, serializer::BOOLEAN, Value::Bool(false))); + } + // AbstractVillager.DATA_UNHAPPY_COUNTER (after AgeableMob's two). + "minecraft:wandering_trader" => unhappy_counter(m, meta, defaults), + // Hoglin.DATA_IMMUNE_TO_ZOMBIFICATION (after AgeableMob's two) and + // AbstractPiglin's, the first entry of its subclasses (the piglin's is + // in its own arm): with the dimension it makes them shake. + "minecraft:hoglin" | "minecraft:piglin_brute" => { + let index = if kind == "minecraft:hoglin" { 18 } else { 16 }; + if e.flag2 { + meta.push((index, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((index, serializer::BOOLEAN, Value::Bool(false))); + } + // Blaze.DATA_FLAGS_ID: charged 1, which makes it burn. + "minecraft:blaze" => { + if e.flag { + meta.push((16, serializer::BYTE, Value::Byte(1))); + } + defaults.push((16, serializer::BYTE, Value::Byte(0))); + } + // Turtle.HAS_EGG and LAYING_EGG (after AgeableMob's two). + "minecraft:turtle" => { + if e.flag { + meta.push((18, serializer::BOOLEAN, Value::Bool(true))); + } + if e.flag2 { + meta.push((19, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((18, serializer::BOOLEAN, Value::Bool(false))); + defaults.push((19, serializer::BOOLEAN, Value::Bool(false))); + } + // WitherBoss.DATA_TARGET_B and DATA_TARGET_C (after DATA_TARGET_A, the + // main target): the entities the side heads look at, by id. + "minecraft:wither" => { + for (k, index) in [(0, 17), (1, 18)] { + let target = match e.ints[k] { + 0 => None, + -1 => player_entity, + id => Some(id), + }; + if let Some(target) = target { + meta.push((index, serializer::INT, Value::Int(target))); + } + defaults.push((index, serializer::INT, Value::Int(0))); + } } _ => {} } @@ -778,6 +864,19 @@ fn mob_meta( } } +/// AbstractVillager.DATA_UNHAPPY_COUNTER (after AgeableMob's two): the head +/// shake of a villager saying no counts it down from 40. +fn unhappy_counter( + m: &Mob, + meta: &mut Vec<(u8, i32, Value)>, + defaults: &mut Vec<(u8, i32, Value)>, +) { + if m.extra.ints[0] > 0 { + meta.push((18, serializer::INT, Value::Int(m.extra.ints[0]))); + } + defaults.push((18, serializer::INT, Value::Int(0))); +} + /// What a client shakes a mob by: Entity.DATA_TICKS_FROZEN (7), whose full /// count is `isFullyFrozen`, and Strider.DATA_SUFFOCATING (19, after /// AgeableMob's two and DATA_BOOST_TIME). diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 78b58a72e..b840402cb 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3935,6 +3935,34 @@ impl Game<'_> { } } let game_time = self.world.game_time; + // `AbstractPiglin.isConverting`: the dimension is not piglin safe. + let nether = self.dim == super::Dim::Nether; + // What a wither's side heads can look at, by network entity id: the + // mobs and the player (position and eye height). + let wither_targets: Vec<(i32, [f64; 3], f64)> = if self + .mobs + .iter() + .any(|m| m.species() == horizon_client::mobs::Species::Wither) + { + let own = self + .remote + .as_ref() + .zip(self.eye_position()) + .map(|(r, eye)| (r.entity_id, eye, eye[1])); + self.mobs + .iter() + .map(|m| { + ( + m.id as i32, + [m.position.x, m.position.y, m.position.z], + m.eye_y(), + ) + }) + .chain(own) + .collect() + } else { + Vec::new() + }; let Some(r) = self.remote.as_mut() else { return; }; @@ -4093,8 +4121,26 @@ impl Game<'_> { } // The animation states a server computes in its own `ai_step`. horizon_client::mobs::sync::client_tick(m, game_time); - if m.species() == horizon_client::mobs::Species::Panda { - horizon_client::mobs::panda::client_tick(m, thundering); + match m.species() { + // WitherBoss.aiStep: the side heads turn toward their targets. + horizon_client::mobs::Species::Wither => { + horizon_client::mobs::wither::client_tick(m, |id| { + wither_targets + .iter() + .find(|t| t.0 == id) + .map(|t| (t.1, t.2)) + }); + } + // Hoglin and piglin `isConverting` outside the Nether. + horizon_client::mobs::Species::Hoglin + | horizon_client::mobs::Species::Piglin + | horizon_client::mobs::Species::PiglinBrute => { + horizon_client::mobs::piglin::client_converting(m, nether); + } + horizon_client::mobs::Species::Panda => { + horizon_client::mobs::panda::client_tick(m, thundering); + } + _ => {} } } for o in self.orbs.iter_mut().filter(|_| running) { diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index 6650e185d..1e3f8887c 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -5,11 +5,13 @@ use super::Game; use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; use horizon_client::mobs::{ - Mob, Species, Who, armadillo, bat, bee, camel, creaking, finalize, panda, sniffer, sync, tame, + Mob, Species, Who, armadillo, bat, bee, camel, creaking, equine, finalize, illusioner, panda, + sniffer, sync, tame, zombie_villager, }; use horizon_client::particles::{ParticleOptions, ParticleType}; use horizon_protocol::entity_data::{Particle, ParticleData, Value}; use horizon_protocol::registry::{Builtin, Dynamic}; +use horizon_world::registry::BlockStateId; /// The values `apply` takes from one SetEntityData packet, by vanilla's entry /// indices (Entity 0..=7, LivingEntity 8..=14, Mob 15, then the subclasses). @@ -31,7 +33,21 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti // Entity.DATA_SHARED_FLAGS_ID's FLAG_ONFIRE: Entity.isOnFire on a // client, which draws the flames. A client doesn't count the // fire down: the flag goes off when the server's fire is out. - (0, Value::Byte(flags)) => m.fire_ticks = i32::from(flags & 1), + (0, Value::Byte(flags)) => { + m.fire_ticks = i32::from(flags & 1); + // Drowned.setSwimming: the shared flag of swimming. + if species == Species::Drowned { + m.extra.flag = flags & 16 != 0; + } + // The shared flag of invisibility: Entity.isInvisible hides + // the model (an illusioner shows its mirror images). + let invisible = flags & 32 != 0; + if species == Species::Illusioner { + illusioner::set_invisible(m, invisible); + } else if &*m.kind.id != "minecraft:player" { + m.invisible = invisible; + } + } // Entity.DATA_POSE: the pose the species animates by. (6, Value::Id(pose)) => sync::set_pose(m, (*pose).clamp(0, 17) as u8), // LivingEntity.DATA_LIVING_ENTITY_FLAGS: using an item 1, in the @@ -218,6 +234,42 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti (Species::CopperGolem, 16, Value::Id(state)) => { m.extra.variant = (*state).clamp(0, 3) as u8; } + // AbstractHorse.DATA_ID_FLAGS: eating 16 and standing 32 (the + // graze and the rear), which `sync::client_tick` animates. + (s, 18, Value::Byte(flags)) if equine::grazes(s) => equine::set_flags(m, *flags as u8), + // Enderman.DATA_CARRY_STATE (0 for none): the block it holds. + (Species::Enderman, 16, Value::Id(state)) => { + m.extra.carried = (*state > 0).then_some(BlockStateId(*state as u32)); + } + // Zombie.DATA_DROWNED_CONVERSION_ID (after DATA_BABY_ID and + // DATA_SPECIAL_TYPE_ID): the conversion's shaking. + (Species::Zombie | Species::Husk, 18, Value::Bool(converting)) => { + m.extra.counter2 = i32::from(*converting); + } + // ZombieVillager.DATA_CONVERTING_ID (before its villager data). + (Species::ZombieVillager, 19, Value::Bool(converting)) => { + zombie_villager::set_converting(m, *converting); + } + // AbstractVillager.DATA_UNHAPPY_COUNTER (after AgeableMob's two): + // the head shake of `no`, which the server counts down. + (Species::Villager | Species::WanderingTrader, 18, Value::Int(ticks)) => { + m.extra.ints[0] = *ticks; + } + // Hoglin.DATA_IMMUNE_TO_ZOMBIFICATION (after AgeableMob's two) and + // AbstractPiglin's: `sync`'s conversion shake reads it. + (Species::Hoglin, 18, Value::Bool(immune)) + | (Species::Piglin | Species::PiglinBrute, 16, Value::Bool(immune)) => { + m.extra.flag2 = *immune; + } + // Blaze.DATA_FLAGS_ID: charged 1, which makes it burn. + (Species::Blaze, 16, Value::Byte(flags)) => m.extra.flag = flags & 1 != 0, + // Turtle.HAS_EGG and LAYING_EGG (after AgeableMob's two). + (Species::Turtle, 18, Value::Bool(has_egg)) => m.extra.flag = *has_egg, + (Species::Turtle, 19, Value::Bool(laying)) => m.extra.flag2 = *laying, + // WitherBoss.DATA_TARGET_B and _C (after DATA_TARGET_A): the + // entities the side heads turn toward in `wither::client_tick`. + (Species::Wither, 17, Value::Int(id)) => m.extra.ints[0] = *id, + (Species::Wither, 18, Value::Int(id)) => m.extra.ints[1] = *id, // Pillager.IS_CHARGING_CROSSBOW: the charge pose (Raider's // IS_CELEBRATING takes 16). (Species::Pillager, 17, Value::Bool(charging)) => m.extra.flag = *charging, @@ -360,9 +412,20 @@ impl Game<'_> { let Some(r) = &self.remote else { return; }; + // LivingEntity.onSyncedDataUpdated(SLEEPING_POS_ID): a villager lies + // in its bed the way the bed faces, or gets up. + let bed = values.iter().find_map(|v| match v { + (14, _, Value::OptPos(bed)) => Some(bed.map_or(0, |b| self.bed_facing(b))), + _ => None, + }); if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id as u32) { apply(m, values, &r.builtin, r.entity_id); apply_registry_data(m, values, &r.registries, self.world.game_time); + if let Some(code) = bed + && m.species() == Species::Villager + { + m.extra.ints[1] = code; + } } } } diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 0575d8d14..eaadf14a4 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -635,6 +635,9 @@ fn axolotl_air_supply(m: &mut Mob, w: &MobWorld) { fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec) { m.was_eye_in_water = m.fluids.eye_in_water; m.update_fluids(w, events); + if m.species() == Species::Drowned { + super::undead::drowned_update_swimming(m, w); + } let fire = crate::motion::environment::fire_contact(w.world, w.registry, m.bounds()); if fire > 0.0 { m.ticks_frozen = 0; diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index 2eccd31f0..872944ac6 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -540,6 +540,26 @@ fn rot_lerp_rad(a: f32, from: f32, to: f32) -> f32 { } from + a * diff } +/// `DrownedModel.setupSwimAnimation`: the arms reach up and sway, the legs +/// kick and the head lies straight. +fn drowned_swim(p: &mut Poses, s: &State, amount: f32) { + if amount <= 0.0 { + return; + } + let sway = amount * 0.35 * (0.1 * s.age).msin(); + let kick = amount * 0.55 * (0.1 * s.age).msin(); + let reach = -PI * 4.0 / 5.0; + let (right_x, left_x) = (p.get("right_arm")[3], p.get("left_arm")[3]); + let (right_z, left_z) = (p.get("right_arm")[5], p.get("left_arm")[5]); + p.xrot("right_arm", rot_lerp_rad(amount, right_x, reach) + sway); + p.xrot("left_arm", rot_lerp_rad(amount, left_x, reach) - sway); + p.zrot("right_arm", rot_lerp_rad(amount, right_z, -0.15)); + p.zrot("left_arm", rot_lerp_rad(amount, left_z, 0.15)); + let (left_leg, right_leg) = (p.get("left_leg")[3], p.get("right_leg")[3]); + p.xrot("left_leg", left_leg - kick); + p.xrot("right_leg", right_leg + kick); + p.xrot("head", 0.0); +} /// `HumanoidModel.setupSwimAnimation`: the stroke of both arms over 26 /// walk-animation units, the head down and a slow flutter kick. The left arm /// eases the short way round, the right one linearly, as in vanilla. @@ -697,6 +717,9 @@ pub fn setup( h.crouching = m.extra.crouching; h.passenger = m.extra.passenger; humanoid(p, s, &h); + if m.kind.anim == Anim::Drowned { + drowned_swim(p, s, m.extra.swim.amount(s.partial)); + } if m.kind.anim == Anim::ZombifiedPiglin { super::piglin::ears(p, s); } diff --git a/crates/horizon-client/src/mobs/equine.rs b/crates/horizon-client/src/mobs/equine.rs index 1155388fd..8b0463849 100644 --- a/crates/horizon-client/src/mobs/equine.rs +++ b/crates/horizon-client/src/mobs/equine.rs @@ -471,6 +471,11 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { if m.extra.counter > 0 { m.extra.counter -= 1; } + animate(m); +} +/// `AbstractHorse.tick`'s eat, stand and mouth animations, which follow the +/// eating and standing flags (`flag` and `counter > 0`). +pub fn animate(m: &mut Mob) { let (eating, standing) = (m.extra.flag, m.extra.counter > 0); let v = &mut m.anim.v; if standing { @@ -488,6 +493,22 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } v[MOUTH] = (v[MOUTH] - v[MOUTH] * 0.7 - 0.05).max(0.0); } +/// `AbstractHorse.tick` on a client that is not the server: the animations +/// follow the flags of the synched data (`set_flags`). +pub fn client_tick(m: &mut Mob) { + m.anim.vo = m.anim.v; + animate(m); +} +/// `AbstractHorse.DATA_ID_FLAGS` on a client: eating 16 and standing 32. +pub fn set_flags(m: &mut Mob, flags: u8) { + m.extra.flag = flags & 16 != 0; + m.extra.counter = i32::from(flags & 32 != 0); +} +/// Whether `ai_step` above runs this species' grazing and rearing, so that +/// the server's flags 16 and 32 mean eating and standing. +pub fn grazes(s: Species) -> bool { + is_equine(s) && !super::camel::is_camel(s) && !super::llama::is_llama(s) +} /// Body texture and the markings overlay. pub fn texture(m: &Mob) -> String { let baby = if m.is_baby() { "_baby" } else { "" }; diff --git a/crates/horizon-client/src/mobs/illusioner.rs b/crates/horizon-client/src/mobs/illusioner.rs index b98e56920..3ef6b0592 100644 --- a/crates/horizon-client/src/mobs/illusioner.rs +++ b/crates/horizon-client/src/mobs/illusioner.rs @@ -146,6 +146,15 @@ impl Goal for Spell { } } +/// `Entity.isInvisible` of an illusioner on a client: the shared flag stands +/// in for the effect the server holds, which draws the mirror images. +pub fn set_invisible(m: &mut Mob, on: bool) { + m.extra.effects.retain(|e| e.0 != INVISIBILITY); + if on { + m.extra.effects.push((INVISIBILITY, i32::MAX, 0)); + } +} + /// The client-side half of `Illusioner.aiStep`: new image offsets when /// hurt and once a minute, with a puff of cloud and a sound. pub fn tick(m: &mut Mob, events: &mut Vec) { diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs index ed219d312..aaaaf4dda 100644 --- a/crates/horizon-client/src/mobs/piglin.rs +++ b/crates/horizon-client/src/mobs/piglin.rs @@ -465,6 +465,13 @@ pub fn celebrate(m: &mut Mob, w: &MobWorld) { t.position.z.floor() as i32, ]); } +/// `Hoglin.isConverting` and `AbstractPiglin.isConverting` on a client: in a +/// dimension that is not piglin safe (`nether` is false), a mob that is not +/// immune (`flag2`) and has AI shakes. `counter2 > 0` draws the shake, as it +/// does on the server while the zombification counts up. +pub fn client_converting(m: &mut Mob, nether: bool) { + m.extra.counter2 = i32::from(!nether && !m.extra.flag2 && !m.no_ai); +} /// Per-tick piglin and hoglin state: admiring, anger, zombification and the /// hoglin attack animation. Returns a conversion when it happens. pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index d02c3a172..aa47b2a96 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -923,6 +923,17 @@ pub fn base_transform_at(m: &Mob, alpha: f32, origin: glam::Mat4) -> glam::Mat4 (sign * horizon_core::jmath::acos(dot.abs().min(1.0))) as f32, ); } + } else if m.species() == Species::Drowned { + // DrownedRenderer.setupRotations: tip toward the look pitch about + // the middle of the box while swimming. + let amount = m.extra.swim.amount(alpha); + if amount > 0.0 { + let pitch = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * alpha; + let middle = glam::Vec3::new(0.0, m.height() / 2.0, 0.0); + base *= glam::Mat4::from_translation(middle) + * glam::Mat4::from_rotation_x((amount * (-10.0 - pitch)).to_radians()) + * glam::Mat4::from_translation(-middle); + } } else if m.extra.swim.amount(alpha) > 0.0 { // AvatarRenderer.setupRotations: tip forward with the swim amount, // following the pitch in water, then lie along the swimming box. diff --git a/crates/horizon-client/src/mobs/sync.rs b/crates/horizon-client/src/mobs/sync.rs index 16cd2b30c..fd45ebbb8 100644 --- a/crates/horizon-client/src/mobs/sync.rs +++ b/crates/horizon-client/src/mobs/sync.rs @@ -16,12 +16,13 @@ //! - run its client side animation in `client_tick`, sharing the function //! with the server's `ai_step` where the server computes the same. use super::{ - Mob, Species, allay, armadillo, axolotl, breeze, camel, copper_golem, creaking, frog, goat, - golem, guardian, piglin, ravager, shulker, sniffer, warden, + Mob, Species, allay, armadillo, axolotl, breeze, camel, copper_golem, creaking, equine, frog, + goat, golem, guardian, piglin, ravager, shulker, sniffer, undead, villager, warden, }; // `Pose.id` of the poses mobs take. pub const STANDING: u8 = 0; +pub const SLEEPING: u8 = 2; pub const LONG_JUMPING: u8 = 6; pub const CROAKING: u8 = 8; pub const USING_TONGUE: u8 = 9; @@ -42,6 +43,8 @@ pub fn pose_id(m: &Mob) -> u8 { Species::Breeze => breeze::pose_id(m), Species::Camel | Species::CamelHusk if camel::sitting(m) => SITTING, Species::Frog => m.extra.pose, + // LivingEntity.startSleeping: the pose, with the bed in index 14. + Species::Villager if villager::sleeping(m) => SLEEPING, _ => STANDING, } } @@ -87,6 +90,8 @@ pub fn client_tick(m: &mut Mob, game_time: i64) { Species::Armadillo => armadillo::tick(m), Species::Frog => frog::tick(m), Species::Goat => goat::tick(m), + s if equine::grazes(s) => equine::client_tick(m), + Species::Drowned => undead::drowned_client_tick(m), _ => {} } } diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs index 0f446c87a..01e104001 100644 --- a/crates/horizon-client/src/mobs/undead.rs +++ b/crates/horizon-client/src/mobs/undead.rs @@ -181,6 +181,17 @@ fn drowned_ok_target(m: &Mob, w: &super::MobWorld) -> bool { pub fn drowned_wants_to_swim(m: &Mob, w: &super::MobWorld) -> bool { m.extra.flag2 || m.target_info(w).is_some_and(|t| in_water_at(w, t.position)) } +/// `Drowned.updateSwimming`: swimming under water while it wants to. `flag` +/// holds `isSwimming`, which clients take from the entity's shared flags. +pub fn drowned_update_swimming(m: &mut Mob, w: &super::MobWorld) { + m.extra.flag = + !m.no_ai && m.was_eye_in_water && m.fluids.in_water && drowned_wants_to_swim(m, w); +} +/// A drowned on a client: `LivingEntity.updateSwimAmount` follows the +/// swimming flag (`Drowned.isVisuallySwimming`). +pub fn drowned_client_tick(m: &mut Mob) { + m.extra.swim.tick(m.extra.flag, m.fluids.in_water); +} /// Drowned.DrownedMoveControl pub fn drowned_move_control(m: &mut Mob, w: &super::MobWorld) { let target = m.target_info(w); diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs index 0a429b135..d7fc5f093 100644 --- a/crates/horizon-client/src/mobs/wither.rs +++ b/crates/horizon-client/src/mobs/wither.rs @@ -170,9 +170,7 @@ fn target_pos(w: &MobWorld, id: i32) -> Option<([f64; 3], f64, bool)> { } } /// `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. +/// (`radius` 0.3 of the wither's scale, which is 1 here). pub fn client_smoke(m: &mut Mob, events: &mut Vec) { for i in 0..3 { let h = head_pos(m, i); @@ -189,13 +187,12 @@ pub fn client_smoke(m: &mut Mob, events: &mut Vec) { }); } } -/// `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) { - // Side heads turn toward their targets, else back to the body. +/// The side heads turn toward their targets, else back to the body. `find` +/// gives the position and eye height of the entity a head's target id names. +fn turn_heads(m: &mut Mob, find: impl Fn(i32) -> Option<([f64; 3], f64)>) { for i in 0..2 { - match target_pos(w, m.extra.ints[i]) { - Some((p, eye, _)) => { + match find(m.extra.ints[i]) { + Some((p, eye)) => { let h = head_pos(m, i + 1); let (xd, yd, zd) = (p[0] - h[0], eye - h[1], p[2] - h[2]); let sd = (xd * xd + zd * zd).sqrt(); @@ -207,6 +204,18 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { None => m.anim.v[i] = rotlerp(m.anim.v[i], m.body_yaw, 10.0), } } +} +/// `WitherBoss.aiStep` on a client that is not the server: the side heads +/// turn toward the targets of the synched data (`DATA_TARGET_B` and `_C`, +/// kept in `ints[0]` and `ints[1]` as network entity ids). +pub fn client_tick(m: &mut Mob, find: impl Fn(i32) -> Option<([f64; 3], f64)>) { + m.anim.vo = m.anim.v; + turn_heads(m, find); +} +/// `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) { + turn_heads(m, |id| target_pos(w, id).map(|(p, eye, _)| (p, eye))); let powered = powered(m); for i in 0..3 { let h = head_pos(m, i); @@ -284,11 +293,20 @@ pub fn custom_server_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec + <= 900.0 + && m.sees( + w, + if id == -1 { + Who::Player + } else { + Who::Mob(id as u32) + }, + ) => { let at = [p[0], p[1] + (eye - p[1]) * 0.5, p[2]]; shoot(m, i + 1, at, false, events); diff --git a/crates/horizon-client/src/mobs/zombie_villager.rs b/crates/horizon-client/src/mobs/zombie_villager.rs index 51fb33c6d..c5fae726a 100644 --- a/crates/horizon-client/src/mobs/zombie_villager.rs +++ b/crates/horizon-client/src/mobs/zombie_villager.rs @@ -24,6 +24,14 @@ pub struct Cure { pub fn cure(m: &Mob) -> Option<&Cure> { villager::ext(m).and_then(|e| e.cure.as_ref()) } +/// `ZombieVillager.DATA_CONVERTING_ID` on a client: only `is_converting` +/// (the cure's shaking) reads the cure, so its time does not matter. +pub fn set_converting(m: &mut Mob, on: bool) { + villager::ext_mut(m).cure = on.then_some(Cure { + time: 0, + starter: None, + }); +} pub fn is_converting(m: &Mob) -> bool { m.species() == Species::ZombieVillager && cure(m).is_some() }