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/crates/horizon-client-core/src/component.rs b/crates/horizon-client-core/src/component.rs index afb68fa98..7437e4ea8 100644 --- a/crates/horizon-client-core/src/component.rs +++ b/crates/horizon-client-core/src/component.rs @@ -190,19 +190,31 @@ fn object_style(o: &serde_json::Map) -> Style { .filter(|p| *p >= 1) .map(crate::text::ClickEvent::ChangePage), 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 3a0bf301b..243a3ae3c 100644 --- a/crates/horizon-client-core/src/text.rs +++ b/crates/horizon-client-core/src/text.rs @@ -47,6 +47,8 @@ pub enum ClickEvent { /// `ClickEvent.ChangePage`: a book's page, counted from 1. ChangePage(i32), 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. @@ -65,6 +67,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, @@ -94,6 +100,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); } @@ -499,7 +511,7 @@ impl Text { } /// The style fields of a component's JSON. -const STYLE_KEYS: [&str; 9] = [ +const STYLE_KEYS: [&str; 10] = [ "color", "bold", "italic", @@ -508,6 +520,7 @@ const STYLE_KEYS: [&str; 9] = [ "obfuscated", "click_event", "hover_event", + "insertion", "font", ]; /// Style.Serializer: the fields a style sets. @@ -541,6 +554,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)); @@ -550,6 +566,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/examples/probe/marker_particles_probe.rs b/crates/horizon-client/examples/probe/marker_particles_probe.rs index 3041a84d7..6025a563c 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(_) -> _)), model_offset: &|_, _, _| None, gateway_particles: &|_, _| 0, diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index a59e3ac05..0e0813f4a 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -570,6 +570,10 @@ fn player_damage(e: &MobEvent) -> f32 { MobEvent::AttackPlayer(amount, _) | MobEvent::AttackPlayerWithEffect { amount, .. } | MobEvent::DamagePlayer { amount, .. } => *amount, + MobEvent::SonicBoom { + target: Who::Player, + .. + } => 10.0, _ => 0.0, } } @@ -583,6 +587,10 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool { MobEvent::AttackPlayer(amount, _) | MobEvent::AttackPlayerWithEffect { 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/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs index 068e7d076..ac23d329e 100644 --- a/crates/horizon-client/src/animate_tick.rs +++ b/crates/horizon-client/src/animate_tick.rs @@ -93,6 +93,14 @@ enum Animate { LightningRod(usize), /// `WetSpongeBlock.animateTick`. WetSponge, + 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 { @@ -225,6 +233,11 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { // BrushableBlock has no dust colour of its own, so the dust is the map colour. "suspicious_sand" => Animate::Falling(0xF7E9A3, false), "suspicious_gravel" => Animate::Falling(0x707070, false), + "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") => { @@ -295,6 +308,10 @@ pub struct AnimateTables { desert_sand_sounds: Vec, /// `#required_for_poplar_leaf_ambience` (overworld natural logs). poplar_leaf_logs: 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`). @@ -391,6 +408,11 @@ impl AnimateTables { dried_ghast_sounds: by_state("minecraft:triggers_ambient_dried_ghast_block_sounds"), desert_sand_sounds: by_state("minecraft:triggers_ambient_desert_sand_block_sounds"), poplar_leaf_logs: by_state("minecraft:required_for_poplar_leaf_ambience"), + 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, }) @@ -416,6 +438,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)>, /// `BlockState.getOffset` of a state at (x, z), for blocks with a random model offset. @@ -474,6 +502,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 offset_of(&self, state: BlockStateId, p: [i32; 3]) -> [f64; 3] { (self.model_offset)(state, p[0], p[2]).unwrap_or([0.0; 3]) } @@ -532,7 +566,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( @@ -688,6 +722,22 @@ fn beehive_drip( ]; add(engine, T::DrippingHoney, p, [0.0; 3]); } +/// `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, @@ -763,6 +813,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) { @@ -1152,6 +1203,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/biome.rs b/crates/horizon-client/src/biome.rs index 46c1e16ca..291b719cc 100644 --- a/crates/horizon-client/src/biome.rs +++ b/crates/horizon-client/src/biome.rs @@ -66,6 +66,13 @@ impl BiomeInfo { } .height_adjusted(pos, sea_level) } + /// `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 { + self.precipitation + .then(|| self.temperature_at(BlockPos::new(x, y, z), 63) < 0.15) + } } pub struct Biomes { pub list: Vec, diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 4bde9aeae..ecad13fb1 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, @@ -1416,6 +1420,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) { @@ -1433,6 +1438,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 @@ -2128,4 +2138,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, registry).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" + ); + } } diff --git a/crates/horizon-client/src/chat.rs b/crates/horizon-client/src/chat.rs index d7def2866..63646bcc7 100644 --- a/crates/horizon-client/src/chat.rs +++ b/crates/horizon-client/src/chat.rs @@ -556,26 +556,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)); @@ -585,6 +593,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/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/effects.rs b/crates/horizon-client/src/effects.rs index 9511fd112..5365a9d5c 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/entities.rs b/crates/horizon-client/src/entities.rs index 3039e1611..2c3488f5d 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, @@ -355,7 +357,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 { @@ -951,6 +956,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, @@ -1047,6 +1053,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.wgsl b/crates/horizon-client/src/entity.wgsl index e90b9dd66..919c5edbb 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -54,6 +54,8 @@ struct Out { // The `GLINT_TEXTURING` sample for overlay 7 (item foil), or the model UV // `ARMOR_ENTITY_GLINT_TEXTURING` scrolls for overlay 13 (armour). @location(11) glint_uv: vec2, + // 1 drops the quad's back-facing pixels (Vertex::normal w = 1), like a culling render type. + @location(12) @interpolate(flat) cull: u32, } // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed. fn entity_light(normal: vec3, nether: bool) -> f32 { @@ -102,7 +104,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); } @@ -234,7 +239,7 @@ fn crumbling_uv(uv: vec2, packed_origin: vec2, sprite_size: vec2, // 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/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 0fee9feca..a2d1bef82 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -515,6 +515,12 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { "Variant".into(), Tag::Int(i32::from(m.extra.variant.min(4))), ); + 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:salmon" => { let size = SALMON_SIZES[usize::from(m.extra.variant).min(2)]; @@ -552,7 +558,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()), + )]), )]), )]), ); @@ -606,6 +615,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)); @@ -712,6 +724,17 @@ 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; + stack.extra = m.extra.body_extra.clone(); + equipment.insert(slot.into(), crate::save::item_to_nbt(&stack)); + continue; + } match item { Some(id) => { let keep = matches!( @@ -1111,6 +1134,11 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.extra.variant = gene("MainGene"); m.extra.variant2 = gene("HiddenGene"); } + 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")); @@ -1118,6 +1146,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"); + let armor = tag + .get("equipment") + .and_then(|e| e.get("body")) + .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); } @@ -1148,11 +1182,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); @@ -1230,6 +1267,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 @@ -1320,6 +1360,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 { @@ -1331,6 +1376,7 @@ pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> 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 8ec3589a2..6b4cd49c2 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 bundles; mod campfire; mod campfire_douse; @@ -149,6 +150,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; @@ -169,9 +171,11 @@ mod server_packs; mod server_travel; mod shader_packs; mod shield; +mod shoulders; mod sign_edit; mod sniffers; mod spawner; +mod spear; mod spill; mod startup_menu; mod station_control; @@ -577,12 +581,19 @@ 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], /// Each minecart's kind and comparator signal, in `cart_boxes` order. cart_signals: Vec<(minecarts::CartKind, i32)>, /// Arrow and thrown trident boxes (wooden buttons). arrow_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, @@ -657,6 +668,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())), + ) + } /// `DetectorRailBlock.getAnalogOutputSignal`: a powered rail reads the /// minecart on it, a command block cart first (its success count, which /// is 0 here), else the first container cart's fullness. @@ -786,6 +844,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, @@ -957,8 +1029,9 @@ 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, detector rails and - /// wooden buttons: the players (the host and the LAN guests, mobs) and - /// the minecarts, and for `EntityQuery::Arrows` the arrows. + /// wooden buttons: the players (the host and the LAN guests), the mobs, + /// the minecarts and the other entities that don't ignore block triggers, + /// and for `EntityQuery::Arrows` the arrows. fn count_entities(&self, area: Aabb, query: EntityQuery) -> usize { let hit = |(lo, hi): &([f64; 3], [f64; 3])| { area.intersects(Aabb::new( @@ -967,6 +1040,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 arrows = || self.arrow_boxes.iter().filter(|b| hit(b)).count(); let players = || { self.player_box @@ -978,8 +1061,8 @@ impl LevelAccess for GameLevel<'_> { match query { EntityQuery::Minecart => carts(), EntityQuery::Arrows => arrows(), - EntityQuery::Mobs => players(), - EntityQuery::Everything => players() + carts(), + EntityQuery::Mobs => players() + mobs(), + EntityQuery::Everything => players() + carts() + mobs() + others(), } } fn emit(&mut self, event: LevelEvent) { @@ -1460,6 +1543,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, @@ -1549,6 +1635,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, /// The world is superflat (`ServerLevel.isFlat`, for every dimension). @@ -1754,6 +1842,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)>, lan_cushion_breaks: Vec<(horizon_world::registry::BlockStateId, [f64; 3])>, /// Block events (position, b0, b1, state) and entity events (id, event, /// position) for the guests. @@ -1761,6 +1852,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) @@ -1804,6 +1907,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, @@ -2145,6 +2250,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; }; @@ -2157,6 +2263,7 @@ impl Game<'_> { let _ = player.set_sleeping(sleeping); 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 { @@ -2400,6 +2507,7 @@ impl Game<'_> { health: 5, fire_ticks: 0, thrower: None, + target: None, id: self.next_entity, stack, position: p, @@ -2623,6 +2731,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(); @@ -2632,7 +2741,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()) { @@ -2766,9 +2876,13 @@ impl Game<'_> { }; let mut level = GameLevel { cart_boxes, + item_frames: &self.item_frames, cart_signals, arrow_boxes, blockers, + dropped: &self.dropped, + orbs: &self.orbs, + projectiles: &self.creatures.projectiles, world: &mut self.world, facts: self.res.facts(), collision: self.collision, @@ -2912,7 +3026,8 @@ impl Game<'_> { .collect(); // Entity.checkInsideBlocks for the plates, tripwires, detector rails and // buttons under the players (the host and the LAN guests), the minecarts - // and the arrows. + // and the arrows (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 @@ -2991,7 +3106,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 { @@ -3108,6 +3237,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), // LevelEventHandler 2019 and 2020: the crack on a face of the // block being mined, with its hit sound for 2020. LevelEvent::LevelEvent { @@ -3118,6 +3253,11 @@ impl Game<'_> { let face = horizon_core::geometry::Direction::ALL[data.clamp(0, 5) as usize]; self.breaking_block_effects([pos.x, pos.y, pos.z], face.normal(), id == 2020); } + 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]) } @@ -3379,6 +3519,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", .. } => { @@ -4159,11 +4304,19 @@ 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) || 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) @@ -4449,6 +4602,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 { @@ -4460,6 +4619,10 @@ impl Game<'_> { } return; } + if &*stack.item == "minecraft:brush" { + self.tick_brush(slot, ticks); + return; + } if info.bundle { self.tick_bundle(slot, ticks); return; @@ -4766,11 +4929,22 @@ 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; 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 + .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; @@ -4794,6 +4968,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; @@ -5133,7 +5308,13 @@ impl Game<'_> { } self.powder_snow_fire()?; self.rain_extinguish_in_frame(); + // 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(); + self.handle_shoulder_entities(); let Some(player) = self.player.as_mut() else { return Ok(()); }; @@ -5147,6 +5328,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); @@ -5256,6 +5440,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())?; @@ -5863,6 +6048,19 @@ impl Game<'_> { .health_hud .left_height .max(self.health_hud.right_height); + // 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); @@ -8186,8 +8384,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. @@ -8224,18 +8421,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. @@ -8251,7 +8439,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)); @@ -8286,6 +8488,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 @@ -10323,7 +10529,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()); @@ -10445,19 +10661,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) } /// `Level.isRainingAt`: it rains, the sky light is 15, nothing that stops /// motion is above, and the biome's precipitation there is rain. @@ -10759,6 +10969,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) { @@ -12077,8 +12289,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))); @@ -12771,6 +12989,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.link_prompt.is_some() => { if event.state == ElementState::Pressed @@ -13432,6 +13664,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(), @@ -13485,6 +13718,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(), world_flat: false, @@ -13612,10 +13846,15 @@ impl<'a> Game<'a> { forced_hit: None, guest_use: None, lan_events: Vec::new(), + lan_songs: Vec::new(), lan_cushion_breaks: Vec::new(), 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, @@ -13639,6 +13878,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(), @@ -14299,10 +14539,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) } @@ -14359,10 +14599,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/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index b3a8977a1..79e836322 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -876,6 +876,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)) + }); + } /// `EnchantedItemTrigger`: the enchanted item and the levels it cost. pub(super) fn trigger_enchanted_item(&mut self, stack: &ItemStack, levels: i32) { let me = self.player_entity(); diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs index ce9410ba5..27f40f980 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, @@ -167,11 +198,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(); @@ -186,6 +220,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/beacon.rs b/crates/horizon-client/src/game/beacon.rs index 97177f2b9..6de017c33 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, 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/chat.rs b/crates/horizon-client/src/game/chat.rs index 9fbc5cd88..49ad2be44 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -104,6 +104,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, } @@ -750,12 +753,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); @@ -769,6 +785,7 @@ impl Game<'_> { screen.suggest_command(&m, &c, &command); } } + Some(ClickEvent::RunCommand(command)) => self.click_command(&command), // Screen.defaultHandleClickEvent: a page link means nothing in chat. Some(ClickEvent::ChangePage(_)) | None => {} } @@ -837,6 +854,22 @@ impl Game<'_> { self.answer_link_prompt(yes); } } + /// `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; @@ -891,17 +924,39 @@ impl Game<'_> { ); horizon_client::screen_draw::paint(batch, &self.gui.atlas, &button); } - // 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) { @@ -1046,6 +1101,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; } @@ -1154,26 +1210,3 @@ pub fn screenshot_name(dir: &std::path::Path) -> String { 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/commands.rs b/crates/horizon-client/src/game/commands.rs index f0bbdb13e..ea628917e 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1162,6 +1162,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 { @@ -1178,8 +1189,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, false); + 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; @@ -1447,7 +1469,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, }; @@ -1462,21 +1484,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. @@ -1486,6 +1518,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; } diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs index 39587fa00..952e7d806 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, @@ -118,7 +119,8 @@ impl Game<'_> { "dry_out" => DamageKind::DryOut, "magic" | "indirect_magic" | "dragon_breath" => DamageKind::Magic, "sting" => DamageKind::Sting, - "cactus" | "sweet_berry_bush" => DamageKind::Cactus, + "cactus" => DamageKind::Cactus, + "sweet_berry_bush" => DamageKind::SweetBerryBush, "freeze" => DamageKind::Freeze, "in_wall" => DamageKind::InWall, "thorns" => DamageKind::Thorns, @@ -1219,7 +1221,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 6384a3051..a9bf19c07 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -21,7 +21,7 @@ use horizon_client::{ text::Text, }; use horizon_core::{ - geometry::{Aabb, Vec3, traverse_blocks}, + geometry::{Aabb, Direction, Vec3, traverse_blocks}, position::BlockPos, random::RandomSource, }; @@ -49,6 +49,9 @@ pub(super) struct Creatures { /// Mace smash knockback on the other players from a guest's turn, waiting /// for it to end (game/mace.rs). pub smash_pushes: Vec, + /// Sweep attacks from a guest's turn, waiting for it to end + /// (game/lan_pvp.rs). + pub sweeps: Vec, /// Explosion packets from a guest's turn, waiting for it to end /// (centre, small, radius, blocks hit; game/lan_particles.rs). pub lan_explosions: Vec<([f64; 3], bool, f32, usize)>, @@ -56,6 +59,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>, /// The cat spawner's countdown (`CatSpawner.nextTick`). pub cat_tick: i32, /// Particles from a guest's turn, waiting for it to end @@ -451,9 +456,10 @@ impl Game<'_> { teams: std::sync::Arc::new(self.mob_teams()), items: Some(self.res.items()), lid_openers: &self.lid_openers, + // 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]), ), } @@ -508,6 +514,7 @@ impl Game<'_> { self.tick_wandering_trader(); self.tick_patrol_spawner(); self.tick_cat_spawner(); + self.tick_village_siege(); } self.tick_raids(); self.tick_creature_entities() @@ -938,6 +945,55 @@ 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; + let mut infested = 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) { + match event { + MobEvent::Sound(s, _, volume, pitch) => { + self.audio + .play(&format!("minecraft:{s}"), Some(center), volume, pitch); + } + MobEvent::Infested { .. } => infested = true, + other => { + // Left for the end of the tick. + t.outbox.push(other); + } + } + } + } + } + if infested { + self.mob_infested(target); + } + 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 + } /// `InfestedMobEffect.onMobHurt` for a mob: silverfish from half its height up. pub(super) fn mob_infested(&mut self, mob: u32) { if let Some(m) = self.mobs.iter().find(|m| m.id == mob) { @@ -1017,6 +1073,20 @@ impl Game<'_> { 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 @@ -1155,54 +1225,48 @@ impl Game<'_> { amount, source, } => { - let mut killed = false; - let mut hurt = false; - let mut infested = 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) { - match event { - MobEvent::Sound(s, _, volume, pitch) => { - self.audio.play( - &format!("minecraft:{s}"), - Some(center), - volume, - pitch, - ); - } - MobEvent::Infested { .. } => infested = true, - other => { - // Left for the end of the tick. - t.outbox.push(other); - } - } - } + 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 infested { - self.mob_infested(target); - } - 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| self.mob_knockback_resistance(m)); + (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), @@ -1232,6 +1296,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::Infested { mob } => self.mob_infested(mob), MobEvent::Gift { target, item } => { if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target) @@ -1250,6 +1315,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; @@ -1345,8 +1418,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); @@ -2379,6 +2494,22 @@ impl Game<'_> { 8.0, ) } + /// `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}; @@ -2521,6 +2652,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, @@ -3009,7 +3147,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); // Shulker.hurtServer: a shulker hit by a bullet. horizon_client::mobs::shulker::hit_by_bullet(m); } @@ -3173,6 +3311,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(); @@ -3208,13 +3350,25 @@ 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 acting = self.acting_player_uuid(); + 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); } 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; @@ -3299,6 +3453,23 @@ 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 == Some(acting) + && 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; + stack.extra = m.extra.body_extra.take(); + 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 => { @@ -3313,6 +3484,36 @@ 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 == Some(acting) + && m.extra.head.is_none() + && !m.is_baby() => + { + 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)); + } + // 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 == Some(acting) + && 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 && m.extra.owner == Some(acting) @@ -3432,6 +3633,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; @@ -3489,7 +3699,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 = Some(acting); } // TamableAnimal.spawnTamingParticles (entity event 7 or 6). self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); @@ -3609,6 +3819,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 = [ @@ -3631,6 +3844,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 + } /// `Armadillo.mobInteract`: a brush brushes a scute off an adult /// (`brushOffScute`) and loses 16 durability. fn interact_armadillo(&mut self, index: usize, item: &str) -> bool { @@ -3979,6 +4225,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); if let Some(rgb) = outline { self.mark_outline(&out[entity_start..], rgb); @@ -4213,6 +4471,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", @@ -4229,6 +4488,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", @@ -4289,13 +4549,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/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs index 1e69f2c05..07f3d6c21 100644 --- a/crates/horizon-client/src/game/dedicated.rs +++ b/crates/horizon-client/src/game/dedicated.rs @@ -673,6 +673,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/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/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 192b72552..aaf1dba39 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -1122,14 +1122,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() @@ -3029,14 +3026,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/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs index 5688a3226..6986c5627 100644 --- a/crates/horizon-client/src/game/enchant_effects.rs +++ b/crates/horizon-client/src/game/enchant_effects.rs @@ -3,14 +3,18 @@ //! 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, ...) and Soul -//! Speed's `location_changed` and `tick` effects. +//! the armor attribute effects (respiration, depth strider, ...), Soul +//! Speed's `location_changed` and `tick` effects and the +//! `minecraft:location_changed` disk effect (frost walker). use super::Game; use horizon_client::{ enchant::{EffectContext, Enchantments, 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)] @@ -69,7 +73,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 +106,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 +148,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 }; @@ -636,6 +640,173 @@ impl Game<'_> { self.apply_equipment(); } } + /// `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. @@ -684,3 +855,35 @@ fn soul_speed_modifiers( }) .collect() } + +/// 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/end.rs b/crates/horizon-client/src/game/end.rs index 41c4e1628..3c5cce750 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -12,6 +12,7 @@ use horizon_client::{ motion::PlayerMotion, particles::{ParticleOptions, ParticleType}, vanillagen::VanillaTerrain, + world_spawn::PlayerSpawnFinder, }; use horizon_core::{ geometry::Vec3, @@ -581,7 +582,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; @@ -606,7 +615,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]]; @@ -626,22 +641,32 @@ 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); } - let y = self - .land_column(target.x.floor() as i32, target.z.floor() as i32) - .map_or(target.y, f64::from); - Ok((Vec3::new(target.x, y, target.z), None)) + 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(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(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/frames.rs b/crates/horizon-client/src/game/frames.rs index f4721ae26..4b7465bd0 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-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs index 8b835725f..e7bb1982f 100644 --- a/crates/horizon-client/src/game/hand.rs +++ b/crates/horizon-client/src/game/hand.rs @@ -352,12 +352,21 @@ impl Game<'_> { _ => name.ends_with("shulker_box"), } } - /// `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> { diff --git a/crates/horizon-client/src/game/initial_spawn.rs b/crates/horizon-client/src/game/initial_spawn.rs index c1149b26a..ca727c5d0 100644 --- a/crates/horizon-client/src/game/initial_spawn.rs +++ b/crates/horizon-client/src/game/initial_spawn.rs @@ -212,39 +212,58 @@ impl Game<'_> { ) .is_ok_and(|shape| shape.is_empty()) } - /// 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) + } + } } /// A new PlayerSpawnFinder around `suggestion`: the respawn radius, cut /// by the world border; the suggestion itself in adventure mode. diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index efb83e5db..99d67493b 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -171,6 +171,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) @@ -180,8 +183,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, } } @@ -249,6 +253,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/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs index 87f91895e..1af4a7d17 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<'_> { @@ -97,7 +102,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; }; @@ -109,12 +114,38 @@ impl Game<'_> { self.titles .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. + 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]) { let key = (pos[0], pos[1], pos[2]); diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 38cb16fa1..ac5f8a13a 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -457,6 +457,13 @@ fn mob_meta( } defaults.push((19, 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 }; @@ -527,6 +534,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}; @@ -724,7 +739,7 @@ fn mob_meta( defaults.push((index, serializer::BOOLEAN, Value::Bool(true))); } } - // 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(( @@ -733,6 +748,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))); } _ => {} } @@ -794,8 +813,17 @@ fn mob_equipment( let stack = ItemStack { item: item.clone(), count: 1, - damage: 0, - extra: None, + // A wolf's armor shows its cracks. + damage: if slot == 6 && m.species() == horizon_client::mobs::Species::Wolf { + e.body_damage.max(0) as u32 + } else { + 0 + }, + extra: if slot == 6 && m.species() == horizon_client::mobs::Species::Wolf { + e.body_extra.clone() + } else { + None + }, }; out.push((slot, hub.stack(&Some(stack)))); } @@ -1078,6 +1106,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.lan_cushion_breaks.clear(); self.streaming.extra.clear(); @@ -1300,6 +1329,9 @@ impl Game<'_> { &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_freeze_meta(m, &mut e.meta, &mut e.defaults); mob_equipment(m, hub, &mut e.equipment); self.mob_attributes(m, &mut e.attributes); @@ -1569,6 +1601,8 @@ impl Game<'_> { // A blast from a guest's attack, and a mace's wind burst. self.flush_lan_explosions(); let _ = self.flush_wind_bursts(); + // A sweep attack's reach to the other players from a guest's attack. + self.flush_sweeps(); // Particles a guest's turn sent (sweep attack, damage indicator, a hook's splashes). self.flush_lan_particles(); } @@ -1671,10 +1705,11 @@ 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 - // (these levelEvent calls name no excluded player), nor - // the digger's own crack and hit sound (2019, 2020). - let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 2019 | 2020) { + // particles, bone meal's growth, anvil result sounds, or a + // finished brushing (these levelEvent calls name no + // excluded player), nor the digger's own crack and hit + // sound (2019, 2020). + let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 2019 | 2020 | 3008) { None } else { self.lan_acting @@ -1736,6 +1771,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 (state, at) in std::mem::take(&mut self.lan_cushion_breaks) { if let Some(id) = host .hub @@ -1770,6 +1806,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); } @@ -1814,7 +1860,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); @@ -1835,6 +1886,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) @@ -1899,10 +1963,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 { @@ -1926,6 +1998,27 @@ impl Game<'_> { m.extra.crouching = g.sneaking; m.extra.avatar_pose = g.pose(); 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() @@ -2000,6 +2093,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); // LivingEntity.isCurrentlyGlowing: the guest's Glowing effect. let guest = host.hub.guest(*conn); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index a6a683827..c18abba36 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -388,6 +388,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); @@ -643,6 +644,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; @@ -971,6 +973,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 { @@ -995,6 +1036,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)); @@ -1122,19 +1169,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, @@ -1663,9 +1716,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); @@ -1968,6 +2033,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 @@ -1986,6 +2055,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) { @@ -2031,7 +2104,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 { @@ -2130,7 +2209,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, @@ -2211,11 +2290,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; @@ -2239,11 +2317,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() { @@ -2299,16 +2430,19 @@ 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()); 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); 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); }; @@ -2323,6 +2457,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. @@ -2374,6 +2514,7 @@ impl Game<'_> { w.player.shift_key_down = sneaking; let _ = w.player.set_sleeping(sleeping); w.player.freeze_immune = freeze_immune; + w.player.burn_from_stepping_immune = burn_immune; let _ = w.server_block_damage(start); let _ = w.update_soul_speed_block(); let _ = w.tick_environment_damage(); @@ -2402,12 +2543,16 @@ 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(); // Soul Speed's effects (LivingEntity.baseTick's location_changed // and tick effects); its particle goes to the players around. soul = game.tick_soul_speed(); + game.handle_shoulder_entities(); let Some(player) = game.player.as_mut() else { return (Vec::new(), None); }; @@ -2446,7 +2591,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), @@ -2750,9 +2898,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; @@ -2763,6 +2917,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/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/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index d5317f88a..a3de0b9ad 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -425,6 +425,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 { diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index 42253afa8..8dd77dde7 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -83,6 +83,10 @@ pub(super) fn acts_on_player(e: &MobEvent) -> bool { MobEvent::AttackPlayer(..) | MobEvent::AttackPlayerWithEffect { .. } | MobEvent::DamagePlayer { .. } + | MobEvent::SonicBoom { + target: Who::Player, + .. + } | MobEvent::Push { target: Who::Player, .. @@ -101,6 +105,7 @@ pub(super) fn acts_on_player(e: &MobEvent) -> bool { } | MobEvent::EffectPlayer { .. } | MobEvent::AxolotlSupportPlayer + | MobEvent::ParrotToShoulder { .. } ) } diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs index d8c14e0b5..fe1011804 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/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index 27c7ada1f..ebf7b1ce3 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), @@ -49,6 +50,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 { @@ -127,6 +148,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; @@ -151,6 +176,7 @@ impl Game<'_> { knockback: (strength, xd, zd), knockback_attack, team: self.player_team().cloned(), + sweep_hit, }) } @@ -344,9 +370,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); + } + } + } + } } diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 921244e6d..6caf4458a 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/mace.rs b/crates/horizon-client/src/game/mace.rs index 80f09a331..76b7f4d1c 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}, }; @@ -135,7 +136,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), @@ -144,6 +145,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()), @@ -173,7 +175,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 @@ -193,16 +195,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; } } } @@ -216,6 +228,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, diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index 0abf36a73..f9a208a7f 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -1189,6 +1189,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/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/nether_portal.rs b/crates/horizon-client/src/game/nether_portal.rs index 95c38d9d1..d8c76231d 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; 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/perspective.rs b/crates/horizon-client/src/game/perspective.rs index 2c4cd1571..ceb4507de 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -381,7 +381,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; @@ -463,7 +471,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); // LivingEntity.isCurrentlyGlowing: the Glowing effect. A server's client is @@ -528,7 +543,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); @@ -567,17 +589,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; @@ -617,7 +640,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/potions.rs b/crates/horizon-client/src/game/potions.rs index b8971046d..affd68782 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -119,6 +119,22 @@ fn mob_can_be_affected( || (effect != "regeneration" && effect != "poison") } } +/// `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<'_> { /// `LivingEntity.triggerOnDeathMobEffects` (`onMobRemoved` with the reason /// KILLED) for what Oozing, Weaving and Wind Charged do when their bearer @@ -804,15 +820,15 @@ impl Game<'_> { } } if let Some((p, mob)) = hit { - landed.push((t.stack.clone(), p, mob, t.owner.clone())); + landed.push((t.stack.clone(), p, mob, t.age, t.owner.clone())); return false; } t.position = next; t.age < 1200 && t.position.y > -128.0 }); self.potions.thrown = thrown; - for (stack, at, mob, owner) in landed { - self.splash(&stack, at, mob, owner); + for (stack, at, mob, age, owner) in landed { + self.splash(&stack, at, mob, age, owner); } } /// `AreaEffectCloud.tick` for the lingering potions' clouds: the client @@ -1079,17 +1095,20 @@ impl Game<'_> { &mut self, effects: &'static [(&'static str, i32, i32)], at: Vec3, + age: u32, source: &Text, ) { 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); @@ -1110,8 +1129,15 @@ impl Game<'_> { } } /// `ThrownSplashPotion.onHitAsPotion`, or `ThrownLingeringPotion.onHitAsPotion` - /// for a lingering potion; `mob` is where it hit a mob. - fn splash(&mut self, stack: &ItemStack, at: Vec3, mob: Option, owner: Option) { + /// for a lingering potion; `mob` is where it hit a mob, `age` its age. + fn splash( + &mut self, + stack: &ItemStack, + at: Vec3, + mob: Option, + age: u32, + owner: Option, + ) { let block = [at.x, at.y, at.z].map(|v| v.floor() as i32); if &*stack.item == "minecraft:experience_bottle" { // ThrownExperienceBottle.onHit: the water-coloured splash (level @@ -1169,15 +1195,14 @@ impl Game<'_> { // message names by the owner, else by the potion. let source = owner.unwrap_or_else(|| Text::translate("entity.minecraft.splash_potion", &[])); - self.for_each_player(|g| g.splash_on_player(def.effects, at, &source)); + self.for_each_player(|g| g.splash_on_player(def.effects, at, age, &source)); // 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)); @@ -1204,12 +1229,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); } } diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs index f7525c953..d5f47cc1f 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). @@ -102,11 +114,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 +187,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 +647,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); @@ -791,7 +805,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; @@ -836,11 +850,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)); @@ -1218,6 +1230,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 diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 4d5dca944..3191097e5 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -160,6 +160,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, @@ -206,7 +209,7 @@ pub(super) struct Remote { placing: Option<([i32; 3], u64)>, /// `CommonPlayerSpawnInfo.isFlat`: the level is a superflat one. pub(super) flat: bool, - death_message: Option, + death_message: Option, /// `LocalPlayer.showDeathScreen`: off with `immediate_respawn`. show_death_screen: bool, player_type: Option>, @@ -478,6 +481,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, @@ -696,10 +700,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, @@ -1031,6 +1039,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), @@ -1444,6 +1458,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; + } // So does a firework rocket: its own tick flies it on. if path.is_some() && let Some(f) = self.rockets.iter_mut().find(|f| f.id == id as u32) @@ -2161,7 +2186,23 @@ impl Game<'_> { ) }) .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; + } // The body slot (6: horse armour, llama carpet, harness) // is kept in `head`, as Horizon's own mobs do. let body = horizon_client::mobs::drops::head_is_body(m.species()); @@ -2174,7 +2215,11 @@ impl Game<'_> { 3 => e.legs = item, 4 => e.chest = item, 5 if !body => e.head = item, - 6 if body => e.head = item, + 6 if body => { + // A wolf's armor shows its cracks. + e.body_damage = stack.as_ref().map_or(0, |s| s.damage as i32); + e.head = item; + } 7 => m.set_saddle(stack), _ => {} } @@ -2261,6 +2306,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) @@ -2268,6 +2317,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 @@ -2412,6 +2465,7 @@ impl Game<'_> { { self.screen = Screen::Dead; self.ui.death_time = 0; + self.ui.death_confirm = None; self.capture(false); } } @@ -2419,7 +2473,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); @@ -2431,6 +2485,7 @@ impl Game<'_> { if self.remote.as_ref().is_none_or(|r| r.show_death_screen) { self.screen = Screen::Dead; self.ui.death_time = 0; + self.ui.death_confirm = None; self.capture(false); } else { self.respawn_player()?; @@ -3258,6 +3313,7 @@ impl Game<'_> { health: 5, fire_ticks: 0, thrower: None, + target: None, id: id as u32, stack, position: at, @@ -3294,6 +3350,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(r) = self.rockets.iter_mut().find(|r| r.id == id as u32) { r.velocity = v; } else if let Some(p) = self @@ -3318,6 +3376,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; @@ -3377,6 +3466,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. @@ -3844,15 +3936,12 @@ impl Game<'_> { let head_lerps = &mut r.head_lerps; let players = &r.level_players; let mut using = Vec::new(); - let mut wither_heads = 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 { continue; } - if m.species() == horizon_client::mobs::Species::Wither { - wither_heads.extend((0..3).map(|i| horizon_client::mobs::wither::head_pos(m, i))); - } m.previous = m.position; m.previous_yaw = m.yaw; m.previous_body_yaw = m.body_yaw; @@ -3887,6 +3976,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_smoke(m, &mut mob_fx), + _ => {} + } + } if m.hurt_time > 0 { m.hurt_time -= 1; } @@ -3947,6 +4047,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(); } @@ -3992,19 +4094,7 @@ impl Game<'_> { d.tick(world, facts, collision, false, &self.res.motion().fluids); } head_lerps.retain(|_, (_, steps)| *steps > 0); - // WitherBoss.aiStep runs on a client too: smoke around each head. - let smoke = horizon_client::particles::ParticleOptions::simple( - horizon_client::particles::ParticleType::Smoke, - ); - for h in wither_heads { - let r = self.particles.random(); - let at = [ - h[0] + r.next_gaussian() * 0.3, - h[1] + r.next_gaussian() * 0.3, - h[2] + r.next_gaussian() * 0.3, - ]; - self.particles.add(&smoke, at, [0.0; 3]); - } + 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); } @@ -4451,6 +4541,15 @@ impl Game<'_> { if reacts { self.predict_use(&changes, seq); self.open_command_block_if_editable((hit.pos[0], hit.pos[1], hit.pos[2])); + } 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) { @@ -4749,6 +4848,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()); @@ -4765,7 +4866,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: @@ -4809,6 +4911,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; + } // BundleItem.getUseDuration: 200 ticks, the server drops the contents. if stack .as_ref() @@ -4958,7 +5084,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() => { @@ -5653,8 +5781,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, + ); } } /// Shared flag 6 of an entity on a server's client (`None` without a server). @@ -5949,7 +6085,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() @@ -6019,7 +6156,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/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index 55ba7f997..a4080ac16 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -17,6 +17,9 @@ use horizon_protocol::registry::{Builtin, Dynamic}; 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_POSE: a player's or mannequin's box follows it. @@ -117,6 +120,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, // Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace. (Species::Warden, 16, Value::Int(anger)) => { if let Some(st) = m.extra.warden.as_mut() { @@ -212,6 +218,10 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti // 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; @@ -280,6 +290,21 @@ fn apply_registry_data( } } +/// 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/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/game/remote_mob_use.rs b/crates/horizon-client/src/game/remote_mob_use.rs index bd38c7301..728d22094 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/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 00d4abaed..409c28c88 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -207,6 +207,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" => { @@ -350,6 +352,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. @@ -383,6 +394,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) { self.tick_remote_fangs(); @@ -416,6 +446,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 { @@ -434,8 +465,12 @@ impl Game<'_> { _ => remote_projectile_tick(p, &world), } } + for t in &mut tridents { + t.remote_tick(&world, self.remote_eye(t.owner)); + } } self.creatures.projectiles = projectiles; + self.tridents = tridents; let trails: Vec = self .creatures .projectiles @@ -444,10 +479,6 @@ impl Game<'_> { .map(|p| p.position) .collect(); self.smoke_trails(trails); - for t in &mut self.tridents { - let id = t.id; - t.remote_step(|at| step(id, at)); - } // FireworkRocketEntity.tick: a rocket attached to an entity follows it // and boosts it client-side too (attachedToEntity.isFallFlying), and // every rocket leaves its spark trail on a client. diff --git a/crates/horizon-client/src/game/remote_vehicles.rs b/crates/horizon-client/src/game/remote_vehicles.rs index 877ed66e6..c9cbf1159 100644 --- a/crates/horizon-client/src/game/remote_vehicles.rs +++ b/crates/horizon-client/src/game/remote_vehicles.rs @@ -128,6 +128,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); + } + } } } diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index 27081b43b..26a5a81cd 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -19,10 +19,29 @@ 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") { + // #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; @@ -34,16 +53,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<'_> { @@ -293,6 +303,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 tables = &self.pack.context.tables; let model_offset = |state, x, z| tables.offset(state, x, z); let gateway_particles = |state, p| { @@ -310,6 +325,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(_) -> _)), model_offset: &model_offset, gateway_particles: &gateway_particles, diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index 4b5c4c333..200a0e6fe 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, @@ -103,6 +104,14 @@ fn pause_icons(w: f32, h: f32, links: bool) -> [(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" @@ -267,6 +276,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 { @@ -382,6 +405,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() @@ -391,6 +431,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<()> { match hit { Some(0) => self.respawn_player()?, Some(1) => self.close_world()?, diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs index 65dfede1a..abcecf841 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/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs index bcaf37a76..e516d3f67 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}; @@ -31,6 +31,11 @@ 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, + /// 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, } @@ -66,10 +71,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 +259,8 @@ impl Game<'_> { plan, gateway: None, respawn: None, + world_spawn: false, + finder: None, placed: false, }); if let Err(e) = self.enter_level(Some(host), source) { @@ -272,6 +280,8 @@ impl Game<'_> { plan: None, gateway: None, respawn: Some(config), + world_spawn: false, + finder: None, placed: false, }); } @@ -304,6 +314,28 @@ 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, + finder: None, + placed: false, + }); + } + /// TeleportTransition.missingRespawnBlock: the world spawn, in the /// Overworld. fn respawn_at_world_spawn(&mut self, host: &mut LanHost, conn: u32) { @@ -318,6 +350,7 @@ impl Game<'_> { rotation: None, }); self.run_level_teleports(host); + self.world_spawn_trip(conn); } /// `TheEndGatewayBlockEntity.getPortalPosition` and the teleport within @@ -343,6 +376,8 @@ impl Game<'_> { plan: None, gateway: Some(job), respawn: None, + world_spawn: false, + finder: None, placed: false, }); } @@ -369,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; } @@ -383,6 +418,22 @@ 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); + 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); + 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), @@ -392,12 +443,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) @@ -458,6 +516,8 @@ impl Game<'_> { plan: None, gateway: None, respawn: None, + world_spawn: false, + finder: None, placed: true, }); if let Err(e) = self.enter_level(Some(host), source) { diff --git a/crates/horizon-client/src/game/shoulders.rs b/crates/horizon-client/src/game/shoulders.rs new file mode 100644 index 000000000..7dfc2f355 --- /dev/null +++ b/crates/horizon-client/src/game/shoulders.rs @@ -0,0 +1,124 @@ +//! 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; + }; + // 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 + || 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/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); diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs index a3761cf7a..40085b7fa 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/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/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/game/trident.rs b/crates/horizon-client/src/game/trident.rs index 22333db62..b333156e1 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -10,6 +10,7 @@ use horizon_client::{ items::ItemStack, mesher::Vertex, mobs::{Damage, DamageKind, Who, anim::Poses}, + projectiles::ProjectileWorld, }; use horizon_core::{ geometry::{Aabb, Vec3, traverse_blocks}, @@ -33,6 +34,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, /// The guest that threw it (`Projectile.getOwner`); `None` for the host. guest: Option, } @@ -54,13 +57,72 @@ impl ThrownTrident { no_physics: false, returning: 0, creative_only: false, + owner: 0, guest: None, } } - /// 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; @@ -244,7 +306,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); @@ -277,8 +344,14 @@ impl Game<'_> { p.position.y += moved.y; } } - 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. @@ -322,6 +395,7 @@ impl Game<'_> { no_physics: false, returning: 0, creative_only: self.creative, + owner: 0, guest: self.lan_acting, }); self.player_projectile_shot(); @@ -365,19 +439,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", diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs index 5f01633b0..aa56409b1 100644 --- a/crates/horizon-client/src/game/wither.rs +++ b/crates/horizon-client/src/game/wither.rs @@ -71,7 +71,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/gfx.rs b/crates/horizon-client/src/gfx.rs index 801dedde9..ad1fd0561 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -3587,7 +3587,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 2b9bae9b5..fda0094d8 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, @@ -64,7 +65,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, /// `misc/enchanted_glint_item` as its own image: vanilla's `GlintSampler` @@ -147,6 +151,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 { @@ -378,7 +397,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) @@ -386,12 +405,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 }; @@ -399,16 +441,19 @@ 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 flags = fs::read_to_string(path.with_extension("png.mcmeta")) - .ok() - .and_then(|json| TextureFlags::from_mcmeta(&json)); + let flags = mcmeta.as_deref().and_then(TextureFlags::from_mcmeta); + 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), flags, gui_size, + animated, )) }; let threads = std::thread::available_parallelism().map_or(2, |n| n.get()); @@ -427,14 +472,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 { @@ -500,35 +549,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 glint = Self::glint_texture(root, defaults, "enchanted_glint_item"); @@ -548,7 +594,7 @@ impl HudAtlas { sprites, translucent, flags, - fire_animations, + sprite_animations, glint, glint_armor, font, @@ -1082,7 +1128,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, @@ -1311,7 +1357,7 @@ impl HudRenderer { }); Ok(Self { atlas_texture: None, - fire_animations: Vec::new(), + sprite_animations: Vec::new(), pipeline, invert_pipeline, additive_pipeline, @@ -1324,7 +1370,7 @@ impl HudRenderer { capacity, }) } - pub fn animate_fire( + pub fn animate_sprites( &mut self, uploads: &mut crate::gfx::upload::Uploads, encoder: &mut wgpu::CommandEncoder, @@ -1333,13 +1379,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 { @@ -1356,7 +1420,7 @@ impl HudRenderer { h, &pixels, ); - *previous = frame; + *previous = state; } } /// Stage the batch's atlas patches, vertices and uniform: before the @@ -1522,6 +1586,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) diff --git a/crates/horizon-client/src/hud_layout.rs b/crates/horizon-client/src/hud_layout.rs index 42347d877..efdb2747b 100644 --- a/crates/horizon-client/src/hud_layout.rs +++ b/crates/horizon-client/src/hud_layout.rs @@ -490,6 +490,11 @@ pub struct HealthHud { /// above them. pub left_height: i32, pub right_height: i32, + /// `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 { @@ -761,12 +766,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) diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs index ccdccfb8e..f5ff99939 100644 --- a/crates/horizon-client/src/item_data.rs +++ b/crates/horizon-client/src/item_data.rs @@ -439,6 +439,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 { diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs index 107da9208..f8fb3af8c 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::{ @@ -49,6 +49,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, /// The quad's sprite has translucent pixels (`MaterialInfo.itemRenderType` /// is a translucent sheet): drawn with the translucent entities. pub translucent: bool, @@ -307,6 +309,7 @@ fn submit_quads( color: argb(color), foil, light_emission: q.light_emission, + cull_back: false, translucent: translucent || q.material.force_translucent, }); } @@ -787,7 +790,7 @@ impl ItemSink for WorldSink<'_> { for (i, (p, uv)) in q.pos.iter().zip(q.uv).enumerate() { let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.uv(q.foil_uv[i])); 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 a99969679..1ae908db6 100644 --- a/crates/horizon-client/src/item_render/gui.rs +++ b/crates/horizon-client/src/item_render/gui.rs @@ -377,6 +377,7 @@ mod tests { color, foil: Foil::None, light_emission: 0, + cull_back: false, translucent: false, } } diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs index 6a1d049af..1bc7cb12e 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]) {} @@ -120,6 +131,7 @@ fn draw( color, foil, light_emission: 0, + cull_back: false, translucent: false, }); } @@ -571,6 +583,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") @@ -674,4 +688,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" + ); + } } diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 083a99dec..cc53eeaed 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -215,7 +215,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 70b9babe0..8f1845de1 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -199,6 +199,9 @@ pub struct Hub { pub ops: std::collections::HashMap, /// `entity-broadcast-range-percentage` (dedicated servers). pub entity_range_percent: i32, + /// `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, @@ -369,6 +372,7 @@ impl Hub { stepping: 0, ops: Default::default(), entity_range_percent: 100, + spawn_protection: 0, weather: (false, 0.0, 0.0), level_sync: Default::default(), chat_type, @@ -489,6 +493,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) { @@ -606,16 +617,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: self.flat_world, - 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, } @@ -684,7 +703,7 @@ impl Hub { reduced_debug_info: false, show_death_screen: !self.immediate_respawn, 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(), @@ -2520,14 +2539,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). @@ -2640,8 +2652,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(); @@ -2738,7 +2749,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/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/lib.rs b/crates/horizon-client/src/lib.rs index 4082c0b0c..5ff582455 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -169,6 +169,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/mesher.rs b/crates/horizon-client/src/mesher.rs index 7594e7e31..491e70366 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -36,11 +36,15 @@ 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], /// The `GLINT_TEXTURING` atlas UV for a foil item quad; zero elsewhere. pub glint_uv: [f32; 2], } +/// `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 @@ -57,7 +61,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, @@ -892,8 +896,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/mobs.rs b/crates/horizon-client/src/mobs.rs index cd8962754..29e9313f1 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -53,6 +53,7 @@ pub mod nautilus; pub mod nav; pub mod nether; pub mod panda; +pub mod parrot; pub mod path; pub mod phantom; pub mod piglin; @@ -514,6 +515,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, @@ -530,6 +533,8 @@ pub enum DamageKind { Magic, Sting, Cactus, + /// `sweet_berry_bush`. + SweetBerryBush, Generic, InWall, Thorns, @@ -576,6 +581,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, @@ -592,6 +605,7 @@ impl Damage { | DamageKind::DryOut | DamageKind::Generic | DamageKind::InWall + | DamageKind::SweetBerryBush ) } /// DamageTypeTags.BYPASSES_ARMOR @@ -628,6 +642,7 @@ impl Damage { | DamageKind::DryOut | DamageKind::Magic | DamageKind::Cactus + | DamageKind::SweetBerryBush | DamageKind::Generic | DamageKind::InWall | DamageKind::Freeze @@ -652,6 +667,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 { @@ -685,6 +702,10 @@ 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 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, @@ -695,6 +716,8 @@ pub struct Extra { pub inventory: 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). @@ -705,7 +728,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>, @@ -719,6 +741,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, @@ -862,6 +886,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, /// `Entity.pistonDeltas` and `pistonDeltasGameTime`: how far a moving /// block has pushed this mob this tick (0.51 at most on any axis). pub piston: horizon_world::piston_movement::PistonMovement, @@ -943,6 +969,16 @@ pub enum MobEvent { 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). @@ -956,6 +992,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, @@ -1037,6 +1078,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], + }, /// `Entity.move(MoverType.SHULKER, delta)`: shift a target's position /// (an opening shulker lifts what stands on its shell). Shift { @@ -1084,6 +1134,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), @@ -1126,6 +1183,14 @@ pub enum MobEvent { pos: [i32; 3], data: i32, }, + /// `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], @@ -1365,6 +1430,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, @@ -1414,12 +1481,16 @@ pub struct Seen { pub stats: [f64; 3], /// `Wolf.isInSittingPose`. pub sitting: bool, + /// `Entity.isSilent`. + pub silent: bool, /// `Entity.isVehicle` or `isPassenger`. pub ridden: bool, /// `Attributes.KNOCKBACK_RESISTANCE`. pub knockback_resistance: f64, /// The active effects, without namespace (`slowness`, `poison`...). pub effects: Vec<&'static str>, + /// A piglin's `HUNTED_RECENTLY` memory. + pub hunted_recently: bool, } impl Seen { /// `LivingEntity.hasEffect`, by id without namespace. @@ -1470,6 +1541,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, @@ -1505,6 +1577,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(), knockback_resistance: m.attrs.knockback_resistance, effects: m @@ -1513,6 +1586,7 @@ impl Mob { .iter() .map(|e| e.0.trim_start_matches("minecraft:")) .collect(), + hunted_recently: m.species() == Species::Piglin && m.extra.ints[0] > 0, } } /// `EntityType.getCategory`'s name. @@ -1794,6 +1868,7 @@ impl Mob { // Mob.ambientSoundTime starts at 0. ambient_timer: 0, fall_distance: 0.0, + stuck_multiplier: Vec3::ZERO, piston: Default::default(), persistent: false, random, @@ -1866,13 +1941,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, ), ) } @@ -1996,18 +2075,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`). @@ -2038,7 +2128,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.ambient_interval(); } @@ -2062,6 +2157,46 @@ 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.extra.body_extra = None; + 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); @@ -2110,8 +2245,10 @@ 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, witch::speed(self, self.attrs.speed)) - * self.speed_bonus(); + let mut v = strider::movement_speed( + self, + witch::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), @@ -2503,6 +2640,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::*; diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index e1627e29f..7d596f5ca 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -123,7 +123,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 @@ -182,9 +182,12 @@ 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 if m.species() == Species::Armadillo => super::armadillo::register(m), Family::Generic if m.species() == Species::Frog => super::frog::register(m), Family::Generic if m.species() == Species::Fox => super::fox::register(m), + Family::Generic if m.species() == Species::Parrot => super::tame::register_parrot(m), Family::Generic => { generic(m); if m.species() == Species::Rabbit { @@ -202,9 +205,6 @@ pub fn register(m: &mut Mob) { gravity: true, }; } - if m.species() == Species::Turtle { - super::turtle::register(m); - } if m.species() == Species::Goat { super::goat::register(m); } @@ -442,9 +442,16 @@ 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); } + effects_from_blocks(m, w); if m.species() == Species::Rabbit { super::rabbit::post_tick(m); } @@ -480,6 +487,59 @@ 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 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(); + 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 { + 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::SweetBerryBush)); + } + } + _ => continue, + } + visited.push(p); + } + } + } + } +} /// LivingEntity.updateSwingTime (6-tick swing duration). pub fn tick_swing(m: &mut Mob) { if m.ai.swinging { @@ -725,6 +785,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", @@ -776,6 +837,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 @@ -837,8 +901,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())); @@ -847,10 +911,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; @@ -1141,6 +1207,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, @@ -1152,6 +1228,9 @@ fn species_ai_step( } 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 => 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), @@ -1463,6 +1542,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| { @@ -1532,6 +1614,10 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, _amount: f32) -> bool { super::panda::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/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/body_anim.rs b/crates/horizon-client/src/mobs/body_anim.rs index 3f458085b..d31603156 100644 --- a/crates/horizon-client/src/mobs/body_anim.rs +++ b/crates/horizon-client/src/mobs/body_anim.rs @@ -981,7 +981,9 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool { 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; // `Parrot.isFlying` is `!onGround`, in water too. - 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 { ParrotPose::Flying diff --git a/crates/horizon-client/src/mobs/creaking.rs b/crates/horizon-client/src/mobs/creaking.rs index e23cd817c..0bfccc7a6 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/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/drops.rs b/crates/horizon-client/src/mobs/drops.rs index e20f991c1..d0159a619 100644 --- a/crates/horizon-client/src/mobs/drops.rs +++ b/crates/horizon-client/src/mobs/drops.rs @@ -251,6 +251,9 @@ pub fn slot_item(m: &Mob, slot: &str) -> Option { 1 }; let mut stack = loot_stack(item?, count as i32); + 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)); @@ -288,6 +291,8 @@ 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" => { diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs index b2ca6db9f..72c6a7ccd 100644 --- a/crates/horizon-client/src/mobs/enderman.rs +++ b/crates/horizon-client/src/mobs/enderman.rs @@ -154,6 +154,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) { diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs index b3532726e..52f3d575f 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) { @@ -898,6 +903,28 @@ pub fn slot_enchantments(m: &Mob, slot: usize) -> gear::Levels { pub fn set_slot_enchantments(m: &mut Mob, slot: usize, levels: gear::Levels) { gear::set(m, gear_slot(slot), levels); } +/// `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/goals.rs b/crates/horizon-client/src/mobs/goals.rs index 11dd40d6b..e4682b0de 100644 --- a/crates/horizon-client/src/mobs/goals.rs +++ b/crates/horizon-client/src/mobs/goals.rs @@ -675,6 +675,9 @@ pub struct Panic { pub speed: f64, /// Only the damage of `#panic_environmental_causes` (an armadillo). pub environmental: bool, + /// `TurtlePanicGoal`: always look for water this far away, not only + /// when on fire. + pub water_range: Option, pos: [f64; 3], } impl Panic { @@ -682,9 +685,15 @@ impl Panic { Self { speed, environmental: false, + 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 @@ -707,18 +716,19 @@ impl Goal for Panic { if !wanted { 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/golem.rs b/crates/horizon-client/src/mobs/golem.rs index ae73ef854..2fe37331b 100644 --- a/crates/horizon-client/src/mobs/golem.rs +++ b/crates/horizon-client/src/mobs/golem.rs @@ -341,12 +341,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); diff --git a/crates/horizon-client/src/mobs/guardian.rs b/crates/horizon-client/src/mobs/guardian.rs index ea70ecb41..4bdd1831b 100644 --- a/crates/horizon-client/src/mobs/guardian.rs +++ b/crates/horizon-client/src/mobs/guardian.rs @@ -291,7 +291,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/hostile.rs b/crates/horizon-client/src/mobs/hostile.rs index 689301e14..e5c7b6a93 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/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/living.rs b/crates/horizon-client/src/mobs/living.rs index 612ab0dbb..2de7297ef 100644 --- a/crates/horizon-client/src/mobs/living.rs +++ b/crates/horizon-client/src/mobs/living.rs @@ -505,7 +505,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, @@ -990,8 +997,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(); } 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/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/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" +} diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs index f8bc9acfe..ed219d312 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}; @@ -62,15 +63,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; @@ -394,6 +474,19 @@ 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 { + 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; if m.extra.anger == 0 && m.ai.target == Some(Who::Player) && !hostile_to_player(m, w) { diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs index 9b1d17eed..04ebdff1e 100644 --- a/crates/horizon-client/src/mobs/raider.rs +++ b/crates/horizon-client/src/mobs/raider.rs @@ -46,6 +46,9 @@ pub struct State { /// Banners with no path to them, and until when (game time): /// `unreachableBannerCache`. pub unreachable_banners: Vec<(u32, i64)>, + /// `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`. @@ -105,6 +108,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) } @@ -122,7 +129,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::default()); - 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); } @@ -379,9 +386,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 @@ -402,6 +411,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, diff --git a/crates/horizon-client/src/mobs/ravager.rs b/crates/horizon-client/src/mobs/ravager.rs index 4c179aeda..daa707a07 100644 --- a/crates/horizon-client/src/mobs/ravager.rs +++ b/crates/horizon-client/src/mobs/ravager.rs @@ -236,7 +236,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/render.rs b/crates/horizon-client/src/mobs/render.rs index ee319caf6..d02c3a172 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -439,13 +439,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, @@ -1452,7 +1476,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/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" 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? { diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs index 64106574b..201632706 100644 --- a/crates/horizon-client/src/mobs/species.rs +++ b/crates/horizon-client/src/mobs/species.rs @@ -1699,10 +1699,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 ) } diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs index 9a71e9682..f0d4611a5 100644 --- a/crates/horizon-client/src/mobs/sulfur_cube.rs +++ b/crates/horizon-client/src/mobs/sulfur_cube.rs @@ -370,6 +370,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool { source.kind, DamageKind::PlayerAttack | DamageKind::MaceSmash + | DamageKind::Spear | DamageKind::MobAttack | DamageKind::Arrow | DamageKind::Thrown @@ -378,6 +379,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool { | DamageKind::Sting | DamageKind::Cactus | DamageKind::Freeze + | DamageKind::SweetBerryBush ); if immune { if let Some(from) = source.from { diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index f38296d4b..faee3c4de 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -100,6 +100,48 @@ 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)); + 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. + 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 + .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 { matches!(s.species, Species::Sheep | Species::Rabbit | Species::Fox) @@ -138,6 +180,18 @@ fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> { let p = owner_view(m, w)?; 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 || owner_view(m, w).is_some_and(|p| p.spectator) @@ -448,7 +502,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; @@ -461,7 +516,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, } diff --git a/crates/horizon-client/src/mobs/turtle.rs b/crates/horizon-client/src/mobs/turtle.rs index e56973384..58417052e 100644 --- a/crates/horizon-client/src/mobs/turtle.rs +++ b/crates/horizon-client/src/mobs/turtle.rs @@ -1,23 +1,77 @@ //! 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`. Its own -//! `TurtleMoveControl` sets the speed it walks and swims at. Not ported yet: -//! `Turtle.travelInWater` (swimming still uses the generic fluid travel), -//! `TurtlePathNavigation` and the rest of the turtle goal set, so movement in -//! water still differs from vanilla. +//! `extra.counter` `layEggCounter`, `extra.home` `homePos`, `extra.counter2` +//! `goingHome` and `extra.point` `travelPos`. Its own `TurtleMoveControl` +//! sets the speed it walks and swims at. Not ported yet: `Turtle.travelInWater` +//! (swimming still uses the generic fluid travel), so movement in water still +//! differs from vanilla. use super::{ Mob, MobEvent, MobWorld, control::{EPSILON, Operation, rotlerp}, - 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::{geometry::trig, 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 { @@ -209,10 +263,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) } @@ -252,6 +310,173 @@ 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); + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs index 25c610f69..0f446c87a 100644 --- a/crates/horizon-client/src/mobs/undead.rs +++ b/crates/horizon-client/src/mobs/undead.rs @@ -844,8 +844,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)), @@ -866,7 +867,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); @@ -1040,16 +1041,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/warden.rs b/crates/horizon-client/src/mobs/warden.rs index 747443577..0714bfc64 100644 --- a/crates/horizon-client/src/mobs/warden.rs +++ b/crates/horizon-client/src/mobs/warden.rs @@ -730,34 +730,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 diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs index 2fdd16372..0a429b135 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_smoke(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) { 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/motion.rs b/crates/horizon-client/src/motion.rs index d357a196f..e9899ad40 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,10 +51,10 @@ pub struct MotionResources { pub attributes: Arc, pub blocks: BoundMovementProperties, pub climbable: BTreeSet, - /// `BlockTags.CAN_GLIDE_THROUGH`: climbable blocks a gliding player passes. - pub glide_through: BTreeSet, /// `BlockTags.SOUL_SPEED_BLOCKS`: what Soul Speed's effects look for. pub soul_speed_blocks: BTreeSet, + /// `LivingEntity.onClimbable` tags plus open trapdoors above a ladder. + pub climbing: ClimbingRegistry<'static>, pub fall_reset: BTreeSet, /// `BlockTags.INSIDE_STEP_SOUND_BLOCKS`. pub inside_step_sound: BTreeSet, @@ -107,6 +108,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)?, @@ -118,8 +125,8 @@ impl MotionResources { suppresses_bounce: tag("minecraft:suppresses_bounce")?, })?, climbable: tag("minecraft:climbable")?, - glide_through: tag("minecraft:can_glide_through")?, soul_speed_blocks: tag("minecraft:soul_speed_blocks")?, + climbing, fall_reset: tag("minecraft:fall_damage_resetting")?, inside_step_sound: tag("minecraft:inside_step_sound_blocks")?, combination_step_sound: tag("minecraft:combination_step_sound_blocks")?, @@ -359,6 +366,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 @@ -540,6 +549,7 @@ impl PlayerMotion { ticks_frozen: 0, leather_boots: false, freeze_immune: false, + burn_from_stepping_immune: false, old_position: position, server_copy: false, wall_hit_events: None, @@ -819,27 +829,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; - // A gliding player passes through vines (`CAN_GLIDE_THROUGH`). - if self.player.fall_flying && self.resources.glide_through.contains(name) { - return Ok(false); - } - 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) @@ -1807,6 +1805,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 { diff --git a/crates/horizon-client/src/motion/environment.rs b/crates/horizon-client/src/motion/environment.rs index 5e9bdfec8..826cc31bb 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 diff --git a/crates/horizon-client/src/projectiles.rs b/crates/horizon-client/src/projectiles.rs index b3e9938c9..43606839e 100644 --- a/crates/horizon-client/src/projectiles.rs +++ b/crates/horizon-client/src/projectiles.rs @@ -66,6 +66,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 { .. } | Self::Trident => 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 { diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 885d10771..d304da145 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -2711,6 +2711,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_particles). pub active_effects: Vec<(String, i32, i32, bool, bool)>, /// Player.EnderItems: the ender chest inventory (27 slots). @@ -2911,6 +2913,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; @@ -3011,6 +3022,7 @@ impl Level { "Pos", "respawn", "recipeBook", + "LastDeathLocation", ] { map.remove(&JavaString::from(key)); } @@ -3137,6 +3149,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![ 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), + ) +} 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 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, .. } => { diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs index 5177e44e3..210786493 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, }; @@ -386,18 +384,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 dcb01e782..4d228f898 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -258,7 +258,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). @@ -379,6 +380,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), @@ -815,6 +822,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 42ba42634..6676242e1 100644 --- a/crates/horizon-world/src/level/redstone.rs +++ b/crates/horizon-world/src/level/redstone.rs @@ -5,13 +5,13 @@ 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, trig}, + geometry::{Axis, Direction, trig}, position::BlockPos, random::RandomSource, ticks::TickPriority, @@ -493,8 +493,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; } } } @@ -1260,6 +1266,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) { diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index 51b6b8083..d0af71808 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); } 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/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): 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/tests/test_remote_motion.py b/tests/test_remote_motion.py index 59526b476..5148c2c1b 100644 --- a/tests/test_remote_motion.py +++ b/tests/test_remote_motion.py @@ -35,8 +35,8 @@ 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, rockets: Vec, - remote: Option, + creatures: Creatures, dragon_fireballs: Vec, tridents: Vec, + rockets: Vec, remote: Option, potions: Potions, end: End, } impl Game { 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)" } 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',