diff --git a/crates/horizon-client-core/src/block_entity_nbt.rs b/crates/horizon-client-core/src/block_entity_nbt.rs index 6e214fd61..a4387bf48 100644 --- a/crates/horizon-client-core/src/block_entity_nbt.rs +++ b/crates/horizon-client-core/src/block_entity_nbt.rs @@ -61,6 +61,16 @@ fn f32_tag(v: f32) -> Tag { Tag::Float(v.to_bits()) } +/// `TheEndGatewayBlockEntity.loadAdditional`: BlockPos.CODEC and Level.isInSpawnableBounds. +pub fn gateway_exit(tag: &Tag) -> Option<[i32; 3]> { + let Tag::IntArray(v) = tag else { return None }; + let p: [i32; 3] = v.as_slice().try_into().ok()?; + ((-30_000_000..30_000_000).contains(&p[0]) + && (-20_000_000..20_000_000).contains(&p[1]) + && (-30_000_000..30_000_000).contains(&p[2])) + .then_some(p) +} + /// What a block entity reads and writes, in `saveAdditional` order. struct Fields<'a> { input: &'a Tag, @@ -424,10 +434,7 @@ pub fn canonical(tag: &Tag) -> Option { } "minecraft:end_gateway" => { f.long("Age", 0); - f.keep("exit_portal", |t| { - is_pos(t) - && matches!(t, Tag::IntArray(v) if v[1].abs() <= 30_000_000 && v[0].abs() <= 30_000_000 && v[2].abs() <= 30_000_000) - }); + f.keep("exit_portal", |t| gateway_exit(t).is_some()); if flag(tag.get("ExactTeleport")) == Some(true) { f.put("ExactTeleport", boolean(true)); } diff --git a/crates/horizon-client-core/src/component.rs b/crates/horizon-client-core/src/component.rs index 5b828b305..afb68fa98 100644 --- a/crates/horizon-client-core/src/component.rs +++ b/crates/horizon-client-core/src/component.rs @@ -173,6 +173,22 @@ fn object_style(o: &serde_json::Map) -> Style { if let Some(e) = o.get("click_event").and_then(Value::as_object) { let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned); style.click = match e.get("action").and_then(Value::as_str) { + // ClickEvent.OpenUrl.CODEC: ExtraCodecs.UNTRUSTED_URI allows http and + // https only, the scheme in any case (Util.parseAndValidateUntrustedUri). + Some("open_url") => text("url") + .filter(|u| { + u.split_once(':').is_some_and(|(scheme, _)| { + scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https") + }) + }) + .map(crate::text::ClickEvent::OpenUrl), + // ClickEvent.ChangePage.CODEC: ExtraCodecs.POSITIVE_INT. + Some("change_page") => e + .get("page") + .and_then(Value::as_i64) + .and_then(|p| i32::try_from(p).ok()) + .filter(|p| *p >= 1) + .map(crate::text::ClickEvent::ChangePage), Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand), Some("copy_to_clipboard") => { text("value").map(crate::text::ClickEvent::CopyToClipboard) diff --git a/crates/horizon-client-core/src/lib.rs b/crates/horizon-client-core/src/lib.rs index 2030165c5..7721668ca 100644 --- a/crates/horizon-client-core/src/lib.rs +++ b/crates/horizon-client-core/src/lib.rs @@ -16,6 +16,7 @@ pub mod lang; pub mod nbt_path; pub mod particle_type; pub mod pattern; +pub mod potions; pub mod registries; pub mod scoreboard; pub mod snbt; diff --git a/crates/horizon-client-core/src/potions.rs b/crates/horizon-client-core/src/potions.rs new file mode 100644 index 000000000..044b25e3a --- /dev/null +++ b/crates/horizon-client-core/src/potions.rs @@ -0,0 +1,249 @@ +//! The `MobEffects` and `Potions` registries (code in vanilla, ported as +//! tables): each effect's colour and category, each potion's effects, and the +//! potion colour mix. horizon-client re-exports them from `brewing`. +use std::{collections::HashMap, sync::OnceLock}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Category { + Beneficial, + Harmful, + Neutral, +} +/// A `MobEffect`: id (without namespace), colour, category, instantaneous. +#[derive(Clone, Copy, Debug)] +pub struct EffectDef { + pub id: &'static str, + pub color: u32, + pub category: Category, + pub instant: bool, +} +const fn fx(id: &'static str, color: u32, category: Category) -> EffectDef { + EffectDef { + id, + color, + category, + instant: false, + } +} +use Category::{Beneficial as B, Harmful as H, Neutral as N}; +/// `MobEffects` in registration order. +pub const EFFECTS: &[EffectDef] = &[ + fx("speed", 3402751, B), + fx("slowness", 9154528, H), + fx("haste", 14270531, B), + fx("mining_fatigue", 4866583, H), + fx("strength", 16762624, B), + EffectDef { + id: "instant_health", + color: 16262179, + category: B, + instant: true, + }, + EffectDef { + id: "instant_damage", + color: 11101546, + category: H, + instant: true, + }, + fx("jump_boost", 16646020, B), + fx("nausea", 5578058, H), + fx("regeneration", 13458603, B), + fx("resistance", 9520880, B), + fx("fire_resistance", 16750848, B), + fx("water_breathing", 10017472, B), + fx("invisibility", 16185078, B), + fx("blindness", 2039587, H), + fx("night_vision", 12779366, B), + fx("hunger", 5797459, H), + fx("weakness", 4738376, H), + fx("poison", 8889187, H), + fx("wither", 7561558, H), + fx("health_boost", 16284963, B), + fx("absorption", 2445989, B), + EffectDef { + id: "saturation", + color: 16262179, + category: B, + instant: true, + }, + fx("glowing", 9740385, N), + fx("levitation", 13565951, H), + fx("luck", 5882118, B), + fx("unluck", 12624973, H), + fx("slow_falling", 15978425, B), + fx("conduit_power", 1950417, B), + fx("dolphins_grace", 8954814, B), + fx("bad_omen", 745784, N), + fx("hero_of_the_village", 4521796, B), + fx("darkness", 2696993, H), + fx("trial_omen", 1484454, N), + fx("raid_omen", 14565464, N), + fx("wind_charged", 12438015, H), + fx("weaving", 7891290, H), + fx("oozing", 10092451, H), + fx("infested", 9214860, H), + fx("breath_of_the_nautilus", 65518, B), +]; +pub fn effect(id: &str) -> Option<&'static EffectDef> { + let id = id.trim_start_matches("minecraft:"); + EFFECTS.iter().find(|e| e.id == id) +} +/// Namespaced effect ids for mob effect storage. +pub fn namespaced(id: &'static str) -> &'static str { + static IDS: OnceLock> = OnceLock::new(); + IDS.get_or_init(|| { + EFFECTS + .iter() + .map(|e| { + ( + e.id, + &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()), + ) + }) + .collect() + }) + .get(id) + .copied() + .unwrap_or(id) +} +/// A `Potion`: id, name suffix (`item.minecraft.potion.effect.`) and +/// effects as (effect, duration ticks, amplifier). +#[derive(Clone, Copy, Debug)] +pub struct PotionDef { + pub id: &'static str, + pub name: &'static str, + pub effects: &'static [(&'static str, i32, i32)], +} +const fn p( + id: &'static str, + name: &'static str, + effects: &'static [(&'static str, i32, i32)], +) -> PotionDef { + PotionDef { id, name, effects } +} +/// `Potions` in registration order. +pub const POTIONS: &[PotionDef] = &[ + p("water", "water", &[]), + p("mundane", "mundane", &[]), + p("thick", "thick", &[]), + p("awkward", "awkward", &[]), + p("night_vision", "night_vision", &[("night_vision", 3600, 0)]), + p( + "long_night_vision", + "night_vision", + &[("night_vision", 9600, 0)], + ), + p("invisibility", "invisibility", &[("invisibility", 3600, 0)]), + p( + "long_invisibility", + "invisibility", + &[("invisibility", 9600, 0)], + ), + p("leaping", "leaping", &[("jump_boost", 3600, 0)]), + p("long_leaping", "leaping", &[("jump_boost", 9600, 0)]), + p("strong_leaping", "leaping", &[("jump_boost", 1800, 1)]), + p( + "fire_resistance", + "fire_resistance", + &[("fire_resistance", 3600, 0)], + ), + p( + "long_fire_resistance", + "fire_resistance", + &[("fire_resistance", 9600, 0)], + ), + p("swiftness", "swiftness", &[("speed", 3600, 0)]), + p("long_swiftness", "swiftness", &[("speed", 9600, 0)]), + p("strong_swiftness", "swiftness", &[("speed", 1800, 1)]), + p("slowness", "slowness", &[("slowness", 1800, 0)]), + p("long_slowness", "slowness", &[("slowness", 4800, 0)]), + p("strong_slowness", "slowness", &[("slowness", 400, 3)]), + p( + "turtle_master", + "turtle_master", + &[("slowness", 400, 3), ("resistance", 400, 2)], + ), + p( + "long_turtle_master", + "turtle_master", + &[("slowness", 800, 3), ("resistance", 800, 2)], + ), + p( + "strong_turtle_master", + "turtle_master", + &[("slowness", 400, 5), ("resistance", 400, 3)], + ), + p( + "water_breathing", + "water_breathing", + &[("water_breathing", 3600, 0)], + ), + p( + "long_water_breathing", + "water_breathing", + &[("water_breathing", 9600, 0)], + ), + p("healing", "healing", &[("instant_health", 1, 0)]), + p("strong_healing", "healing", &[("instant_health", 1, 1)]), + p("harming", "harming", &[("instant_damage", 1, 0)]), + p("strong_harming", "harming", &[("instant_damage", 1, 1)]), + p("poison", "poison", &[("poison", 900, 0)]), + p("long_poison", "poison", &[("poison", 1800, 0)]), + p("strong_poison", "poison", &[("poison", 432, 1)]), + p("regeneration", "regeneration", &[("regeneration", 900, 0)]), + p( + "long_regeneration", + "regeneration", + &[("regeneration", 1800, 0)], + ), + p( + "strong_regeneration", + "regeneration", + &[("regeneration", 450, 1)], + ), + p("strength", "strength", &[("strength", 3600, 0)]), + p("long_strength", "strength", &[("strength", 9600, 0)]), + p("strong_strength", "strength", &[("strength", 1800, 1)]), + p("weakness", "weakness", &[("weakness", 1800, 0)]), + p("long_weakness", "weakness", &[("weakness", 4800, 0)]), + p("luck", "luck", &[("luck", 6000, 0)]), + p("slow_falling", "slow_falling", &[("slow_falling", 1800, 0)]), + p( + "long_slow_falling", + "slow_falling", + &[("slow_falling", 4800, 0)], + ), + p("wind_charged", "wind_charged", &[("wind_charged", 3600, 0)]), + p("weaving", "weaving", &[("weaving", 3600, 0)]), + p("oozing", "oozing", &[("oozing", 3600, 0)]), + p("infested", "infested", &[("infested", 3600, 0)]), +]; +pub fn potion(id: &str) -> Option<&'static PotionDef> { + let id = id.trim_start_matches("minecraft:"); + POTIONS.iter().find(|p| p.id == id) +} +/// `PotionContents.BASE_POTION_COLOR` (ARGB -13083194) as RGB. +pub const BASE_POTION_COLOR: u32 = 0x385DC6; +/// `PotionContents.getColor`: amplifier-weighted mix of visible effect colours. +pub fn potion_color(id: Option<&str>) -> u32 { + let Some(def) = id.and_then(potion) else { + return BASE_POTION_COLOR; + }; + let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32); + for (e, _, amp) in def.effects { + let Some(e) = effect(e) else { continue }; + let w = *amp as u32 + 1; + r += w * (e.color >> 16 & 255); + g += w * (e.color >> 8 & 255); + b += w * (e.color & 255); + total += w; + } + match ( + r.checked_div(total), + g.checked_div(total), + b.checked_div(total), + ) { + (Some(r), Some(g), Some(b)) => (r << 16) | (g << 8) | b, + _ => BASE_POTION_COLOR, + } +} diff --git a/crates/horizon-client-core/src/text.rs b/crates/horizon-client-core/src/text.rs index 0a2b6eadb..3a0bf301b 100644 --- a/crates/horizon-client-core/src/text.rs +++ b/crates/horizon-client-core/src/text.rs @@ -42,6 +42,10 @@ pub fn named_color(name: &str) -> Option { /// Click actions carried by locally constructed text components. #[derive(Clone, Debug, PartialEq, Eq)] pub enum ClickEvent { + /// `ClickEvent.OpenUrl`: an http or https link. + OpenUrl(String), + /// `ClickEvent.ChangePage`: a book's page, counted from 1. + ChangePage(i32), SuggestCommand(String), CopyToClipboard(String), /// A local file to open with the system handler. @@ -529,6 +533,8 @@ fn style_json(style: &Style) -> Vec<(String, Value)> { } if let Some(click) = &style.click { let event = match click { + ClickEvent::OpenUrl(url) => json!({ "action": "open_url", "url": url }), + ClickEvent::ChangePage(page) => json!({ "action": "change_page", "page": page }), ClickEvent::SuggestCommand(command) => { json!({ "action": "suggest_command", "command": command }) } diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index 5ea0a456b..07f2bf22a 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -580,7 +580,7 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool { match e { MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0, // ServerExplosion.hurtEntities: within twice the radius every hit does damage. - MobEvent::Explode(at, radius) => { + MobEvent::Explode(at, radius, _) => { let d = Vec3::new(at[0], at[1], at[2]) .distance_squared(p.position) .sqrt(); @@ -1050,6 +1050,7 @@ pub fn main() -> horizon_client::Result<()> { off_hand: None, head: None, armor_cover: 0.0, + invisible: false, spectator: false, gold_armor: false, hurt_by: None, @@ -1071,6 +1072,8 @@ pub fn main() -> horizon_client::Result<()> { for (i, m) in mobs.iter().enumerate() { print(&mut out, 0, i, m, s.creative, world.game_time); } + // No player has a chest open in the scenarios. + let lid_openers = std::collections::HashMap::new(); // The MobWorld every step sees, over a snapshot of the mobs. macro_rules! mob_world { ($snapshot:expr) => { @@ -1100,12 +1103,14 @@ pub fn main() -> horizon_client::Result<()> { block_tags: &items.block_tags, biomes: &biomes, mob_griefing: true, + mob_drops: true, difficulty: LocalDifficulty::new(s.difficulty, world.day_time, 0, 0.0), end: false, world_seed: 0, // FlatLevelSource.getSeaLevel. sea_level: -63, items: Some(&items), + lid_openers: &lid_openers, } }; } diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs index 6706532b7..1ed11da4d 100644 --- a/crates/horizon-client/src/advancements.rs +++ b/crates/horizon-client/src/advancements.rs @@ -437,6 +437,8 @@ pub struct EntityView { /// mainhand, offhand, head, chest, legs, feet, body. pub equipment: [Option; 7], pub vehicle: Option>, + /// Player: what it looks at within 100 blocks (`PlayerPredicate.lookingAt`). + pub looking_at: Option>, pub effects: Vec<(String, i32, i32)>, /// Player: game mode name. pub gamemode: Option, @@ -458,7 +460,7 @@ fn range_f(v: &Value, x: f64) -> bool { _ => false, } } -fn range_i(v: &Value, x: i64) -> bool { +pub fn range_i(v: &Value, x: i64) -> bool { range_f(v, x as f64) } /// A registry id, `#tag`, or list matched against one id. @@ -473,6 +475,51 @@ pub fn id_matches(v: &Value, registry: &str, id: &str, w: &dyn World) -> bool { _ => false, } } +/// `PotionsPredicate`: the potion in a `HolderSet`, plus a `CollectionPredicate` +/// over the potion's effects (`contains`, `count`, `size`). +pub fn potions(v: &Value, potion: Option<&str>, w: &dyn World) -> bool { + if v.is_null() { + return true; + } + if !v["potions"].is_null() && !potion.is_some_and(|p| id_matches(&v["potions"], "potion", p, w)) + { + return false; + } + let c = &v["effects"]; + if c.is_null() { + return true; + } + let effects: Vec<(String, i32, i32)> = potion + .and_then(crate::brewing::potion) + .map(|d| { + d.effects + .iter() + .map(|(id, dur, amp)| (format!("minecraft:{id}"), *amp, *dur)) + .collect() + }) + .unwrap_or_default(); + // `MobEffectsPredicate.test`: the one listed effect, amplifier and duration. + let test = |pred: &Value, e: &(String, i32, i32)| { + pred.as_object().is_some_and(|m| { + m.get(&e.0).is_some_and(|want| { + range_i(&want["amplifier"], i64::from(e.1)) + && range_i(&want["duration"], i64::from(e.2)) + && want["ambient"].as_bool().is_none_or(|b| !b) + && want["visible"].as_bool().is_none_or(|b| b) + }) + }) + }; + c["contains"] + .as_array() + .is_none_or(|l| l.iter().all(|p| effects.iter().any(|e| test(p, e)))) + && c["count"].as_array().is_none_or(|l| { + l.iter().all(|entry| { + let n = effects.iter().filter(|e| test(&entry["test"], e)).count(); + range_i(&entry["count"], n as i64) + }) + }) + && range_i(&c["size"], effects.len() as i64) +} /// `ItemPredicate`. pub fn item(v: &Value, it: &ItemView, w: &dyn World) -> bool { if v.is_null() { @@ -614,6 +661,18 @@ fn components(expected: &Value, have: &[(String, String)]) -> bool { }) }) } +/// `DistancePredicate.matches` between two points. +pub fn distance(v: &Value, a: [f64; 3], b: [f64; 3]) -> bool { + let d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; + range_f(&v["x"], d[0].abs()) + && range_f(&v["y"], d[1].abs()) + && range_f(&v["z"], d[2].abs()) + && range_f(&v["horizontal"], (d[0] * d[0] + d[2] * d[2]).sqrt()) + && range_f( + &v["absolute"], + (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(), + ) +} /// `EntityPredicate` (26.x keyed sub-predicates). pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> bool { if v.is_null() { @@ -629,21 +688,7 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo "minecraft:stepping_on" => { location(p, [e.position[0], e.position[1] - 0.5, e.position[2]], w) } - "minecraft:distance" | "distance" => { - let d = [ - e.position[0] - origin[0], - e.position[1] - origin[1], - e.position[2] - origin[2], - ]; - range_f(&p["x"], d[0].abs()) - && range_f(&p["y"], d[1].abs()) - && range_f(&p["z"], d[2].abs()) - && range_f(&p["horizontal"], (d[0] * d[0] + d[2] * d[2]).sqrt()) - && range_f( - &p["absolute"], - (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(), - ) - } + "minecraft:distance" | "distance" => distance(p, e.position, origin), "minecraft:flags" | "flags" => { let f = |k: &str, have: bool| p[k].as_bool().is_none_or(|want| want == have); f("is_on_fire", e.on_fire) @@ -678,11 +723,16 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo }) }) }), - "minecraft:type_specific/player" => p["gamemode"].as_array().is_none_or(|modes| { - e.gamemode - .as_deref() - .is_some_and(|g| modes.iter().any(|m| m.as_str() == Some(g))) - }), + "minecraft:type_specific/player" => { + p["gamemode"].as_array().is_none_or(|modes| { + e.gamemode + .as_deref() + .is_some_and(|g| modes.iter().any(|m| m.as_str() == Some(g))) + }) && (p["looking_at"].is_null() + || e.looking_at + .as_ref() + .is_some_and(|t| entity(&p["looking_at"], t, w, origin))) + } "minecraft:type_specific/lightning" => { range_i(&p["blocks_set_on_fire"], 0) && (p["entity_struck"].is_null() @@ -703,6 +753,52 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo } true } +/// A damage event as `DamagePredicate` sees it. +#[derive(Clone, Debug, Default)] +pub struct DamageView { + /// The damage type id (`minecraft:arrow`). + pub kind: String, + /// `DamageSource.getDirectEntity` and `getEntity`. + pub direct: Option, + pub source: Option, + /// `DamageSource.isDirect`: the direct entity is the causing one. + pub is_direct: bool, + /// The damage before and after the shield took its share. + pub original: f32, + pub actual: f32, + pub blocked: bool, +} +/// `DamagePredicate`, with its `DamageSourcePredicate` as `type`. +pub fn damage(v: &Value, d: &DamageView, w: &dyn World, origin: [f64; 3]) -> bool { + if v.is_null() { + return true; + } + let by = |key: &str, e: &Option| { + v[key].is_null() || e.as_ref().is_some_and(|e| entity(&v[key], e, w, origin)) + }; + if !range_f(&v["dealt"], f64::from(d.original)) + || !range_f(&v["taken"], f64::from(d.actual)) + || !by("source_entity", &d.source) + || v["blocked"].as_bool().is_some_and(|b| b != d.blocked) + { + return false; + } + let ty = &v["type"]; + let tags_ok = ty["tags"].as_array().into_iter().flatten().all(|t| { + let tag = t["id"].as_str().unwrap_or(""); + let tag = tag.strip_prefix('#').unwrap_or(tag); + w.in_tag("damage_type", tag, &d.kind) == t["expected"].as_bool().unwrap_or(true) + }); + let direct_ok = ty["direct_entity"].is_null() + || d.direct + .as_ref() + .is_some_and(|e| entity(&ty["direct_entity"], e, w, origin)); + let source_ok = ty["source_entity"].is_null() + || d.source + .as_ref() + .is_some_and(|e| entity(&ty["source_entity"], e, w, origin)); + tags_ok && direct_ok && source_ok && ty["is_direct"].as_bool().is_none_or(|b| b == d.is_direct) +} /// The entities a loot-style condition list may refer to. pub struct Entities<'a> { pub this: Option<&'a EntityView>, diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs index 07548e208..c2123e693 100644 --- a/crates/horizon-client/src/animate_tick.rs +++ b/crates/horizon-client/src/animate_tick.rs @@ -36,8 +36,9 @@ enum Animate { spawn_particles: bool, }, /// Leaves: optional falling-leaf particle and chance; a tinted leaf takes - /// the biome foliage colour unless a fixed colour is given (azalea). - Leaves(Option<(T, f32)>, Option), + /// the biome foliage colour unless a fixed colour is given (azalea); and + /// whether they have the poplar ambient sound (`AmbientLeavesBlockSoundPlayer`). + Leaves(Option<(T, f32)>, Option, bool), NetherPortal, EnchantingTable, EndRod([i32; 3]), @@ -48,8 +49,9 @@ enum Animate { CandleCake, BrewingStand, EnderChest, - /// FallingBlock with its dust colour. - Falling(u32), + /// FallingBlock with its dust colour; sand also has the ambient desert sound + /// (`SandBlock.animateTick`). + Falling(u32, bool), /// A beehive or bee nest full of honey (`BeehiveBlock.animateTick`). Beehive, RedstoneOre, @@ -109,17 +111,17 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { spawn_particles: false, }, "oak_leaves" | "birch_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves" - | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01)), None), - "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1)), None), - "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02)), None), - "red_poplar_leaves" => Animate::Leaves(Some((T::RedPoplarLeaves, 0.01)), None), - "orange_poplar_leaves" => Animate::Leaves(Some((T::OrangePoplarLeaves, 0.01)), None), - "yellow_poplar_leaves" => Animate::Leaves(Some((T::YellowPoplarLeaves, 0.01)), None), + | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01)), None, false), + "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1)), None, false), + "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02)), None, false), + "red_poplar_leaves" => Animate::Leaves(Some((T::RedPoplarLeaves, 0.01)), None, true), + "orange_poplar_leaves" => Animate::Leaves(Some((T::OrangePoplarLeaves, 0.01)), None, true), + "yellow_poplar_leaves" => Animate::Leaves(Some((T::YellowPoplarLeaves, 0.01)), None, true), // The azalea blocks drop tinted leaves of the fixed colour -9399763. "azalea_leaves" | "flowering_azalea_leaves" => { - Animate::Leaves(Some((T::TintedLeaves, 0.01)), Some(0x0070_922D)) + Animate::Leaves(Some((T::TintedLeaves, 0.01)), Some(0x0070_922D), false) } - "spruce_leaves" => Animate::Leaves(None, None), + "spruce_leaves" => Animate::Leaves(None, None, false), "nether_portal" => Animate::NetherPortal, "enchanting_table" => Animate::EnchantingTable, "end_rod" => Animate::EndRod(facing()), @@ -128,16 +130,17 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { "mycelium" => Animate::Mycelium, "brewing_stand" => Animate::BrewingStand, "ender_chest" => Animate::EnderChest, - "sand" => Animate::Falling(0xDBD3A0), - "red_sand" => Animate::Falling(0xA95821), - "gravel" => Animate::Falling(0x807C7B), + "sand" => Animate::Falling(0xDBD3A0, true), + "red_sand" => Animate::Falling(0xA95821, true), + "gravel" => Animate::Falling(0x807C7B, false), // AnvilBlock/ConcretePowderBlock.getDustColor is the map colour; // DragonEggBlock's is black. - "anvil" | "chipped_anvil" | "damaged_anvil" => Animate::Falling(0xA7A7A7), - "dragon_egg" => Animate::Falling(0x000000), - _ if name.ends_with("_concrete_powder") => Animate::Falling(concrete_powder_color( - name.trim_end_matches("_concrete_powder"), - )), + "anvil" | "chipped_anvil" | "damaged_anvil" => Animate::Falling(0xA7A7A7, false), + "dragon_egg" => Animate::Falling(0x000000, false), + _ if name.ends_with("_concrete_powder") => Animate::Falling( + concrete_powder_color(name.trim_end_matches("_concrete_powder")), + false, + ), "beehive" | "bee_nest" if prop("honey_level").as_deref() == Some("5") => Animate::Beehive, "redstone_ore" | "deepslate_redstone_ore" if lit => Animate::RedstoneOre, "redstone_wire" => { @@ -171,8 +174,8 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { "end_portal" => Animate::EndPortal, "wet_sponge" => Animate::WetSponge, // BrushableBlock has no dust colour of its own, so the dust is the map colour. - "suspicious_sand" => Animate::Falling(0xF7E9A3), - "suspicious_gravel" => Animate::Falling(0x707070), + "suspicious_sand" => Animate::Falling(0xF7E9A3, false), + "suspicious_gravel" => Animate::Falling(0x707070, false), "sculk_sensor" | "calibrated_sculk_sensor" if prop("sculk_sensor_phase").as_deref() == Some("active") => { @@ -239,6 +242,10 @@ pub struct AnimateTables { power_transmitter: Vec, /// `#triggers_ambient_dried_ghast_block_sounds` (soul sand, soul soil). dried_ghast_sounds: Vec, + /// `#triggers_ambient_desert_sand_block_sounds` (sand, red sand). + desert_sand_sounds: Vec, + /// `#required_for_poplar_leaf_ambience` (overworld natural logs). + poplar_leaf_logs: Vec, /// `FireBlock.canBurn`: states with ignite odds above zero (none waterlogged). burnable: Vec, /// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`). @@ -314,6 +321,8 @@ impl AnimateTables { power_provider: by_state("minecraft:enchantment_power_provider"), power_transmitter: by_state("minecraft:enchantment_power_transmitter"), dried_ghast_sounds: by_state("minecraft:triggers_ambient_dried_ghast_block_sounds"), + desert_sand_sounds: by_state("minecraft:triggers_ambient_desert_sand_block_sounds"), + poplar_leaf_logs: by_state("minecraft:required_for_poplar_leaf_ambience"), burnable, ambient, }) @@ -402,6 +411,10 @@ impl AnimateContext<'_> { fn add(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) { engine.add(&ParticleOptions::simple(ty), p, v); } +/// `Level.addAlwaysVisibleParticle`: still shown under the Minimal option now and then. +fn add_visible(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) { + engine.add_with(&ParticleOptions::simple(ty), p, v, false, true); +} fn sound(engine: &mut ParticleEngine, name: &'static str, p: [f64; 3], volume: f32, pitch: f32) { engine.sounds.push((name, p, volume, pitch)); } @@ -777,7 +790,7 @@ fn block_animate_tick( } } } - Animate::Leaves(falling, fixed_tint) => { + Animate::Leaves(falling, fixed_tint, poplar) => { let below = [pos[0], pos[1] - 1, pos[2]]; // LeavesBlock.makeDrippingWaterParticles. if (ctx.raining_at)([pos[0], pos[1] + 1, pos[2]]) && next_int(engine.random(), 15) == 1 @@ -789,6 +802,9 @@ fn block_animate_tick( add(engine, T::DrippingWater, p, [0.0; 3]); } } + if poplar { + leaves_ambient_sound(tables, engine, ctx, state, pos); + } // FallingParticlesLeavesBlock.makeFallingLeavesParticles. if let Some((ty, chance)) = falling && engine.random().next_float() < chance @@ -961,7 +977,7 @@ fn block_animate_tick( fy + 1.0 + f64::from(r.next_float()), fz + f64::from(r.next_float()), ]; - add(engine, T::SulfurBubbles, p, [0.0; 3]); + add_visible(engine, T::SulfurBubbles, p, [0.0; 3]); } if next_int(engine.random(), 10) == 0 { let name = "minecraft:block.potent_sulfur.noxious_gas"; @@ -1081,7 +1097,7 @@ fn block_animate_tick( add(engine, T::Portal, p, v); } } - Animate::Falling(color) => { + Animate::Falling(color, sand) => { if next_int(engine.random(), 16) == 0 { let below = ctx.facts.get(ctx.state([pos[0], pos[1] - 1, pos[2]])); // FallingBlock.isFree: air, fire, liquids or replaceable. @@ -1098,6 +1114,14 @@ fn block_animate_tick( ); } } + // AmbientDesertBlockSoundsPlayer.playAmbientSandSounds: only for the air block. + if sand + && ctx.state([pos[0], pos[1] + 1, pos[2]]) == ctx.world.air + && next_int(engine.random(), 2100) == 0 + && sand_sound_nearby(tables, ctx, pos) + { + sound(engine, "minecraft:block.sand.idle", [fx, fy, fz], 1.0, 1.0); + } } Animate::Beehive => { // BeehiveBlock.animateTick: nextInt(1) + 1 attempts. @@ -1215,7 +1239,7 @@ fn block_animate_tick( } Animate::BubbleColumn { drag } => { if drag { - add(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]); + add_visible(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]); let r = engine.random(); if next_int(r, 200) == 0 { let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15); @@ -1228,7 +1252,7 @@ fn block_animate_tick( ); } } else { - add( + add_visible( engine, T::BubbleColumnUp, [fx + 0.5, fy, fz + 0.5], @@ -1240,7 +1264,7 @@ fn block_animate_tick( fy + f64::from(r.next_float()), fz + f64::from(r.next_float()), ]; - add(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]); + add_visible(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]); let r = engine.random(); if next_int(r, 200) == 0 { let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15); @@ -1318,6 +1342,91 @@ fn block_animate_tick( } } } +/// `AmbientLeavesBlockSoundPlayer.playAmbientLeavesSounds` for the poplar leaves: +/// one log and three leaves of the same kind around the block. +fn leaves_ambient_sound( + tables: &AnimateTables, + engine: &mut ParticleEngine, + ctx: &AnimateContext, + state: BlockStateId, + pos: [i32; 3], +) { + if next_int(engine.random(), 300) != 0 { + return; + } + let Some(name) = ctx.registry.state(state).map(|s| &s.name) else { + return; + }; + let (mut logs, mut leaves) = (0, 0); + for d in [[0, -1], [1, 0], [0, 1], [-1, 0]] { + let neighbor = ctx.state([pos[0] + d[0], pos[1], pos[2] + d[1]]); + if tables + .poplar_leaf_logs + .get(neighbor.0 as usize) + .copied() + .unwrap_or(false) + { + logs += 1; + } + if ctx + .registry + .state(neighbor) + .is_some_and(|s| &s.name == name) + { + leaves += 1; + } + if logs == 1 && leaves == 3 { + let p = pos.map(f64::from); + sound(engine, "minecraft:block.poplar_leaves.ambient", p, 1.0, 1.0); + return; + } + } +} +/// `AmbientDesertBlockSoundsPlayer.shouldPlayAmbientSandSound`: sand in the +/// surface column eight blocks away on all four sides. +fn sand_sound_nearby(tables: &AnimateTables, ctx: &AnimateContext, pos: [i32; 3]) -> bool { + let is_sand = |p: [i32; 3]| { + tables + .desert_sand_sounds + .get(ctx.state(p).0 as usize) + .copied() + .unwrap_or(false) + }; + let (mut found, mut checked) = (0, 0); + for d in [[0, -8], [8, 0], [0, 8], [-8, 0]] { + let (x, z) = (pos[0] + d[0], pos[2] + d[1]); + // columnContainsTriggeringBlock. + let surface = ctx.world.world_surface(x, z, |s| ctx.facts.is_air(s)) - 1; + let matches = if (surface - pos[1]).abs() > 5 { + let mut y = pos[1] + 6; + let mut above_air = ctx.is_air([x, y, z]); + y -= 1; + let mut hit = false; + for _ in 0..10 { + if above_air && is_sand([x, y, z]) { + hit = true; + break; + } + above_air = ctx.is_air([x, y, z]); + y -= 1; + } + hit + } else { + ctx.is_air([x, surface + 1, z]) && is_sand([x, surface, z]) + }; + if matches { + found += 1; + if found > 3 { + return true; + } + } + checked += 1; + if 4 - checked + found < 3 { + return false; + } + } + false +} /// `AbstractCandleBlock.addParticlesAndSound`. fn candle(engine: &mut ParticleEngine, p: [f64; 3]) { let r = engine.random(); diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index db063e3e3..514326e66 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -149,6 +149,8 @@ pub fn draw_part( layer: 0, color, light, + + glint_uv: [0.0, 0.0], }); } } @@ -650,6 +652,8 @@ fn draw_text(scene: &Scene, call: &TextCall, out: &mut Vec) { layer: 0, color: c, light: call.light, + + glint_uv: [0.0, 0.0], }); } } @@ -1717,6 +1721,8 @@ impl BeamPart { layer: 6, color, light: self.wrap, + + glint_uv: [0.0, 0.0], }); } } @@ -1787,6 +1793,7 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec) layer, color: 0, light: 0, + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/breaking.rs b/crates/horizon-client/src/breaking.rs index 84eedae75..df6d0f33b 100644 --- a/crates/horizon-client/src/breaking.rs +++ b/crates/horizon-client/src/breaking.rs @@ -49,6 +49,8 @@ pub fn geometry( color: 0xffff_ffff, light: stage_light(stage), normal: [0; 4], + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/brewing.rs b/crates/horizon-client/src/brewing.rs index cdd988a7a..b3cda5f90 100644 --- a/crates/horizon-client/src/brewing.rs +++ b/crates/horizon-client/src/brewing.rs @@ -7,257 +7,12 @@ use crate::{ items::{ItemStack, Items}, }; use serde_json::Value; -use std::{ - collections::{HashMap, HashSet}, - fs, - path::Path, - sync::{Arc, OnceLock}, -}; +use std::{collections::HashSet, fs, path::Path, sync::Arc}; -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Category { - Beneficial, - Harmful, - Neutral, -} -/// A `MobEffect`: id (without namespace), colour, category, instantaneous. -#[derive(Clone, Copy, Debug)] -pub struct EffectDef { - pub id: &'static str, - pub color: u32, - pub category: Category, - pub instant: bool, -} -const fn fx(id: &'static str, color: u32, category: Category) -> EffectDef { - EffectDef { - id, - color, - category, - instant: false, - } -} -use Category::{Beneficial as B, Harmful as H, Neutral as N}; -/// `MobEffects` in registration order. -pub const EFFECTS: &[EffectDef] = &[ - fx("speed", 3402751, B), - fx("slowness", 9154528, H), - fx("haste", 14270531, B), - fx("mining_fatigue", 4866583, H), - fx("strength", 16762624, B), - EffectDef { - id: "instant_health", - color: 16262179, - category: B, - instant: true, - }, - EffectDef { - id: "instant_damage", - color: 11101546, - category: H, - instant: true, - }, - fx("jump_boost", 16646020, B), - fx("nausea", 5578058, H), - fx("regeneration", 13458603, B), - fx("resistance", 9520880, B), - fx("fire_resistance", 16750848, B), - fx("water_breathing", 10017472, B), - fx("invisibility", 16185078, B), - fx("blindness", 2039587, H), - fx("night_vision", 12779366, B), - fx("hunger", 5797459, H), - fx("weakness", 4738376, H), - fx("poison", 8889187, H), - fx("wither", 7561558, H), - fx("health_boost", 16284963, B), - fx("absorption", 2445989, B), - EffectDef { - id: "saturation", - color: 16262179, - category: B, - instant: true, - }, - fx("glowing", 9740385, N), - fx("levitation", 13565951, H), - fx("luck", 5882118, B), - fx("unluck", 12624973, H), - fx("slow_falling", 15978425, B), - fx("conduit_power", 1950417, B), - fx("dolphins_grace", 8954814, B), - fx("bad_omen", 745784, N), - fx("hero_of_the_village", 4521796, B), - fx("darkness", 2696993, H), - fx("trial_omen", 1484454, N), - fx("raid_omen", 14565464, N), - fx("wind_charged", 12438015, H), - fx("weaving", 7891290, H), - fx("oozing", 10092451, H), - fx("infested", 9214860, H), - fx("breath_of_the_nautilus", 65518, B), -]; -pub fn effect(id: &str) -> Option<&'static EffectDef> { - let id = id.trim_start_matches("minecraft:"); - EFFECTS.iter().find(|e| e.id == id) -} -/// Namespaced effect ids for mob effect storage. -pub fn namespaced(id: &'static str) -> &'static str { - static IDS: OnceLock> = OnceLock::new(); - IDS.get_or_init(|| { - EFFECTS - .iter() - .map(|e| { - ( - e.id, - &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()), - ) - }) - .collect() - }) - .get(id) - .copied() - .unwrap_or(id) -} -/// A `Potion`: id, name suffix (`item.minecraft.potion.effect.`) and -/// effects as (effect, duration ticks, amplifier). -#[derive(Clone, Copy, Debug)] -pub struct PotionDef { - pub id: &'static str, - pub name: &'static str, - pub effects: &'static [(&'static str, i32, i32)], -} -const fn p( - id: &'static str, - name: &'static str, - effects: &'static [(&'static str, i32, i32)], -) -> PotionDef { - PotionDef { id, name, effects } -} -/// `Potions` in registration order. -pub const POTIONS: &[PotionDef] = &[ - p("water", "water", &[]), - p("mundane", "mundane", &[]), - p("thick", "thick", &[]), - p("awkward", "awkward", &[]), - p("night_vision", "night_vision", &[("night_vision", 3600, 0)]), - p( - "long_night_vision", - "night_vision", - &[("night_vision", 9600, 0)], - ), - p("invisibility", "invisibility", &[("invisibility", 3600, 0)]), - p( - "long_invisibility", - "invisibility", - &[("invisibility", 9600, 0)], - ), - p("leaping", "leaping", &[("jump_boost", 3600, 0)]), - p("long_leaping", "leaping", &[("jump_boost", 9600, 0)]), - p("strong_leaping", "leaping", &[("jump_boost", 1800, 1)]), - p( - "fire_resistance", - "fire_resistance", - &[("fire_resistance", 3600, 0)], - ), - p( - "long_fire_resistance", - "fire_resistance", - &[("fire_resistance", 9600, 0)], - ), - p("swiftness", "swiftness", &[("speed", 3600, 0)]), - p("long_swiftness", "swiftness", &[("speed", 9600, 0)]), - p("strong_swiftness", "swiftness", &[("speed", 1800, 1)]), - p("slowness", "slowness", &[("slowness", 1800, 0)]), - p("long_slowness", "slowness", &[("slowness", 4800, 0)]), - p("strong_slowness", "slowness", &[("slowness", 400, 3)]), - p( - "turtle_master", - "turtle_master", - &[("slowness", 400, 3), ("resistance", 400, 2)], - ), - p( - "long_turtle_master", - "turtle_master", - &[("slowness", 800, 3), ("resistance", 800, 2)], - ), - p( - "strong_turtle_master", - "turtle_master", - &[("slowness", 400, 5), ("resistance", 400, 3)], - ), - p( - "water_breathing", - "water_breathing", - &[("water_breathing", 3600, 0)], - ), - p( - "long_water_breathing", - "water_breathing", - &[("water_breathing", 9600, 0)], - ), - p("healing", "healing", &[("instant_health", 1, 0)]), - p("strong_healing", "healing", &[("instant_health", 1, 1)]), - p("harming", "harming", &[("instant_damage", 1, 0)]), - p("strong_harming", "harming", &[("instant_damage", 1, 1)]), - p("poison", "poison", &[("poison", 900, 0)]), - p("long_poison", "poison", &[("poison", 1800, 0)]), - p("strong_poison", "poison", &[("poison", 432, 1)]), - p("regeneration", "regeneration", &[("regeneration", 900, 0)]), - p( - "long_regeneration", - "regeneration", - &[("regeneration", 1800, 0)], - ), - p( - "strong_regeneration", - "regeneration", - &[("regeneration", 450, 1)], - ), - p("strength", "strength", &[("strength", 3600, 0)]), - p("long_strength", "strength", &[("strength", 9600, 0)]), - p("strong_strength", "strength", &[("strength", 1800, 1)]), - p("weakness", "weakness", &[("weakness", 1800, 0)]), - p("long_weakness", "weakness", &[("weakness", 4800, 0)]), - p("luck", "luck", &[("luck", 6000, 0)]), - p("slow_falling", "slow_falling", &[("slow_falling", 1800, 0)]), - p( - "long_slow_falling", - "slow_falling", - &[("slow_falling", 4800, 0)], - ), - p("wind_charged", "wind_charged", &[("wind_charged", 3600, 0)]), - p("weaving", "weaving", &[("weaving", 3600, 0)]), - p("oozing", "oozing", &[("oozing", 3600, 0)]), - p("infested", "infested", &[("infested", 3600, 0)]), -]; -pub fn potion(id: &str) -> Option<&'static PotionDef> { - let id = id.trim_start_matches("minecraft:"); - POTIONS.iter().find(|p| p.id == id) -} -/// `PotionContents.BASE_POTION_COLOR` (ARGB -13083194) as RGB. -pub const BASE_POTION_COLOR: u32 = 0x385DC6; -/// `PotionContents.getColor`: amplifier-weighted mix of visible effect colours. -pub fn potion_color(id: Option<&str>) -> u32 { - let Some(def) = id.and_then(potion) else { - return BASE_POTION_COLOR; - }; - let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32); - for (e, _, amp) in def.effects { - let Some(e) = effect(e) else { continue }; - let w = *amp as u32 + 1; - r += w * (e.color >> 16 & 255); - g += w * (e.color >> 8 & 255); - b += w * (e.color & 255); - total += w; - } - match ( - r.checked_div(total), - g.checked_div(total), - b.checked_div(total), - ) { - (Some(r), Some(g), Some(b)) => (r << 16) | (g << 8) | b, - _ => BASE_POTION_COLOR, - } -} +pub use horizon_client_core::potions::{ + BASE_POTION_COLOR, Category, EFFECTS, EffectDef, POTIONS, PotionDef, effect, namespaced, + potion, potion_color, +}; /// `MobEffectUtil.formatDuration` at 20 TPS: m:ss or h:mm:ss. pub fn format_duration(ticks: i32) -> String { let secs = ticks / 20; diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs index f3df1ea14..b0dd377c7 100644 --- a/crates/horizon-client/src/chunk.rs +++ b/crates/horizon-client/src/chunk.rs @@ -310,6 +310,76 @@ impl Chunk { } } +/// A proto chunk saved before it became final. Decoration writes into a +/// chunk's neighbours, and decorated chunks wait for theirs, so the chunks +/// past the finished ones hold writes that generating them again would lose +/// (whole structure pieces, trees, ores). Vanilla saves its proto chunks too. +pub struct SavedProto { + /// Blocks, scheduled ticks (in `saved`) and post-processing marks. + pub column: Chunk, + /// Decorated itself (`features`), not only written to by its neighbours + /// (`terrain`). + pub decorated: bool, + /// Block entity data in placement order, with `x`, `y` and `z`. + pub block_entities: Vec, + /// Entities placed by structures, with absolute `Pos`. + pub entities: Vec, +} + +/// A container's loot table and what Horizon rolled from it. Vanilla keeps +/// `LootTable` and `LootTableSeed` until the container is first opened; +/// Horizon rolls when it generates or loads the chunk, and saves the table +/// again while the container still holds exactly the rolled items. +#[derive(Clone, Debug, PartialEq)] +pub struct RolledLoot { + pub pos: (i32, i32, i32), + pub table: String, + /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable). + pub seed: Option, + /// The rolled `Items`. + pub items: Tag, +} +impl RolledLoot { + /// Puts the loot table back in place of `Items` while they are still the + /// roll; false once the container holds anything else. + pub fn restore(&self, map: &mut Compound) -> bool { + if map.get(&"Items".into()) != Some(&self.items) { + return false; + } + map.remove(&"Items".into()); + map.insert("LootTable".into(), Tag::String(self.table.as_str().into())); + if let Some(seed) = self.seed.filter(|s| *s != 0) { + map.insert("LootTableSeed".into(), Tag::Long(seed)); + } + true + } +} + +/// Save data loaded with a chunk that Horizon keeps but does not simulate. +#[derive(Clone, Debug, Default)] +pub struct ChunkExtras { + /// Chunk root keys written back as loaded (structures, PostProcessing, + /// InhabitedTime, blending data, ...). + pub root: Compound, + /// Block entities Horizon does not model. + pub block_entities: Vec, + /// The NBT of the modelled block entities as loaded, to restore the fields and + /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`). + pub block_entity_sources: Vec<((i32, i32, i32), Tag)>, + /// Every saved block entity's position in the order of the save's list, + /// the order `SerializableChunkData` puts them in the chunk's maps. + pub block_entity_order: Vec<(i32, i32, i32)>, + /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the + /// save time. Registered with the level's tick scheduler on arrival and + /// replaced with the scheduler's pending ticks when saving. + pub block_ticks: Vec, + pub fluid_ticks: Vec, + /// Game time written as `LastUpdate`. + pub last_update: i64, + /// Containers still holding their loot table's roll. + pub rolled_loot: Vec, +} + #[cfg(test)] mod tests { use super::*; @@ -433,57 +503,3 @@ mod tests { } } } - -/// A container's loot table and what Horizon rolled from it. Vanilla keeps -/// `LootTable` and `LootTableSeed` until the container is first opened; -/// Horizon rolls when it generates or loads the chunk, and saves the table -/// again while the container still holds exactly the rolled items. -#[derive(Clone, Debug, PartialEq)] -pub struct RolledLoot { - pub pos: (i32, i32, i32), - pub table: String, - /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable). - pub seed: Option, - /// The rolled `Items`. - pub items: Tag, -} -impl RolledLoot { - /// Puts the loot table back in place of `Items` while they are still the - /// roll; false once the container holds anything else. - pub fn restore(&self, map: &mut Compound) -> bool { - if map.get(&"Items".into()) != Some(&self.items) { - return false; - } - map.remove(&"Items".into()); - map.insert("LootTable".into(), Tag::String(self.table.as_str().into())); - if let Some(seed) = self.seed.filter(|s| *s != 0) { - map.insert("LootTableSeed".into(), Tag::Long(seed)); - } - true - } -} - -/// Save data loaded with a chunk that Horizon keeps but does not simulate. -#[derive(Clone, Debug, Default)] -pub struct ChunkExtras { - /// Chunk root keys written back as loaded (structures, PostProcessing, - /// InhabitedTime, blending data, ...). - pub root: Compound, - /// Block entities Horizon does not model. - pub block_entities: Vec, - /// The NBT of the modelled block entities as loaded, to restore the fields and - /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`). - pub block_entity_sources: Vec<((i32, i32, i32), Tag)>, - /// Every saved block entity's position in the order of the save's list, - /// the order `SerializableChunkData` puts them in the chunk's maps. - pub block_entity_order: Vec<(i32, i32, i32)>, - /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the - /// save time. Registered with the level's tick scheduler on arrival and - /// replaced with the scheduler's pending ticks when saving. - pub block_ticks: Vec, - pub fluid_ticks: Vec, - /// Game time written as `LastUpdate`. - pub last_update: i64, - /// Containers still holding their loot table's roll. - pub rolled_loot: Vec, -} diff --git a/crates/horizon-client/src/clouds.rs b/crates/horizon-client/src/clouds.rs index 70f29c132..5e9bb731a 100644 --- a/crates/horizon-client/src/clouds.rs +++ b/crates/horizon-client/src/clouds.rs @@ -179,6 +179,8 @@ impl Mesh { layer: 4, color: u32::MAX, light: shade, + + glint_uv: [0.0, 0.0], }); } }; diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index c449376f6..ed7d09a60 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -98,10 +98,19 @@ pub enum BlockEntity { Campfire(Box), /// `SkullBlockEntity` of every skull and head block. Skull(Skull), + /// `TheEndGatewayBlockEntity`: its age and configured destination. + EndGateway(EndGateway), /// `DaylightDetectorBlockEntity`: no data, only the ticker /// (`DaylightDetectorBlock.tickEntity`). DaylightDetector, } +/// `TheEndGatewayBlockEntity`. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct EndGateway { + pub age: i64, + pub exit_portal: Option<[i32; 3]>, + pub exact_teleport: bool, +} /// `CampfireBlockEntity`: four cooking slots, each with its /// `cookingProgress` and `cookingTime` (the recipe's). #[derive(Clone, Debug, Default, PartialEq)] @@ -380,6 +389,9 @@ impl BlockEntity { if is_skull(name) { return Some(Self::Skull(Skull::default())); } + if name == "minecraft:end_gateway" { + return Some(Self::EndGateway(EndGateway::default())); + } if name == "minecraft:daylight_detector" { return Some(Self::DaylightDetector); } @@ -432,6 +444,7 @@ impl BlockEntity { Self::Beehive(_) => "minecraft:beehive", Self::CommandBlock(_) => "minecraft:command_block", Self::Skull(_) => "minecraft:skull", + Self::EndGateway(_) => "minecraft:end_gateway", Self::DaylightDetector => "minecraft:daylight_detector", Self::Campfire(_) => "minecraft:campfire", } @@ -450,6 +463,7 @@ impl BlockEntity { | Self::Vault(_) | Self::Beehive(_) | Self::CommandBlock(_) + | Self::EndGateway(_) | Self::Skull(_) | Self::DaylightDetector => Vec::new(), Self::Lectern(l) => l.book.iter().cloned().collect(), @@ -470,6 +484,7 @@ impl BlockEntity { | Self::Lectern(_) | Self::Sculk(_) | Self::Banner(_) + | Self::EndGateway(_) | Self::Skull(_) | Self::DaylightDetector => &[], Self::Crafter(c) => &c.items, @@ -494,6 +509,7 @@ impl BlockEntity { | Self::Lectern(_) | Self::Sculk(_) | Self::Banner(_) + | Self::EndGateway(_) | Self::Skull(_) | Self::DaylightDetector => &mut [], Self::Crafter(c) => &mut c.items, diff --git a/crates/horizon-client/src/effects.rs b/crates/horizon-client/src/effects.rs index 387de78b6..9511fd112 100644 --- a/crates/horizon-client/src/effects.rs +++ b/crates/horizon-client/src/effects.rs @@ -2,7 +2,7 @@ //! add/update with hidden effects, per-tick application of the periodic //! effects (regeneration, poison, wither, hunger, saturation, instant //! effects), and the derived flags the movement and damage code read. -use crate::brewing; +use horizon_client_core::potions; #[derive(Clone, Debug, PartialEq)] pub struct EffectInstance { @@ -183,7 +183,7 @@ impl PlayerEffects { pub fn from_saved(saved: &[(String, i32, i32, bool, bool)]) -> Self { let mut effects = Self::default(); for (id, duration, amplifier, ambient, particles) in saved { - if let Some(def) = brewing::effect(id) { + if let Some(def) = potions::effect(id) { let mut e = EffectInstance::new(def.id, *duration, *amplifier); e.ambient = *ambient; e.visible = *particles; @@ -306,10 +306,10 @@ impl PlayerEffects { ) -> (Vec, Vec) { let mut lasting = Vec::new(); let mut now = Vec::new(); - if let Some(def) = potion.and_then(brewing::potion) { + if let Some(def) = potion.and_then(potions::potion) { for (id, duration, amp) in def.effects { - let id = brewing::effect(id).map_or("speed", |e| e.id); - if brewing::effect(id).is_some_and(|e| e.instant) { + let id = potions::effect(id).map_or("speed", |e| e.id); + if potions::effect(id).is_some_and(|e| e.instant) { now.extend(instant(id, *amp, 1.0)); } else { // withScaledDuration: max(floor(d * scale), 1). diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index e71aa1ad8..e90b9dd66 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -14,7 +14,8 @@ struct Globals { // Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png. end_portal_sprites: array, 2>, // x: vanilla's GameTime ((game time % 24000 + partial tick) / 24000) - // y: Nether cardinal lighting, z: how many dynamic_lights are set. + // y: Nether cardinal lighting, z: how many dynamic_lights are set, + // w: the glint scroll clock (`Glint::scroll_ticks`). time: vec4, crumbling_sprite: vec4, // Selection outline parameters (read by terrain.wgsl). @@ -27,6 +28,12 @@ struct Globals { @group(0) @binding(2) var atlas_sampler: sampler; @group(0) @binding(3) var lightmap: texture_2d; @group(0) @binding(4) var lightmap_sampler: sampler; +// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler). +@group(0) @binding(5) var glint_tex: texture_2d; +@group(0) @binding(6) var glint_sampler: sampler; +// The armour layers' GlintSampler: vanilla samples enchanted_glint_armor with +// the same repeating, linearly filtered sampler as the item glint. +@group(0) @binding(7) var glint_armor_tex: texture_2d; struct Out { @builtin(position) clip: vec4, @location(0) uv: vec2, @@ -44,6 +51,9 @@ struct Out { // entity.vsh's lightMapColor, multiplied in after the overlay. @location(9) light_color: vec4, @location(10) @interpolate(flat) weather_rect: vec4, + // The `GLINT_TEXTURING` sample for overlay 7 (item foil), or the model UV + // `ARMOR_ENTITY_GLINT_TEXTURING` scrolls for overlay 13 (armour). + @location(11) glint_uv: vec2, } // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed. fn entity_light(normal: vec3, nether: bool) -> f32 { @@ -103,18 +113,23 @@ fn entity_vertex(position: vec3, uv: vec2, out.spherical = select(length(position), 0.0, overlay >= 2u && overlay <= 4u); out.cylindrical = select(max(length(position.xz), abs(position.y)), 0.0, overlay >= 2u && overlay <= 4u); out.overlay = overlay; + out.glint_uv = vec2(0.0); if overlay == 4u { out.spherical = length(position); } return out; } @vertex fn vs_entity(@location(0) position: vec3, @location(1) uv: vec2, - @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, @location(5) normal: vec4) -> Out { - return entity_vertex(position, uv, overlay, color, light, normal); + @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, + @location(5) normal: vec4, @location(6) glint_uv: vec2) -> Out { + var out = entity_vertex(position, uv, overlay, color, light, normal); + out.glint_uv = glint_uv; + return out; } // Retained bolt-local geometry, translated using the same f64 camera // subtraction as the former CPU path before adding each local f32 position. +// The bolt offset is instance attribute 7: 6 is the entity vertex's glint UV. @vertex fn vs_lightning(@location(0) position: vec3, @location(1) uv: vec2, @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, @location(5) normal: vec4, - @location(6) offset: vec3) -> Out { + @location(7) offset: vec3) -> Out { return entity_vertex(offset + position, uv, overlay, color, light, normal); } struct CloudInfo { @@ -166,6 +181,27 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 { if d >= end { return 1.0; } return (d - start) / (end - start); } +// TextureTransform.setupGlintTexturing(0.16), ARMOR_ENTITY_GLINT_TEXTURING. +// globals.time.w is (Util.getMillis() * glintSpeed * 8) modulo 330000, the +// common period of both offsets. +fn armor_glint_uv(model: vec2) -> vec2 { + let ticks = globals.time.w; + let offset0 = (ticks % 110000.0) / 110000.0; + let offset1 = (ticks % 30000.0) / 30000.0; + let angle = 0.17453292; + let c = cos(angle); + let s = sin(angle); + let scaled = model * 0.16; + return vec2(scaled.x * c - scaled.y * s - offset0, + scaled.x * s + scaled.y * c + offset1); +} +// RenderPipelines.GLINT: the source colour is scaled by itself, so `GlintAlpha` +// is squared along with the sample. +fn glint_over(color: vec4, glint: vec4) -> vec4 { + let alpha = globals.fog_ends.w; + let g = alpha * glint; + return vec4(color.rgb + g.rgb * g.rgb, max(color.a, alpha)); +} // CRUMBLING_UV_BEGIN fn crumbling_uv(uv: vec2, packed_origin: vec2, sprite_size: vec2, dimensions: vec2) -> vec2 { let size = vec2(dimensions); @@ -204,15 +240,16 @@ fn crumbling_uv(uv: vec2, packed_origin: vec2, sprite_size: vec2, color = vec4(mix(in.overlay_color.rgb, color.rgb, in.overlay_color.a), color.a); color *= in.light_color; if in.overlay == 7u || in.overlay == 8u || in.overlay == 33u { - // Enchantment glint (overlay 7, 8 with the hurt tint): the purple - // enchanted_glint sheen drifting diagonally over the item's shape. - let px = in.uv * vec2(textureDimensions(atlas)); - let t = globals.misc.y * 0.05; - let band = sin((px.x + px.y) * 0.9 - t * 6.0) * 0.5 + 0.5; - let band2 = sin((px.x - px.y) * 0.6 + t * 4.0) * 0.5 + 0.5; - let shimmer = pow(band * 0.6 + band2 * 0.4, 2.0); - let glint = vec3(0.50, 0.25, 0.80) * (0.25 + 0.75 * shimmer); - color = vec4(min(color.rgb + glint * 0.6, vec3(1.0)), color.a); + // 33: a translucent item with the glint. + // Enchantment glint: item.fsh's GLINT path, sampled from + // enchanted_glint_item at the `GLINT_TEXTURING` UV. + color = glint_over(color, textureSample(glint_tex, glint_sampler, in.glint_uv)); + } else if in.overlay == 13u { + // Enchanted armour: enchanted_glint_armor at the scrolling model UV. + color = glint_over( + color, + textureSample(glint_armor_tex, glint_sampler, armor_glint_uv(in.glint_uv)), + ); } let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y), linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)); @@ -244,6 +281,20 @@ fn celestial_color(in: Out) -> vec4 { return vec4(added, smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b)))); } +// RenderPipelines.ENERGY_SWIRL (entity.fsh with EMISSIVE and NO_OVERLAY): the sprite, scrolled by +// the UV and repeated within itself, times the layer colour 0xFF808080, unlit; the pipeline adds +// it to the frame. The light bytes carry the sprite's origin and the colour bytes its size, both +// as breaking::stage_light packs them. +@fragment fn fs_energy_swirl(in: Out) -> @location(0) vec4 { + let bytes = round(in.color * 255.0); + let size = vec2(bytes.x + bytes.y * 256.0, bytes.z + bytes.w * 256.0) / 65535.0; + let color = textureSample(atlas, atlas_sampler, crumbling_uv(in.uv, in.wrap, size, textureDimensions(atlas))); + if color.a < 0.1 { discard; } + let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y), + linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)); + return vec4(mix(color.rgb * (128.0 / 255.0), globals.fog_color.rgb, f * globals.fog_color.a), color.a); +} + // RenderPipelines.WATER_MASK: depth only (the pipeline masks the colour off). @fragment fn fs_water_mask() -> @location(0) vec4 { return vec4(0.0); diff --git a/crates/horizon-client/src/entity_culling.rs b/crates/horizon-client/src/entity_culling.rs index 16de17465..0c309041a 100644 --- a/crates/horizon-client/src/entity_culling.rs +++ b/crates/horizon-client/src/entity_culling.rs @@ -186,6 +186,8 @@ mod tests { color: u32::MAX, light: 0, normal: [0; 4], + + glint_uv: [0.0, 0.0], }; let prior = vertex([0.0; 3]); let body = [vertex([8.0, -1.0, -1.0]), vertex([10.0, 1.0, 1.0])]; diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index b2d1401da..5c3d41ddc 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -577,6 +577,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.insert("anger".into(), Tag::compound(Vec::<(&str, Tag)>::new())); } } + // Armadillo.addAdditionalSaveData: the time left to the next scute. + "minecraft:armadillo" => { + map.insert("scute_time".into(), Tag::Int(m.extra.egg_time)); + } "minecraft:ravager" => { map.insert("AttackTick".into(), Tag::Int(m.extra.counter)); map.insert("StunTick".into(), Tag::Int(m.extra.counter2)); @@ -1198,6 +1202,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - st.vibration = crate::sculk::Data::from_nbt(listener); } } + // Armadillo.readAdditionalSaveData: keeps the constructor's time when absent. + if m.species() == crate::mobs::Species::Armadillo + && let Some(t) = number(tag.get("scute_time")) + { + m.extra.egg_time = t as i32; + } if m.species() == crate::mobs::Species::Ravager { m.extra.counter = number(tag.get("AttackTick")).unwrap_or(0) as i32; m.extra.counter2 = number(tag.get("StunTick")).unwrap_or(0) as i32; diff --git a/crates/horizon-client/src/fire_render.rs b/crates/horizon-client/src/fire_render.rs index c3a9f6a92..98eff6f9d 100644 --- a/crates/horizon-client/src/fire_render.rs +++ b/crates/horizon-client/src/fire_render.rs @@ -48,6 +48,8 @@ pub fn flames( color: 0xffff_ffff, light: 0xf000 | (u32::from(scene_light >> 4) * 16), normal: [0; 4], + + glint_uv: [0.0, 0.0], }); } remaining -= 0.45; diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 2599aaf5b..2c3eeed39 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1283,6 +1283,8 @@ struct Game<'a> { pending_pack_reload: bool, /// A server's resource packs (game/server_packs.rs). server_packs: server_packs::ServerPackState, + /// The link a chat click asks to open (`ConfirmLinkScreen`). + link_prompt: Option, dialogs: dialogs::DialogState, world_renderer_ready: bool, collision: &'a BlockCollisionRegistry<'a>, @@ -1527,6 +1529,8 @@ struct Game<'a> { /// `ClientAvatarState`: walked distance and view bob. avatar: horizon_client::camera::AvatarBob, flash: u32, + /// `ClientLevel.rainSoundTime`: ticks of rain since the last rain sound. + rain_sound_time: i32, /// Bolts that struck here and sky flashes they made, in total (`status`). lightning_seen: [u32; 2], /// The head of the bed while sleeping; the visual timer also survives waking. @@ -1609,6 +1613,12 @@ struct Game<'a> { /// Map textures waiting for the next HUD batch to upload them. map_patches: Vec, text_displays: std::collections::HashMap, + /// The fence knots a server tracks to this client, by entity id, at their + /// block (`LeashFenceKnotEntity`). + remote_knots: HashMap, + /// The entity ids a hosted server gives the knots its mobs hang on, by + /// block, while a lead is tied there. + knot_ids: HashMap<[i32; 3], u32>, text_display_vertices: usize, /// Player skin downloads, and which skin each atlas skin slot holds /// (least recently shown first). @@ -2517,6 +2527,15 @@ impl Game<'_> { no_physics, &self.res.motion().fluids, ); + // Entity.applyEffectsFromBlocks: bubble columns lift or drag the item. + horizon_client::motion::bubble_column_push( + &self.world, + self.pack.assets.registry, + self.res.facts(), + self.collision, + item.bounds(), + &mut item.velocity, + ); cells.moved(i, item.previous, item.position); // ItemEntity.tick: merge every 2 ticks while moving between // blocks, every 40 otherwise, before the lifetime check. @@ -2787,9 +2806,13 @@ impl Game<'_> { self.process_level_events() } fn attack_block(&mut self, pos: [i32; 3]) -> Result<()> { - self.with_level(|b, level, ticks| { - b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2])); + let note = self.with_level(|b, level, ticks| { + b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2])) }); + // NoteBlock.attack awards the statistic. + if note { + self.stats.custom("play_noteblock", 1); + } self.process_level_events() } /// Track which chunks are ticking (Ticks needs chunk load/unload). @@ -3459,15 +3482,9 @@ impl Game<'_> { self.open_ender_chest(key); // EnderChestBlock.useWithoutItem self.stats.custom("open_enderchest", 1); - self.container_opener_event(key, true); - let at = [ - f64::from(key.0) + 0.5, - f64::from(key.1) + 0.5, - f64::from(key.2) + 0.5, - ]; - let pitch = self.world.random.next_float() * 0.1 + 0.9; - self.audio - .play("minecraft:block.ender_chest.open", Some(at), 0.5, pitch); + if self.container_opener_event(key, true) { + self.container_edge_sound(key, true); + } } else if &*name == "minecraft:beacon" && self.open_station(pos, &name) { self.world.block_entities.get_or_insert_with(key, || { BlockEntity::for_block(&name).unwrap_or(BlockEntity::Chest(Vec::new())) @@ -3483,7 +3500,7 @@ impl Game<'_> { ]; self.resolve_container_maps(key, centre); self.container = Some(key); - self.container_opener_event(key, true); + let first = self.container_opener_event(key, true); self.post_block_game_event( "minecraft:container_open", [key.0, key.1, key.2], @@ -3507,26 +3524,8 @@ impl Game<'_> { if self.guarded_by_piglins(&name) { self.anger_piglins(true); } - let sound = if storage::is_shulker_box(&name) { - Some("minecraft:block.shulker_box.open") - } else if name.contains("chest") { - Some("minecraft:block.chest.open") - } else if &*name == "minecraft:barrel" { - Some("minecraft:block.barrel.open") - } else { - None - }; - if let Some(sound) = sound { - self.audio.play( - sound, - Some([ - f64::from(key.0) + 0.5, - f64::from(key.1) + 0.5, - f64::from(key.2) + 0.5, - ]), - 0.5, - 1.0, - ); + if first { + self.container_edge_sound(key, true); } } else if self.open_station(pos, &name) { // Workstation menus: game/stations.rs. @@ -4010,6 +4009,10 @@ impl Game<'_> { self.swing_arm(); return Ok(true); } + if self.use_beehive(hit.pos, held.as_ref())? { + self.swing_arm(); + return Ok(true); + } if self.use_campfire_douse(hit.pos, held.as_ref())? { self.swing_arm(); return Ok(true); @@ -4366,6 +4369,8 @@ impl Game<'_> { self.release_used_item(&stack, ticks, hand_changed); return; } + // ServerPlayer.updateUsingItem: USING_ITEM every tick of the use. + self.trigger_using_item(&stack); let Some(info) = self.res.items().get(&stack.item).cloned() else { self.using = None; return; @@ -5066,9 +5071,14 @@ impl Game<'_> { if let Some(host) = &self.lan { host.hub.entity_event(host.host_entity, 3, feet); } - self.screen = Screen::Dead; - self.capture(false); - self.ui.death_time = 0; + if self.ui.rules.bool("immediate_respawn") { + // Gui.setScreen: without the death screen the player respawns at once. + self.respawn_player()?; + } else { + self.screen = Screen::Dead; + self.capture(false); + self.ui.death_time = 0; + } } else if dead { // LivingEntity.tickDeath: 20 ticks after dying the player is // removed, and Player.remove's inventoryMenu.removed drops what @@ -5540,6 +5550,7 @@ impl Game<'_> { }; self.draw_dialog(&mut batch); self.draw_pack_prompt(&mut batch); + self.draw_link_prompt(&mut batch); // Gui.extractRenderState: the debug overlay comes after the screen // and the toasts, so it is over everything, menus included. self.draw_debug_overlay(&mut batch, size); @@ -5601,7 +5612,11 @@ impl Game<'_> { let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed()); let strength = self.hand_strength.scale(0.0, self.main_hand_attack_speed()); // The 3D crosshair (F3) takes the 2D one's place. - if self.camera_type.first_person() && !spectator && !self.debug_crosshair() { + // Hud.extractCrosshair: a spectator only sees it over something to open. + if self.camera_type.first_person() + && (!spectator || self.spectator_crosshair()) + && !self.debug_crosshair() + { let attack = (indicator == 1).then_some(strength); let full = attack.is_some_and(|a| { hud_layout::full_attack_indicator(a, delay, self.crosshair_living()) @@ -5858,6 +5873,7 @@ impl Game<'_> { | BlockEntity::Vault(_) | BlockEntity::Beehive(_) | BlockEntity::CommandBlock(_) + | BlockEntity::EndGateway(_) | BlockEntity::Skull(_) | BlockEntity::DaylightDetector | BlockEntity::Campfire(_), @@ -6130,6 +6146,7 @@ impl Game<'_> { | BlockEntity::Vault(_) | BlockEntity::Beehive(_) | BlockEntity::CommandBlock(_) + | BlockEntity::EndGateway(_) | BlockEntity::Skull(_) | BlockEntity::DaylightDetector | BlockEntity::Campfire(_), @@ -6211,41 +6228,15 @@ impl Game<'_> { if let Some(key) = self.container.take() { // A cart's or chest boat's items go back to it. self.close_cart_container(key); - self.container_opener_event(key, false); + let last = self.container_opener_event(key, false); self.post_block_game_event( "minecraft:container_close", [key.0, key.1, key.2], Some(horizon_client::mobs::Who::Player), None, ); - let name = self - .res - .facts() - .get(self.world.block(key.0, key.1, key.2)) - .name - .clone(); - let sound = if storage::is_shulker_box(&name) { - Some("minecraft:block.shulker_box.close") - } else if &*name == "minecraft:ender_chest" { - Some("minecraft:block.ender_chest.close") - } else if name.contains("chest") { - Some("minecraft:block.chest.close") - } else if &*name == "minecraft:barrel" { - Some("minecraft:block.barrel.close") - } else { - None - }; - if let Some(sound) = sound { - self.audio.play( - sound, - Some([ - f64::from(key.0) + 0.5, - f64::from(key.1) + 0.5, - f64::from(key.2) + 0.5, - ]), - 0.5, - 1.0, - ); + if last { + self.container_edge_sound(key, false); } self.world.modified.insert((key.0 >> 4, key.2 >> 4)); } @@ -6765,6 +6756,7 @@ impl Game<'_> { self.player_menu_sound(sound); } let crafted = std::mem::take(&mut menu.crafted); + let brewed = std::mem::take(&mut menu.brewed); let equipped = std::mem::take(&mut menu.equipped); for (i, stack) in after.into_iter().enumerate() { if let Some(g) = game_of[i] { @@ -6780,6 +6772,9 @@ impl Game<'_> { self.player_drop(stack); } self.award_crafted(&crafted); + for stack in &brewed { + self.trigger_brewed_potion(stack); + } if furnace_before > furnace_after && self.remote.is_none() && let (Some(pos), Some(p)) = (self.container, self.player.as_ref()) @@ -7818,6 +7813,8 @@ impl Game<'_> { layer: 0, color, light: packed, + + glint_uv: [0.0, 0.0], }); } } @@ -8276,6 +8273,15 @@ impl Game<'_> { None => horizon_client::mobs::Damage::of(horizon_client::mobs::DamageKind::Generic), }; let landed = self.hurt_by_player(index, amount, source); + if landed { + let victim = self.mob_entity(&self.mobs[index]); + self.player_hit( + &victim, + creatures::damage_type(source.kind, true), + None, + amount, + ); + } if let Some(p) = self.player.as_mut() { if p.attack_log.len() >= 64 { p.attack_log.remove(0); @@ -8369,15 +8375,24 @@ impl Game<'_> { // The hurt or death sound the mob raised (getHurtSound / getDeathSound, // its voice pitch from its own random). let queued = std::mem::take(&mut self.mobs[index].outbox); + let mut infested = false; for event in queued { - if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event { - self.audio - .play(&format!("minecraft:{s}"), Some(at), volume, pitch); - } else { - // Left for the end of the tick. - self.mobs[index].outbox.push(event); + match event { + horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) => { + self.audio + .play(&format!("minecraft:{s}"), Some(at), volume, pitch); + } + horizon_client::mobs::MobEvent::Infested { .. } => infested = true, + other => { + // Left for the end of the tick. + self.mobs[index].outbox.push(other); + } } } + if infested { + let id = self.mobs[index].id; + self.mob_infested(id); + } self.weapon_hit(index); // Player.attack: causeFoodExhaustion(0.1F) only when the hit hurt // (inside `if (wasHurt)`), after damageStatsAndHearts. @@ -8465,6 +8480,8 @@ impl Game<'_> { layer: 2, color, light: 0, + + glint_uv: [0.0, 0.0], }); } }; @@ -10340,40 +10357,7 @@ impl Game<'_> { if self.flash > 0 { self.flash -= 1; } - let (rain, _) = self.world.weather.levels(1.0); - let Some(eye) = self.eye_position() else { - return; - }; - // WeatherEffectRenderer.tickRainParticles: occasional rain sounds. - if rain > 0.0 && self.world.random.next_int_bound(3).unwrap_or(1) < (rain * 3.0) as i32 { - let r = &mut self.world.random; - let (dx, dz) = ( - r.next_int_bound(21).unwrap_or(10) - 10, - r.next_int_bound(21).unwrap_or(10) - 10, - ); - let (x, z) = (eye[0].floor() as i32 + dx, eye[2].floor() as i32 + dz); - let top = self.rain_height(x, z); - if self.precipitation(x, top, z) == Some(false) - && (top - eye[1] as i32).abs() < 10 - && self.world.random.next_int_bound(5).unwrap_or(1) == 0 - { - let above = f64::from(top) > eye[1] + 1.0; - let (name, volume, pitch) = if above { - ("minecraft:weather.rain.above", 0.1, 0.5) - } else { - ("minecraft:weather.rain", 0.2, 1.0) - }; - // The Horizon Weather option off silences the rain too. - if self.settings.horizon.weather { - self.audio.play( - name, - Some([f64::from(x) + 0.5, f64::from(top), f64::from(z) + 0.5]), - volume, - pitch, - ); - } - } - } + // The rain sounds come with the rain splashes (`tick_particles`). } /// WeatherEffectRenderer: rain and snow columns within the weather radius. fn weather_geometry( @@ -11414,6 +11398,8 @@ impl Game<'_> { debug_lines_on_top: &debug_lines_on_top, debug_crosshair: &debug_crosshair, hud: &hud, + glint_alpha: self.settings.file.double("glintStrength") as f32, + glint_ticks: self.glint_ticks(), clouds: (!title && self.dim == Dim::Overworld && horizon_client::clouds::visible(&self.settings.clouds, sky.cloud_color[3])) @@ -12365,6 +12351,11 @@ impl ApplicationHandler for Game<'_> { self.advancements_scroll(scaled(raw_x) as f32, d); } } + WindowEvent::MouseInput { state, button, .. } if self.link_prompt.is_some() => { + if state == ElementState::Pressed && button == MouseButton::Left { + self.link_prompt_click(); + } + } WindowEvent::MouseInput { state, button, .. } if self.server_packs.prompt.is_some() => { @@ -12594,6 +12585,13 @@ impl ApplicationHandler for Game<'_> { } } // ConfirmScreen.keyPressed: Escape answers no. + WindowEvent::KeyboardInput { event, .. } if self.link_prompt.is_some() => { + if event.state == ElementState::Pressed + && event.physical_key == PhysicalKey::Code(KeyCode::Escape) + { + self.answer_link_prompt(false); + } + } WindowEvent::KeyboardInput { event, .. } if self.server_packs.prompt.is_some() => { if event.state == ElementState::Pressed && event.physical_key == PhysicalKey::Code(KeyCode::Escape) @@ -13127,6 +13125,7 @@ impl<'a> Game<'a> { world_loader: None, pending_pack_reload: false, server_packs: Default::default(), + link_prompt: None, dialogs: Default::default(), world_renderer_ready: false, collision: res.collision(), @@ -13294,6 +13293,7 @@ impl<'a> Game<'a> { dragging: false, avatar: Default::default(), flash: 0, + rain_sound_time: 0, lightning_seen: [0; 2], sleeping: None, sleep_timer: 0, @@ -13348,6 +13348,8 @@ impl<'a> Game<'a> { dragon_model: prepared.dragon_model, map_patches: Vec::new(), text_displays: Default::default(), + remote_knots: Default::default(), + knot_ids: Default::default(), text_display_vertices: 0, skin_downloads: RefCell::new(horizon_client::skins::Downloader::new( std::env::current_dir() @@ -14096,6 +14098,12 @@ fn build_renderer( &assets.sprite_mips, &assets.animations, (&atlas.pixels, atlas.width, atlas.height), + (&atlas.glint.0, atlas.glint.1, atlas.glint.2), + ( + &atlas.glint_armor.0, + atlas.glint_armor.1, + atlas.glint_armor.2, + ), (&pack.forcefield.2, pack.forcefield.0), &gui.panorama, prepared, @@ -14122,6 +14130,7 @@ fn loading_renderer( ) -> Result { static FORCEFIELD: [u8; 4] = [0; 4]; static EMPTY_HUD: [u8; 4] = [0, 0, 0, 255]; + static EMPTY_GLINT: [u8; 4] = [0; 4]; let empty_panorama = horizon_client::gfx::panorama::Faces { size: 1, pixels: [0u8; 4].repeat(6), @@ -14132,6 +14141,10 @@ fn loading_renderer( Some(atlas) => (atlas.pixels.as_slice(), atlas.width, atlas.height), None => (EMPTY_HUD.as_slice(), 1, 1), }; + let (glint_pixels, glint_width, glint_height) = match atlas { + Some(atlas) => (atlas.glint.0.as_slice(), atlas.glint.1, atlas.glint.2), + None => (EMPTY_GLINT.as_slice(), 1, 1), + }; // A glyph rasterized into an earlier texture is not in these pixels; the // new texture gets it again when the character is drawn (see // `build_renderer`). @@ -14148,6 +14161,8 @@ fn loading_renderer( &[], &[], (pixels, width, height), + (glint_pixels, glint_width, glint_height), + (glint_pixels, glint_width, glint_height), (&FORCEFIELD[..], 1), panorama, None, @@ -14195,6 +14210,8 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> { debug_lines_on_top: &[], debug_crosshair: &[], hud, + glint_alpha: 0.75, + glint_ticks: 0.0, nether_lighting: false, entities: &[], entity_spans: &[], diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index f7bafd767..912bf7c33 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -9,6 +9,7 @@ use horizon_client::{ text::{self, Style, Text}, toasts::Slide, }; +use horizon_core::geometry::Vec3; use serde_json::Value; use std::{ collections::{BTreeMap, BTreeSet, VecDeque}, @@ -82,6 +83,8 @@ pub(super) struct AdvState { pub(super) quiet: bool, /// The inventory last seen by `inventory_changed`. pub(super) last_inventory: u64, + /// `ServerPlayer.levitationStartPos` and `levitationStartTime`. + pub(super) levitation: Option<([f64; 3], u64)>, /// While the game acts for a network player (`as_guest`): the /// advancements whose progress changed (`progressChanged`), the recipes /// unlocked and the announcements, for their client and everyone's. @@ -180,6 +183,14 @@ impl adv::World for View<'_, '_> { "block" => items.block_tags.get(tag).is_some_and(|t| t.contains(id)), "entity_type" => self.0.res.mob_data().entity_has(tag, id), "worldgen/biome" => self.0.res.mob_data().biome_has(tag, id), + "damage_type" => self + .0 + .res + .stations() + .enchantments + .damage_tags + .get(tag) + .is_some_and(|t| t.contains(id)), _ => false, } } @@ -647,6 +658,28 @@ impl Game<'_> { }; adv::conditions(&c["player"], &ctx, w) }); + // ServerPlayer.onEffectAdded and onEffectsRemoved keep the start of a + // levitation; tick fires LEVITATION while there is one. + let levitating = self + .potions + .effects + .list + .iter() + .any(|e| e.id == "levitation"); + match (levitating, self.adv.levitation) { + (true, None) => { + let at = self + .player + .as_ref() + .map(|p| [p.position.x, p.position.y, p.position.z]); + self.adv.levitation = at.map(|at| (at, self.ticks)); + } + (false, Some(_)) => self.adv.levitation = None, + _ => {} + } + if let Some((start, since)) = self.adv.levitation { + self.trigger_levitation(start, (self.ticks - since) as i64); + } if self.ticks.is_multiple_of(20) { let me = self.player_entity(); self.trigger("minecraft:location", |c, w| { @@ -681,6 +714,123 @@ impl Game<'_> { adv::conditions(&c["player"], &pctx, w) && adv::conditions(&c[&key], &ectx, w) }); } + /// `LevitationTrigger`: how far the player rose from where it started + /// levitating, and for how long. + fn trigger_levitation(&mut self, start: [f64; 3], duration: i64) { + let me = self.player_entity(); + self.trigger("minecraft:levitation", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) + && (c["distance"].is_null() || adv::distance(&c["distance"], start, me.position)) + && adv::range_i(&c["duration"], duration) + }); + } + /// `ServerPlayer.updateUsingItem`: USING_ITEM for the item in use, with + /// what the player looks at (`PlayerPredicate.lookingAt`). + pub(super) fn trigger_using_item(&mut self, stack: &ItemStack) { + if self.remote.is_some() || self.no_player_here() { + return; + } + let mut me = self.player_entity(); + me.looking_at = self.looking_at_entity().map(Box::new); + let it = item_view(stack); + self.trigger("minecraft:using_item", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) && adv::item(&c["item"], &it, w) + }); + } + /// The mob a 100 block ray from the eyes meets first, if no block is in + /// the way (`ProjectileUtil.getEntityHitResult` and `hasLineOfSight`). + fn looking_at_entity(&self) -> Option { + let eye = self.eye_position()?; + let dir = super::view_vector(self.yaw, self.pitch); + let (m, _) = self + .mobs + .iter() + .filter(|m| m.alive()) + .filter_map(|m| Some((m, super::ray_box(eye, dir, 100.0, m.bounds())?))) + .min_by(|a, b| a.1.total_cmp(&b.1))?; + // `LivingEntity.hasLineOfSight`: eye to the target's eye height, + // `ClipContext.Block.COLLIDER`, no fluids, within 128 blocks. + let from = Vec3::new(eye[0], eye[1], eye[2]); + let to = Vec3::new(m.position.x, m.eye_y(), m.position.z); + let world = self.mob_world_base(&[]); + let clear = to.distance(from) <= 128.0 && world.clear_between(from, to, false); + clear.then(|| self.mob_entity(m)) + } + /// `PlayerHurtEntityTrigger`: the player, the damage and the victim. + pub(super) fn trigger_player_hurt_entity( + &mut self, + victim: &EntityView, + damage: &adv::DamageView, + ) { + let me = self.player_entity(); + let (victim, damage) = (victim.clone(), damage.clone()); + self.trigger("minecraft:player_hurt_entity", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + let vctx = adv::Entities { + this: Some(&victim), + ..pctx + }; + adv::conditions(&c["player"], &pctx, w) + && adv::damage(&c["damage"], &damage, w, me.position) + && adv::conditions(&c["entity"], &vctx, w) + }); + } + /// The player's hit on `victim` as `LivingEntity.hurtServer` reports it: + /// `kind` damage of `amount` from `direct` (the player's own hand when + /// `None`), nothing blocked. + pub(super) fn player_hit( + &mut self, + victim: &EntityView, + kind: &str, + direct: Option, + amount: f32, + ) { + let me = self.player_entity(); + self.trigger_player_hurt_entity( + victim, + &adv::DamageView { + kind: kind.to_owned(), + is_direct: direct.is_none(), + direct: direct.or_else(|| Some(me.clone())), + source: Some(me), + original: amount, + actual: amount, + blocked: false, + }, + ); + } + /// `EntityHurtPlayerTrigger`: the player and the damage it took. + pub(super) fn trigger_entity_hurt_player(&mut self, damage: &adv::DamageView) { + let me = self.player_entity(); + let damage = damage.clone(); + self.trigger("minecraft:entity_hurt_player", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) + && adv::damage(&c["damage"], &damage, w, me.position) + }); + } /// A player condition plus one item (`item` key). pub(super) fn trigger_item(&mut self, name: &str, stack: &ItemStack) { let me = self.player_entity(); @@ -708,6 +858,22 @@ impl Game<'_> { let it = item_view(stack); self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w)); } + /// `BrewedPotionTrigger`: the potion contents of a stack taken from a + /// brewing stand. + pub(super) fn trigger_brewed_potion(&mut self, stack: &ItemStack) { + let me = self.player_entity(); + let potion = stack.potion().map(str::to_owned); + self.trigger("minecraft:brewed_potion", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) + && adv::potions(&c["potion"], potion.as_deref(), w) + }); + } /// `TradeTrigger`: the villager and the item the trade gave. pub(super) fn trigger_trade(&mut self, villager: &EntityView, stack: &ItemStack) { let me = self.player_entity(); @@ -729,6 +895,35 @@ impl Game<'_> { && adv::item(&c["item"], &it, w) }); } + /// `FishingRodHookedTrigger`: the rod, what the hook is in (or the hook) + /// and the items it caught. + pub(super) fn trigger_fishing_rod_hooked( + &mut self, + rod: &ItemStack, + hooked: &EntityView, + items: &[ItemStack], + ) { + let me = self.player_entity(); + let rod = item_view(rod); + let hooked = hooked.clone(); + let items: Vec = items.iter().map(item_view).collect(); + self.trigger("minecraft:fishing_rod_hooked", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + let ectx = adv::Entities { + this: Some(&hooked), + ..pctx + }; + adv::conditions(&c["player"], &pctx, w) + && adv::item(&c["rod"], &rod, w) + && adv::conditions(&c["entity"], &ectx, w) + && (c["item"].is_null() || items.iter().any(|i| adv::item(&c["item"], i, w))) + }); + } /// `EnterBlockTrigger`: the block, its state properties and the player. pub(super) fn trigger_enter_block(&mut self, state: horizon_world::registry::BlockStateId) { let Some(definition) = self.pack.assets.registry.state(state).cloned() else { diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index d99f32f24..4ab0a5189 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -568,6 +568,22 @@ impl Game<'_> { "generate_structures": options.structures, "bonus_chest": options.bonus_chest(), }), + Mode::CreateFlat { + name, + seed, + options, + flat, + .. + } => json!({ + "mode": "customize-flat", + "fields": { "name": name, "seed": seed }, + "superflat": options.flat, + "biome": flat.settings().biome, + "layers": flat.settings().layers.iter().map(|layer| json!({ + "block": layer.block, + "height": layer.height, + })).collect::>(), + }), Mode::Edit { world, name, diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs index dba4edfad..ce9410ba5 100644 --- a/crates/horizon-client/src/game/allays.rs +++ b/crates/horizon-client/src/game/allays.rs @@ -161,7 +161,7 @@ impl Game<'_> { } // Allay.duplicateAllay: entity event 18, three spawnHeartParticle. let id = self.mobs[index].id; - self.particles_around_mob(id, "heart", horizon_client::particles::Burst::ALLAY); + self.mob_event_particles(id, 18); self.audio .play("minecraft:block.amethyst_block.chime", Some(at), 2.0, 1.0); self.consume_held(); diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs index 9a8c846c5..8cd8be53a 100644 --- a/crates/horizon-client/src/game/armor_stands.rs +++ b/crates/horizon-client/src/game/armor_stands.rs @@ -711,6 +711,20 @@ impl Game<'_> { let color = undyed.map_or(0xFFFF_FFFF, |c| { 0xFF00_0000 | (c & 0xFF) << 16 | (c & 0xFF00) | (c >> 16) & 0xFF }); + // ArmorStandRenderer's HumanoidArmorLayer: the armour glint + // when `stack.hasFoil()`, as on a living entity. + let item_glint = self + .res + .items() + .enchantments + .props + .get(&stack.item) + .is_some_and(|p| p.glint); + let overlay = if stack.has_foil(item_glint) { + horizon_client::mobs::render::ARMOR_GLINT + } else { + 0 + }; let layer_poses = Poses::new(part); horizon_client::mobs::render::draw( part, @@ -719,7 +733,7 @@ impl Game<'_> { uv, color, packed, - 0, + overlay, out, ); // EquipmentLayerRenderer: the trim layer over the armour. @@ -734,7 +748,7 @@ impl Game<'_> { trim, 0xFFFF_FFFF, packed, - 0, + overlay, out, ); } @@ -877,6 +891,7 @@ impl Game<'_> { lights: Some(horizon_client::block_entity_render::diffuse_lights( self.dim == super::Dim::Nether, )), + glint: self.glint(), }; let profile = stack .extra diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs index b7f7efb1a..e17a8f6a3 100644 --- a/crates/horizon-client/src/game/beehives.rs +++ b/crates/horizon-client/src/game/beehives.rs @@ -3,8 +3,10 @@ //! player breaks the hive or fire reaches it. use super::Game; use horizon_client::{ + Result, beehive::{self, Beehive, HiveHost, Release}, containers::BlockEntity, + items::ItemStack, mobs::{Mob, Who, bee}, }; use horizon_core::{ @@ -194,19 +196,139 @@ impl Game<'_> { } self.anger_nearby_bees(at); } + /// `BeehiveBlock.useItemOn` with `held` in the acting hand: shears take + /// the honeycombs and a glass bottle a honey bottle from a full hive + /// (honey level 5), then the honey level resets and, unless a campfire + /// smokes the hive, the bees come out angry. True when it took the click. + pub(super) fn use_beehive(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> Result { + let Some(held) = held else { return Ok(false) }; + let shears = &*held.item == "minecraft:shears"; + if !shears && &*held.item != "minecraft:glass_bottle" { + return Ok(false); + } + let state = self.world.block(pos[0], pos[1], pos[2]); + if !matches!( + &*self.res.facts().get(state).name, + "minecraft:beehive" | "minecraft:bee_nest" + ) { + return Ok(false); + } + let prop = |key: &str| { + self.pack + .assets + .registry + .state(state) + .and_then(|s| s.properties.get(key).cloned()) + }; + if prop("honey_level").and_then(|v| v.parse::().ok()) != Some(5) { + return Ok(false); + } + let facing = beehive::facing_step(prop("facing").as_deref()); + let at = self + .player + .as_ref() + .map(|p| [p.position.x, p.position.y, p.position.z]); + if shears { + // dropHoneycomb (harvest/beehive), the shear sound, hurtAndBreak. + for stack in self.sequence_loot( + "minecraft:harvest/beehive", + "minecraft:harvest/beehive", + Some(held), + ) { + self.pop_resource(pos, stack); + } + self.audio + .play("minecraft:block.beehive.shear", at, 1.0, 1.0); + self.damage_held(1); + self.post_block_game_event("minecraft:shear", pos, self.sculk_actor(), None); + } else { + // shrink(1), then the honey bottle in the hand, the inventory or + // on the ground. + self.audio.play("minecraft:item.bottle.fill", at, 1.0, 1.0); + let cell = self.held_mut(); + if let Some(s) = cell.as_mut() { + s.count -= 1; + if s.count == 0 { + *cell = None; + } + } + let bottle = ItemStack::new("minecraft:honey_bottle", 1); + if self.held().is_none() { + *self.held_mut() = Some(bottle); + } else if let Some(rest) = self.give(bottle) + && let Some(eye) = self.eye_position() + { + self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40); + } + self.post_block_game_event("minecraft:fluid_pickup", pos, self.sculk_actor(), None); + } + self.stats.add("used", &held.item, 1); + let smokey = beehive::smokey(&self.mob_world_base(&[]), pos); + let key = (pos[0], pos[1], pos[2]); + if !smokey + && matches!(self.world.block_entities.get(&key), Some(BlockEntity::Beehive(h)) if !h.bees.is_empty()) + { + self.anger_nearby_bees(pos); + } + // resetHoneyLevel. + if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) { + self.level_set(pos, reset)?; + } + if !smokey + && let Some(BlockEntity::Beehive(mut hive)) = self.world.block_entities.take(&key) + { + // emptyAllLivingFromHive: the bees within 4 blocks of the player + // go for them. + let released = hive.release_all( + pos, + facing, + None, + Release::Emergency, + &mut GameHive { game: self }, + ); + self.world + .block_entities + .put(key, BlockEntity::Beehive(hive)); + if let Some(p) = self.player_view().map(|p| p.position) { + for m in self.mobs.iter_mut().filter(|m| released.contains(&m.id)) { + if m.distance_sqr(p) <= 16.0 { + m.ai.target = Some(Who::Player); + } + } + } + } + // ServerPlayerGameMode.useItemOn: the action was consumed. + self.trigger_block("minecraft:item_used_on_block", pos, held); + Ok(true) + } /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down) - /// without a target go for a player in the same box. - fn anger_nearby_bees(&mut self, at: [i32; 3]) { + /// without a target go for a random player in the same box, the window's + /// own or a guest (`None` is the window's player). + pub(super) fn anger_nearby_bees(&mut self, at: [i32; 3]) { let min = Vec3::new( f64::from(at[0]) - 8.0, f64::from(at[1]) - 6.0, f64::from(at[2]) - 8.0, ); let area = Aabb::new(min, Vec3::new(min.x + 17.0, min.y + 13.0, min.z + 17.0)); - if !self + let mut players: Vec> = Vec::new(); + if self .player_view() .is_some_and(|p| p.bounds.intersects(area)) { + players.push(None); + } + if let Some(host) = self.lan.as_ref() { + players.extend( + host.hub + .guests + .iter() + .filter(|g| host.hub.here(g) && g.loaded && !g.dead) + .filter(|g| super::lan_mobs::guest_bounds(g).intersects(area)) + .map(|g| Some(g.conn)), + ); + } + if players.is_empty() { return; } let mut bees: Vec = (0..self.mobs.len()) @@ -219,9 +341,20 @@ impl Game<'_> { .collect(); bees.retain(|&i| self.mobs[i].ai.target.is_none()); for i in bees { - // Util.getRandom over the one player. - let _ = self.world.random.next_int_bound(1); + // Util.getRandom over the players. + let pick = self + .world + .random + .next_int_bound(players.len() as i32) + .unwrap_or(0) as usize; self.mobs[i].ai.target = Some(Who::Player); + // The player a mob sees is its guest binding, else the window's. + if let Some(host) = self.lan.as_mut() { + match players[pick] { + Some(conn) => host.mob_players.insert(self.mobs[i].id, conn), + None => host.mob_players.remove(&self.mobs[i].id), + }; + } } } } diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs index a710a273b..2705d8388 100644 --- a/crates/horizon-client/src/game/block_entity_anims.rs +++ b/crates/horizon-client/src/game/block_entity_anims.rs @@ -76,23 +76,24 @@ impl Game<'_> { /// A player opened (`open`) or closed the container at `key`: the opener /// count block event (`ContainerOpenersCounter` / `ShulkerBoxBlockEntity` /// `startOpen`/`stopOpen`) for chests, ender chests and shulker boxes, - /// on both halves of a double chest (`CompoundContainer`). - pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) { + /// on both halves of a double chest (`CompoundContainer`). True when the + /// count went from 0 to 1 or back to 0: the only moments the container + /// plays its open or close sound. + pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) -> bool { // Spectators never count as openers. - if !self.spectator() { - self.container_openers_changed(key, open); - } + !self.spectator() && self.container_openers_changed(key, open) } /// `container_opener_event` for a player who is not a spectator (a guest). - pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) { + pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool { let pos = [key.0, key.1, key.2]; let state = self.world.block(pos[0], pos[1], pos[2]).0; match self.be_anims.ticker(state) { Some(Ticker::Lid) => { - self.lid_openers_changed(key, open); + let edge = self.lid_openers_changed(key, open); if let Some(other) = self.chest_other_half(key) { self.lid_openers_changed(other, open); } + edge } _ if self .res @@ -102,26 +103,27 @@ impl Game<'_> { .as_ref() == "minecraft:barrel" => { - self.barrel_openers_changed(key, open); + self.barrel_openers_changed(key, open) } Some(Ticker::Shulker { .. }) => { let shulker = self.be_anims.shulkers.entry(pos).or_default(); - let (count, _) = if open { + let (count, edge) = if open { shulker.start_open() } else { shulker.stop_open() }; self.block_entity_event(pos, 1, count); self.lan_block_event(pos, 1, count); + edge } - _ => {} + _ => false, } } /// `ContainerOpenersCounter.incrementOpeners` / `decrementOpeners` of the /// chest at `key` (the host and the guests are counted), then /// `ChestBlockEntity.signalOpenCount`: block event 1 with the count, here - /// and for the guests. - fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) { + /// and for the guests. True when the count crossed zero. + fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool { let (before, count) = self.count_opener(key, open); let pos = [key.0, key.1, key.2]; self.block_entity_event(pos, 1, count); @@ -139,12 +141,15 @@ impl Game<'_> { b.update_neighbors_at(level, ticks, p.offset(0, -1, 0), block); }); } + (before == 0) != (count == 0) } /// `BarrelBlockEntity.openersCounter`: the first opener opens the barrel /// (`open=true`), the last one to leave closes it (`updateBlockState`). - fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) { + /// True when the count crossed zero. + fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool { let (before, count) = self.count_opener(key, open); - if (before == 0) != (count == 0) { + let edge = (before == 0) != (count == 0); + if edge { self.set_bool_prop( key, "open", @@ -152,6 +157,7 @@ impl Game<'_> { horizon_world::level::flags::UPDATE_ALL, ); } + edge } /// One opener more (`open`) or less at `key`: the count before and after /// (`ContainerOpenersCounter.incrementOpeners` / `decrementOpeners`). diff --git a/crates/horizon-client/src/game/books.rs b/crates/horizon-client/src/game/books.rs index b09803e49..ddbe47481 100644 --- a/crates/horizon-client/src/game/books.rs +++ b/crates/horizon-client/src/game/books.rs @@ -8,7 +8,7 @@ use horizon_client::{ containers::{BlockEntity, Lectern}, first_person::Hand, hud::{HudBatch, rgba}, - item_data::WrittenBook, + item_data::{StackData, WrittenBook}, items::ItemStack, menu::{Kind, Menu}, text::Text, @@ -59,14 +59,86 @@ pub(super) enum BookScreen { page_edit: ui::EditBox, }, View { - pages: Vec, + pages: Vec, page: usize, lectern: Option<(i32, i32, i32)>, }, } +/// The pages a book screen reads: a written book's components (so their +/// click events stay), else a writable book's text. +fn view_pages(data: Option<&StackData>) -> Vec { + let Some(data) = data else { return Vec::new() }; + let Some(w) = &data.written else { + return data.writable_pages.iter().map(Text::literal).collect(); + }; + let tagged = w.page_tags.len() == w.pages.len(); + w.pages + .iter() + .enumerate() + .map(|(i, page)| match tagged.then(|| &w.page_tags[i]) { + Some(tag @ horizon_world::nbt::Tag::Compound(_)) => { + horizon_client::entity_nbt::name_text(tag) + } + _ => Text::literal(page), + }) + .collect() +} impl Game<'_> { fn book_lines(&self, page: &str) -> Vec { - self.gui.atlas.font.split(&Text::literal(page), 114.0) + self.page_lines(&Text::literal(page)) + } + fn page_lines(&self, page: &Text) -> Vec { + self.gui.atlas.font.split(page, 114.0) + } + /// `BookViewScreen.mouseClicked`: the click event of the text under the + /// cursor on the page. + fn book_link_at(&self, page: &Text, left: f32) -> Option { + let (mx, my) = self.cursor; + let row = ((my - 32.0) / 9.0).floor(); + if row < 0.0 || row >= LINES as f32 { + return None; + } + let lines = self.page_lines(page); + let line = lines.get(row as usize)?.resolve_legacy(); + let mut x = mx - (left + 36.0); + if x < 0.0 { + return None; + } + for (c, style) in line.chars() { + x -= self.gui.atlas.font.advance(c, style); + if x < 0.0 { + return style.click.clone(); + } + } + None + } + /// `BookViewScreen.handleClickEvent`: a page link turns to its page + /// (`forcePage`), a web link goes through the confirm-link flow. + fn book_follow_link( + &mut self, + link: horizon_client::text::ClickEvent, + count: usize, + lectern: Option<(i32, i32, i32)>, + ) { + use horizon_client::text::ClickEvent; + match link { + ClickEvent::ChangePage(target) => { + let target = (target - 1).clamp(0, count.saturating_sub(1) as i32); + let Some(BookScreen::View { page, .. }) = self.book.as_mut() else { + return; + }; + if let Some(key) = lectern { + // LecternScreen.forcePage: the menu's button 100 + page. + if target != *page as i32 { + self.lectern_button(key, 100 + target); + } + } else if target != *page as i32 { + *page = target as usize; + } + } + ClickEvent::OpenUrl(url) => self.click_url(url), + _ => {} + } } /// `WritableBookItem.use` / `WrittenBookItem.use` (`Player.openItemGui`). /// A server's player writes in its own client's editor @@ -115,11 +187,7 @@ impl Game<'_> { } } "minecraft:written_book" => BookScreen::View { - pages: stack - .data() - .and_then(|d| d.written.as_ref()) - .map(|w| w.pages.clone()) - .unwrap_or_default(), + pages: view_pages(stack.data()), page: 0, lectern: None, }, @@ -215,6 +283,7 @@ impl Game<'_> { author, generation: 0, pages, + page_tags: Vec::new(), }); *stack = written; } else { @@ -685,11 +754,7 @@ impl Game<'_> { return false; }; let Some(book) = &l.book else { return false }; - let data = book.data(); - let pages = data - .and_then(|d| d.written.as_ref().map(|w| w.pages.clone())) - .or_else(|| data.map(|d| d.writable_pages.clone())) - .unwrap_or_default(); + let pages = view_pages(book.data()); let page = (l.page.max(0) as usize).min(pages.len().saturating_sub(1)); self.stats.custom("interact_with_lectern", 1); self.open_book(BookScreen::View { @@ -811,11 +876,7 @@ impl Game<'_> { page, }) = self.book.as_mut() { - let data = book.as_ref().and_then(ItemStack::data); - *pages = data - .and_then(|d| d.written.as_ref().map(|w| w.pages.clone())) - .or_else(|| data.map(|d| d.writable_pages.clone())) - .unwrap_or_default(); + *pages = view_pages(book.as_ref().and_then(ItemStack::data)); *page = (*page).min(pages.len().saturating_sub(1)); } } @@ -955,7 +1016,10 @@ impl Game<'_> { lectern, }) => { let (page, count, lectern) = (*page, pages.len(), *lectern); - if page + 1 < count && inside(left + 116.0, 159.0, 23.0, 13.0) { + // The text's click event first, then the buttons. + if let Some(link) = pages.get(page).and_then(|t| self.book_link_at(t, left)) { + self.book_follow_link(link, count, lectern); + } else if page + 1 < count && inside(left + 116.0, 159.0, 23.0, 13.0) { self.turn_page(true); } else if page > 0 && inside(left + 43.0, 159.0, 23.0, 13.0) { self.turn_page(false); @@ -1198,7 +1262,7 @@ impl Game<'_> { } => { indicator(batch, *page, pages.len()); if let Some(text) = pages.get(*page) { - for (i, line) in self.book_lines(text).iter().take(LINES).enumerate() { + for (i, line) in self.page_lines(text).iter().take(LINES).enumerate() { batch.text_styled( atlas, line, diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index c392f3ea6..7344c0e9d 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -695,12 +695,78 @@ impl Game<'_> { Some(ClickEvent::OpenFile(path)) => { super::packs::open_folder(std::path::Path::new(&path)); } + Some(ClickEvent::OpenUrl(url)) => self.click_url(url), Some(ClickEvent::SuggestCommand(command)) => { if let Some(screen) = self.ui.chat_screen.as_mut() { screen.suggest_command(&m, &c, &command); } } - None => {} + // Screen.defaultHandleClickEvent: a page link means nothing in chat. + Some(ClickEvent::ChangePage(_)) | None => {} + } + } + /// `Screen.clickUrlAction`: nothing with Web Links off, else the link + /// opens, after the confirmation unless Prompt on Links is off. + pub(super) fn click_url(&mut self, url: String) { + if !self.settings.chat_links { + return; + } + if self.settings.file.bool("chatLinksPrompt") { + self.link_prompt = Some(url); + } else { + super::packs::open_uri(&url); + } + } + /// `ConfirmLinkScreen` (untrusted): the link and its warning over the + /// chat, answered yes to open it. + fn link_prompt_layout( + &self, + url: &str, + size: (f32, f32), + ) -> horizon_client::confirm_screen::Confirm { + let warning = Text::translate("chat.link.warning", &[]).with_color(0xFF_CCCC); + let message = Text::literal(url) + .append(Text::literal("\n")) + .append(warning); + horizon_client::confirm_screen::Confirm::new( + &self.gui.atlas.font, + size, + &Text::translate("chat.link.confirm", &[]), + &message, + ) + } + pub(super) fn draw_link_prompt(&self, batch: &mut HudBatch) { + let Some(url) = &self.link_prompt else { + return; + }; + let atlas = &self.gui.atlas; + let (w, h) = (batch.width, batch.height); + horizon_client::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true); + let (yes, no) = ( + Text::translate("gui.yes", &[]), + Text::translate("gui.no", &[]), + ); + self.link_prompt_layout(url, (w, h)) + .draw(batch, atlas, self.cursor, [&yes, &no]); + } + /// The prompt's answer: the link opens on yes; either way the chat is back. + pub(super) fn answer_link_prompt(&mut self, yes: bool) { + if let Some(url) = self.link_prompt.take() + && yes + { + super::packs::open_uri(&url); + } + } + pub(super) fn link_prompt_click(&mut self) { + let Some(url) = &self.link_prompt else { + return; + }; + let answer = self + .link_prompt_layout(url, self.gui_size()) + .answer_at(self.cursor); + if let Some(yes) = answer { + self.audio.play_button_click(); + self.answer_link_prompt(yes); } } /// Chat lines over the HUD (focused while the chat screen is open). diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index f69f1b695..f125899f3 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -45,6 +45,13 @@ pub(super) struct CombatTracker { /// The mob exploding now (`ServerExplosion.source`): its team's friendly /// fire decides whom the blast may hurt. pub(super) explosion_source: Option, + /// The blast now going off comes from a primed TNT, creeper, wither + /// skull, wither or TNT minecart, the sources that empty a hive they + /// destroy (`BeehiveBlock.getDrops`). + pub(super) hive_emptying_blast: bool, + /// The mob that owns the projectile exploding now (`getIndirectSourceEntity`): + /// the mobs the blast hurts record it as their attacker. + pub(super) explosion_owner: Option, /// Charged creepers whose blast just went off and that have not dropped /// a head yet (`Creeper.droppedSkulls`): they are gone from the mob list, /// but the mobs they killed still ask for their loot. @@ -131,6 +138,19 @@ impl Game<'_> { self.recheck_combat(); for e in events { let (name, amount) = match e { + // LivingEntity.getDamageAfterMagicAbsorb (Resistance) and + // Player.actuallyHurt (absorption hearts) and + // LivingEntity.hurtServer (the shield, only for an accepted + // hit), in tenths. + MotionEvent::Health(HealthEvent::Statistic { name, amount }) => { + match *name { + "resisted" => self.stats.custom("damage_resisted", *amount), + "absorbed" => self.stats.custom("damage_absorbed", *amount), + "blocked" => self.stats.custom("damage_blocked_by_shield", *amount), + _ => {} + } + continue; + } MotionEvent::Health(HealthEvent::RecordedDamage { source, amount }) => { let Some(d) = self.motion.health.damage.definition(*source) else { continue; @@ -177,6 +197,10 @@ impl Game<'_> { direct, }); self.combat.last_damage = now; + // InfestedMobEffect.onMobHurt. + if self.potions.effects.get("infested").is_some() { + self.player_infested(); + } } self.combat.pending.clear(); self.combat.pending_direct.clear(); diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index d3c40c3eb..43cdfa51c 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -2049,8 +2049,7 @@ impl Game<'_> { return false; } self.world.block_entities.insert(key, new); - let state = self.world.block(pos[0], pos[1], pos[2]); - let _ = self.world.set(pos[0], pos[1], pos[2], state); + self.world.modified.insert((pos[0] >> 4, pos[2] >> 4)); true } /// RandomizableContainer.tryLoadLootTable for a tag a command gives a diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index f773f5fed..34319d462 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -158,6 +158,8 @@ fn flame_geometry( layer: 0, color: 0xFFFF_FFFF, light: packed, + + glint_uv: [0.0, 0.0], }); } h -= 0.45; @@ -199,6 +201,7 @@ impl Game<'_> { off_hand: None, head: self.armor[0].as_ref().map(|s| s.item.clone()), armor_cover: self.armor.iter().filter(|a| a.is_some()).count() as f32 / 4.0, + invisible: self.potions.effects.get("invisibility").is_some(), spectator: self.spectator(), gold_armor: self.wearing_gold(), hurt_by: self.player_hurt_by(), @@ -433,11 +436,13 @@ impl Game<'_> { block_tags: &self.res.items().block_tags, biomes: self.res.biomes(), mob_griefing: self.ui.rules.bool("mob_griefing"), + mob_drops: self.ui.rules.bool("mob_drops"), end: self.dim == Dim::End, world_seed: self.level.seed, sea_level: if self.dim == Dim::Nether { 32 } else { 63 }, teams: std::sync::Arc::new(self.mob_teams()), items: Some(self.res.items()), + lid_openers: &self.lid_openers, difficulty: self.local_difficulty( self.player .as_ref() @@ -526,6 +531,7 @@ impl Game<'_> { let mut events = Vec::new(); let mut mobs = std::mem::take(&mut self.mobs); let mut dead = Vec::new(); + let mut corpses = Vec::new(); let mut died = std::mem::take(&mut self.died); let ticking = self.entity_ticking_area(); // With guests on, each mob sees its nearest player (game/lan_mobs.rs). @@ -620,6 +626,11 @@ impl Game<'_> { horizon_client::mobs::apply_mob_pushes(m, &mut pushes); let from = events.len(); let kept = m.tick(&w, &mut scratch, &mut events); + // A killed mob's body is removed: its effects that act on + // death run (`LivingEntity.remove` with KILLED). + if !kept && !m.alive() && !m.removed && !m.extra.effects.is_empty() { + corpses.push(m.clone()); + } horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes); // LivingEntity.tickDeath: after twenty ticks the body is removed. if !kept && !m.removed && !m.alive() && m.death_time >= 20 { @@ -700,6 +711,16 @@ impl Game<'_> { for m in dead { self.mob_died(&m); } + for mut m in corpses { + let names: Vec<&'static str> = m + .extra + .effects + .iter() + .map(|e| e.0.trim_start_matches("minecraft:")) + .collect(); + let bounds = m.bounds(); + self.effects_on_death(&names, bounds, false, Some(m.id), Some(&mut m.random)); + } self.handle_mob_events(events)?; self.lan_guest_mob_events(guest_events); self.tick_projectiles()?; @@ -772,6 +793,7 @@ impl Game<'_> { self.villager_murdered(m, by_player); let pos = [m.position.x, m.position.y + 0.5, m.position.z]; self.drop_death_loot(&mut dying, by_player, consumed, pos); + self.create_wither_rose(m); if m.species() == Species::CopperGolem { // CopperGolem.dropEquipment: the preserved equipment too. self.golem_drop_equipment(&mut dying); @@ -902,6 +924,18 @@ impl Game<'_> { } } } + /// `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) { + let at = [ + m.position.x, + m.position.y + f64::from(m.height()) / 2.0, + m.position.z, + ]; + let look = m.view_vector(); + self.infested_hurt(at, look, Some(mob)); + } + } /// `LivingEntity.dropFromGiftLootTable`: the gift table from its random /// sequence with the mob as `this` (a chicken's egg depends on its /// variant); the loot data of the game's resources decides, and without it @@ -966,6 +1000,9 @@ impl Game<'_> { .map_or([0.0; 3], |m| [m.velocity.x, m.velocity.y, m.velocity.z]); self.drown_particles(at, v); } + MobEvent::EntityEvent { mob, event, at } => { + self.lan_entity_event(mob as i32, event, at) + } MobEvent::Sound(name, at, volume, pitch) | MobEvent::LocalSound(name, at, volume, pitch) => { self.audio @@ -1047,7 +1084,7 @@ impl Game<'_> { self.combat.charged_exploders.push(mob); } } - MobEvent::Explode(at, radius) => { + MobEvent::Explode(at, radius, species) => { // The exploding mob causes the damage (Creeper.explodeCreeper). let source_mob = self.combat.explosion_source.or_else(|| { self.mobs @@ -1063,7 +1100,14 @@ impl Game<'_> { self.note_attacker("minecraft:explosion", id); } self.combat.explosion_source = source_mob; - let result = self.explode(at, radius); + // Only a creeper or a wither empties the hives it blows up. + // The creeper is already gone from the list, so the event + // carries its kind. + let result = if matches!(species, Species::Creeper | Species::Wither) { + self.with_hive_emptying_blast(|g| g.explode(at, radius)) + } else { + self.explode(at, radius) + }; self.combat.explosion_source = None; result? } @@ -1074,6 +1118,7 @@ impl Game<'_> { } => { 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; @@ -1082,20 +1127,27 @@ impl Game<'_> { // The hurt or death sound the mob raised. let center = t.center(); for event in std::mem::take(&mut t.outbox) { - if let MobEvent::Sound(s, _, volume, pitch) = event { - self.audio.play( - &format!("minecraft:{s}"), - Some(center), - volume, - pitch, - ); - } else { - // Left for the end of the tick. - t.outbox.push(event); + 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 @@ -1141,6 +1193,7 @@ impl Game<'_> { } MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob), MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive), + MobEvent::Infested { mob } => self.mob_infested(mob), MobEvent::Gift { target, item } => { if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target) && m.saddle_item().is_none() @@ -1191,9 +1244,9 @@ impl Game<'_> { [0.0, 0.2, 0.0], 10, ), - MobEvent::SetBlock { pos, state } => { - self.world.set(pos[0], pos[1], pos[2], state)? - } + // `Level.setBlockAndUpdate`: neighbour and shape updates, so a crop + // above trampled farmland breaks and drops. + MobEvent::SetBlock { pos, state } => self.level_set(pos, state)?, MobEvent::SetDoorOpen { pos, open } => { let pos = BlockPos::new(pos[0], pos[1], pos[2]); self.with_level(|b, level, ticks| b.set_door_open(level, ticks, pos, open)); @@ -1304,12 +1357,17 @@ impl Game<'_> { } } MobEvent::AroundSelf { + mob, + event, kind, feet, width, height, burst, - } => self.particles_around(kind, feet, [width, height], burst), + } => { + self.lan_entity_event(mob as i32, event, feet); + self.particles_around(kind, feet, [width, height], burst) + } MobEvent::ParticleAt { kind, at, velocity } => { if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) { let options = horizon_client::particles::ParticleOptions::simple(ty); @@ -1420,6 +1478,22 @@ impl Game<'_> { m.ai.aggressive |= aggressive; } } + MobEvent::ShedScute { mob, at, pitch } => { + // The mob already checked `shouldDropLoot` (a baby, `mob_drops`). + let table = "minecraft:gameplay/armadillo_shed"; + let drops = self.sequence_loot(table, table, None); + for d in drops { + self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d); + } + self.audio.play( + "minecraft:entity.armadillo.scute_drop", + Some(at), + 1.0, + pitch, + ); + let ctx = self.who_context(Some(Who::Mob(mob)), None); + self.post_game_event("minecraft:entity_place", at, ctx); + } MobEvent::GiftLoot { mob, table, at } => { // Turtle.ageBoundaryReached: only with mob loot on. if table == "minecraft:gameplay/turtle_grow" && !self.ui.rules.bool("mob_drops") @@ -1548,6 +1622,8 @@ impl Game<'_> { q.extra.in_love = 0; } let q = self.mobs.iter().find(|m| m.id == partner).cloned(); + // Animal.finalizeSpawnChildFromBreeding: entity event 18 for the parent. + self.mob_event_particles(parent, 18); // Sniffer.spawnChildFromBreeding: an egg instead of a baby. if p.species() == Species::Sniffer { self.lay_sniffer_egg(&p); @@ -1820,6 +1896,10 @@ impl Game<'_> { let (xd, zd) = from.map_or((0.0, 0.0), |from| { (from[0] - player.position.x, from[2] - player.position.z) }); + // dealDefaultKnockback's `indicateDamage`, unless blocked. + if o.blocked <= 0.0 { + player.health.indicate_damage(xd, zd, player.yaw); + } self.knock_back_player(f64::from(0.4_f32), xd, zd); if let Some(p) = self.player.as_mut() && let Some(r) = p.hurt_log.last_mut() @@ -1832,6 +1912,23 @@ impl Game<'_> { self.thorns(a); } } + // LivingEntity.hurtServer: ENTITY_HURT_PLAYER, unless it returned + // early (invulnerable, or inside the hurt cooldown). + if outcome.hurt || outcome.sound { + let source = attacker + .or(owner) + .and_then(|id| self.mobs.iter().find(|m| m.id == id)) + .map(|m| self.mob_entity(m)); + self.trigger_entity_hurt_player(&horizon_client::advancements::DamageView { + kind: damage_type.to_owned(), + direct: source.clone().filter(|_| !projectile), + is_direct: !projectile, + source, + original: amount, + actual: amount - outcome.blocked, + blocked: outcome.blocked > 0.0, + }); + } if raised { self.after_block(outcome, amount, attacker, projectile); } @@ -2064,6 +2161,21 @@ impl Game<'_> { if super::remote_projectiles::has_smoke_trail(&p.kind) { trails.push(p.position); } + // ThrownEnderpearl.onAboveBubbleColumn / onInsideBubbleColumn. + if keep && hit == Hit::None && matches!(p.kind, ProjectileKind::EnderPearl) { + let (at, h) = (p.position, 0.125); + horizon_client::motion::bubble_column_push( + w.world, + w.registry, + w.facts, + w.collision, + Aabb::new( + Vec3::new(at.x - h, at.y, at.z - h), + Vec3::new(at.x + h, at.y + 2.0 * h, at.z + h), + ), + &mut p.velocity, + ); + } if let Some(a) = p.arrow.as_mut() { arrow_events.extend(a.events.drain(..).map(|e| (p.position, e))); } @@ -2489,14 +2601,46 @@ impl Game<'_> { .is_some_and(|m| m.damage(amount, source)); if p.owner == Some(Who::Player) { self.last_hurt_by_player.insert(id, self.lan_acting); + if hurt && let Some(m) = self.mobs.iter().find(|m| m.id == id) { + // LivingEntity.hurtServer: PLAYER_HURT_ENTITY. + let victim = self.mob_entity(m); + let spectral = p.arrow.as_ref().is_some_and(|a| { + &*a.pickup_item.item == "minecraft:spectral_arrow" + }); + let direct = horizon_client::advancements::EntityView { + kind: if spectral { + "minecraft:spectral_arrow" + } else { + "minecraft:arrow" + } + .into(), + position: [p.position.x, p.position.y, p.position.z], + ..Default::default() + }; + self.player_hit(&victim, "minecraft:arrow", Some(direct), amount); + } } hurt } }; - // doKnockback: Punch pushes along the flight. + // doKnockback: Punch pushes along the flight, less the target's + // knockback resistance. let flight = (p.velocity.x * p.velocity.x + p.velocity.z * p.velocity.z).sqrt(); - if hurt && p.bonus.punch > 0 && flight > 1e-6 { - let k = f64::from(p.bonus.punch) * 0.6 / flight; + let resistance = match who { + Who::Player => self + .player + .as_mut() + .and_then(|pl| pl.attribute("minecraft:knockback_resistance").ok()) + .unwrap_or(0.0), + Who::Mob(id) => self + .mobs + .iter() + .find(|m| m.id == id) + .map_or(0.0, |m| m.attrs.knockback_resistance), + }; + let push = f64::from(p.bonus.punch) * 0.6 * (1.0 - resistance).max(0.0); + if hurt && push > 0.0 && flight > 1e-6 { + let k = push / flight; self.handle_mob_events(vec![MobEvent::Push { target: who, velocity: [p.velocity.x * k, 0.1, p.velocity.z * k], @@ -2532,6 +2676,7 @@ impl Game<'_> { }; m.damage(amount, source); } + self.thrown_break_event(p.id, atp); self.item_burst(atp, "minecraft:snowball"); } (ProjectileKind::Egg, hit) => { @@ -2557,6 +2702,7 @@ impl Game<'_> { } } } + self.thrown_break_event(p.id, atp); self.item_burst(atp, "minecraft:egg"); } (ProjectileKind::EnderPearl, hit) => { @@ -2660,7 +2806,10 @@ impl Game<'_> { if let Some(owner) = self.combat.projectile_owner { self.note_attacker("minecraft:explosion", owner); } - self.explode(atp, *power as f32)?; + self.combat.explosion_owner = self.combat.projectile_owner; + let result = self.explode(atp, *power as f32); + self.combat.explosion_owner = None; + result?; } ( ProjectileKind::Potion { @@ -2806,10 +2955,17 @@ impl Game<'_> { } Ok(()) } + /// `Snowball`/`ThrownEgg.onHit`: entity event 3 for the guests, before the + /// projectile is discarded (the clients lose it when the tracker next runs). + fn thrown_break_event(&mut self, id: u32, at: [f64; 3]) { + if id != 0 { + self.lan_entity_event(id as i32, 3, at); + } + } /// `Snowball`/`ThrownEgg.handleEntityEvent(3)`: eight crumbs of the /// thrown item where it broke, at rest for a snowball, scattered by the /// client entity's random (the particle engine's here) for an egg. - fn item_burst(&mut self, at: [f64; 3], item: &str) { + pub(super) fn item_burst(&mut self, at: [f64; 3], item: &str) { let options = self.item_particle(&horizon_client::items::ItemStack::new(item, 1)); let egg = item != "minecraft:snowball"; for _ in 0..8 { @@ -2845,6 +3001,10 @@ impl Game<'_> { if self.name_mob(index) { return Ok(true); } + if self.spawn_egg_offspring(index) { + self.swing_arm(); + return Ok(true); + } { let item = self.held().map(|h| h.item.to_string()).unwrap_or_default(); if self.interact_leash(index, &item) { @@ -2947,6 +3107,7 @@ impl Game<'_> { .items() .get(&item) .is_some_and(|i| i.max_damage > 0); + let acting = self.acting_player_uuid(); let m = &mut self.mobs[index]; if !m.alive() { return Ok(false); @@ -3051,6 +3212,7 @@ impl Game<'_> { } Species::Wolf if m.extra.tame + && m.extra.owner == Some(acting) && item.ends_with("_dye") && horizon_client::mobs::render::DYE_NAMES .iter() @@ -3073,7 +3235,9 @@ impl Game<'_> { consume = true; } Species::Wolf - if m.extra.tame && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) => + if m.extra.tame + && m.extra.owner == Some(acting) + && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) => { m.extra.sitting = !m.extra.sitting; m.ai.jumping = false; @@ -3093,20 +3257,14 @@ impl Game<'_> { let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0; if tamed { horizon_client::mobs::tame::set_tame(m, true); - m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1])); + m.extra.owner = Some(acting); m.persistent = true; m.nav_stop(); m.ai.target = None; m.extra.sitting = true; } - // TamableAnimal.spawnTamingParticles. - let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). - self.particles_around_mob( - self.mobs[index].id, - kind, - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); if tamed { let view = self.mob_entity(&self.mobs[index]); self.trigger_entity("minecraft:tame_animal", "entity", &view); @@ -3120,6 +3278,7 @@ impl Game<'_> { // Cat.mobInteract: dye, heal or sit when tame; fish may tame a wild one. Species::Cat if m.extra.tame + && m.extra.owner == Some(acting) && item.ends_with("_dye") && horizon_client::mobs::render::DYE_NAMES .iter() @@ -3142,7 +3301,12 @@ impl Game<'_> { m.persistent = true; consume = true; } - Species::Cat if m.extra.tame && is_food && m.health < m.attrs.max_health => { + Species::Cat + if m.extra.tame + && m.extra.owner == Some(acting) + && is_food + && m.health < m.attrs.max_health => + { let heal = self .res .items() @@ -3155,7 +3319,9 @@ impl Game<'_> { eat = eating_sound(m, &mut self.world.random); } Species::Cat - if m.extra.tame && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) => + if m.extra.tame + && m.extra.owner == Some(acting) + && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) => { m.extra.sitting = !m.extra.sitting; self.world.modified.insert(( @@ -3169,17 +3335,12 @@ impl Game<'_> { let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0; if tamed { m.extra.tame = true; - m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1])); + m.extra.owner = Some(acting); m.extra.sitting = true; } eat = eating_sound(m, &mut self.world.random); - let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). - self.particles_around_mob( - self.mobs[index].id, - kind, - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); if tamed { let view = self.mob_entity(&self.mobs[index]); self.trigger_entity("minecraft:tame_animal", "entity", &view); @@ -3227,13 +3388,8 @@ impl Game<'_> { m.extra.tame = true; m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1])); } - let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). - self.particles_around_mob( - self.mobs[index].id, - kind, - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); if tamed { let view = self.mob_entity(&self.mobs[index]); self.trigger_entity("minecraft:tame_animal", "entity", &view); @@ -3264,6 +3420,11 @@ impl Game<'_> { Some(sound) => { consume = true; eat = sound; + // Animal.setInLove: entity event 18 (a baby that + // only grew is not in love). + if self.mobs[index].extra.in_love > 0 { + self.mob_event_particles(self.mobs[index].id, 18); + } } // Animal.mobInteract still consumes the client click when // an adult cannot breed, without swinging or taking food. @@ -3460,6 +3621,45 @@ impl Game<'_> { } Ok(true) } + /// `Mob.checkAndHandleImportantInteractions` with a spawn egg of mob + /// `index`'s own kind (`SpawnEggItem.spawnOffspringFromSpawnEgg`): a baby + /// at the mob's feet, taking the parent's variant as `getBreedOffspring` + /// does, and one egg used. False (PASS) when the mob has no baby form. + fn spawn_egg_offspring(&mut self, index: usize) -> bool { + let Some(stack) = self.held().cloned() else { + return false; + }; + let parent = &self.mobs[index]; + if !parent.alive() + || stack.item.strip_suffix("_spawn_egg") != Some(parent.kind.id.as_str()) + || !horizon_client::mobs::drops::can_be_baby(parent.species()) + // WanderingTrader.getBreedOffspring returns null: no offspring, the + // click carries on to trading. + || parent.species() == Species::WanderingTrader + { + return false; + } + let (kind, at) = ( + parent.kind.id.clone(), + [parent.position.x, parent.position.y, parent.position.z], + ); + let (species, variant, color) = + (parent.species(), parent.extra.variant, parent.extra.color); + let target = self.mob_entity(&self.mobs[index]); + let Some(id) = self.spawn_mob(&kind, at, true) else { + return false; + }; + if let Some(child) = self.mobs.iter_mut().find(|m| m.id == id) { + horizon_client::mobs::finalize::set_baby(child, true); + child.extra.variant = variant; + if species == Species::Sheep { + child.extra.color = color; + } + } + self.trigger_item_entity("minecraft:player_interacted_with_entity", &stack, &target); + self.consume_held(); + true + } fn use_spawn_egg(&mut self, stack: &ItemStack) -> Result { let Some(hit) = self.pick() else { return Ok(false); @@ -3859,6 +4059,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light: packed, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 0d5a83fa5..da9aaafce 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -2165,10 +2165,12 @@ impl Game<'_> { c.at[1], c.at[2] + f64::from(a.sin() * d), ]; - self.particles.add( + self.particles.add_with( &ParticleOptions::simple(ParticleType::DragonBreath), at, [0.0, 0.0, 0.0], + false, + true, ); } // AreaEffectCloud: after its 20-tick wait, every 20 ticks per entity. @@ -2537,6 +2539,8 @@ impl Game<'_> { layer: 2, color: c, light: 0, + + glint_uv: [0.0, 0.0], }); } } @@ -2602,6 +2606,8 @@ impl Game<'_> { layer: 6, color: c, light: wrap_light, + + glint_uv: [0.0, 0.0], }); } (last_sin, last_cos, last_u) = (sin, cos, uu); @@ -2647,6 +2653,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light: 240 | 240 << 8, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs index b24a62520..5688a3226 100644 --- a/crates/horizon-client/src/game/enchant_effects.rs +++ b/crates/horizon-client/src/game/enchant_effects.rs @@ -157,8 +157,10 @@ impl Game<'_> { items: Some(self.res.items()), ..Default::default() }; - // minecraft:post_attack ignite effects of the attacker's weapon (fire aspect). + // minecraft:post_attack effects of the attacker's weapon on the victim: + // ignite (fire aspect) and apply_mob_effect (bane of arthropods). let mut ignite = 0.0f32; + let mut mob_effects = Vec::new(); for (id, level) in held.enchantments() { let Some(def) = self.res.stations().enchantments.get(id) else { continue; @@ -168,24 +170,33 @@ impl Game<'_> { .into_iter() .flatten() { - if effect["enchanted"] == "attacker" - && effect["affected"] == "victim" - && effect["effect"]["type"] == "minecraft:ignite" + let e = &effect["effect"]; + let kind_of = e["type"].as_str(); + if effect["enchanted"] != "attacker" + || effect["affected"] != "victim" + || !matches!( + kind_of, + Some("minecraft:ignite" | "minecraft:apply_mob_effect") + ) { - let mut random = self.world.random.clone(); - let ok = effect.get("requirements").is_none_or(|r| { - self.res - .stations() - .enchantments - .condition(r, *level, &ctx, &mut random) - }); - self.world.random = random; - if ok { - ignite = ignite.max(horizon_client::enchant::level_value( - &effect["effect"]["duration"], - *level, - )); - } + continue; + } + let mut random = self.world.random.clone(); + let ok = effect.get("requirements").is_none_or(|r| { + self.res + .stations() + .enchantments + .condition(r, *level, &ctx, &mut random) + }); + self.world.random = random; + if !ok { + continue; + } + if kind_of == Some("minecraft:ignite") { + ignite = + ignite.max(horizon_client::enchant::level_value(&e["duration"], *level)); + } else { + mob_effects.push((e.clone(), *level)); } } } @@ -195,8 +206,41 @@ impl Game<'_> { { m.ignite_for_ticks((ignite * 20.0) as i32); } + for (effect, level) in mob_effects { + self.apply_mob_effect(mob, &effect, level); + } self.post_attack_bursts(&held, &kind); } + /// `ApplyMobEffect.apply`: one of `to_apply` (a single id or a list) for a + /// random duration and amplifier between the level-based bounds. + fn apply_mob_effect(&mut self, mob: usize, effect: &serde_json::Value, level: u32) { + use horizon_client::enchant::level_value; + let Some(m) = self.mobs.get_mut(mob) else { + return; + }; + let ids: Vec<&str> = match &effect["to_apply"] { + serde_json::Value::String(id) => vec![id.as_str()], + serde_json::Value::Array(list) => list.iter().filter_map(|v| v.as_str()).collect(), + _ => Vec::new(), + }; + if ids.is_empty() { + return; + } + // HolderSet.getRandomElement, then Mth.randomBetween for both values. + let pick = m.random.next_int_bound(ids.len() as i32).unwrap_or(0) as usize; + let mut between = |min: &str, max: &str| { + let (lo, hi) = ( + level_value(&effect[min], level), + level_value(&effect[max], level), + ); + m.random.next_float() * (hi - lo) + lo + }; + let ticks = (between("min_duration", "max_duration") * 20.0).round() as i32; + let amplifier = (between("min_amplifier", "max_amplifier").round() as i32).max(0); + if let Some(id) = super::potions::mob_effect_id(ids[pick]) { + m.add_effect(id, ticks, amplifier); + } + } /// `minecraft:post_attack` explode effects on the attacker (wind burst): /// a burst at the player's feet that only knocks back and triggers /// blocks (`ExplodeEffect` with `block_interaction: trigger`). @@ -307,8 +351,10 @@ impl Game<'_> { continue; } hits.push(1.0 + self.world.random.next_float() * 4.0); + // ChangeItemDamage -> ItemStack.hurtAndBreak: unbreaking applies. + let loss = self.durability_loss(&stack, 2); if let Some(s) = self.armor[slot].as_mut() { - s.damage += 2; + s.damage += loss; if self .res .items() diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index bb0f3789d..41c4e1628 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -5,6 +5,7 @@ use super::{Dim, Game}; use horizon_client::{ Result, + containers::{BlockEntity, EndGateway}, environment::Environment, items::ItemStack, mesher::Vertex, @@ -27,14 +28,64 @@ const GATEWAY_Y: i32 = 75; const GATEWAY_FILE: &str = "horizon-end-gateways.json"; /// A gateway teleport waiting for its destination chunks. -#[derive(Clone, Copy, Debug)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(super) enum GatewayJob { /// TheEndGatewayBlockEntity.findOrCreateValidTeleportPos from this gateway. - Find { gateway: [i32; 3] }, + /// `exact` is the gateway's own `ExactTeleport`, read while its chunk is loaded. + Find { gateway: [i32; 3], exact: bool }, /// A known exit (exact, or findExitPosition around it). Known { exit: [i32; 3], exact: bool }, } +impl GatewayJob { + /// TheEndGatewayBlockEntity.getPortalPosition, with legacy save fallbacks. + fn for_gateway( + gateway: [i32; 3], + entity: Option<&BlockEntity>, + legacy: Option<([i32; 3], bool)>, + ) -> Self { + let configured = match entity { + Some(BlockEntity::EndGateway(g)) => g.exit_portal.map(|exit| (exit, g.exact_teleport)), + _ => None, + }; + match configured.or(legacy) { + Some((exit, exact)) => Self::Known { exit, exact }, + // Worldgen return gateways (end_gateway_return) lead exactly to the End spawn. + None if f64::from(gateway[0]).hypot(f64::from(gateway[2])) > 512.0 => Self::Known { + exit: END_SPAWN, + exact: true, + }, + None => Self::Find { + gateway, + exact: exact_teleport(entity), + }, + } + } +} + +/// `TheEndGatewayBlockEntity.exactTeleport` of the block entity at a gateway +/// (false without one). +fn exact_teleport(entity: Option<&BlockEntity>) -> bool { + matches!(entity, Some(BlockEntity::EndGateway(g)) if g.exact_teleport) +} + +/// Moves an exit that only the side file knew into the gateway's block entity, unless the block +/// entity has its own; true when it took the saved one. +fn adopt_saved_exit(entity: &mut EndGateway, (exit, exact): ([i32; 3], bool)) -> bool { + if entity.exit_portal.is_some() { + return false; + } + entity.exit_portal = Some(exit); + entity.exact_teleport = exact; + true +} + +/// The end of `getPortalPosition`: the exit itself when the teleport is exact, +/// else the spot [`Game::resolve_gateway`] finds around it (`findExitPosition`). +fn exit_target(exit: [i32; 3], exact: bool, find: impl FnOnce([i32; 3]) -> [i32; 3]) -> [i32; 3] { + if exact { exit } else { find(exit) } +} + #[derive(Default)] pub(super) struct EndState { /// Gateway position -> (exit, exact teleport); loaded lazily from the save. @@ -247,6 +298,8 @@ impl Game<'_> { layer: 2, color, light: 0, + + glint_uv: [0.0, 0.0], }); } } @@ -606,7 +659,9 @@ impl Game<'_> { /// EnderDragonFight without a dragon: once the centre of the main island /// is loaded, place the active exit portal (EndPodiumFeature) and the - /// first gateway (spawnNewGateway) if the portal is not there yet. + /// first gateway (spawnNewGateway) if the portal is not there yet. Like + /// scanState and spawnExitPortal, only while the fight has no exit portal + /// location: a podium that is later broken stays broken. fn ensure_exit_portal(&mut self) -> Result<()> { if self.travelling.is_some() || !(-1..=0).all(|cz| (-1..=0).all(|cx| self.streaming.is_lit(cx, cz))) @@ -616,8 +671,14 @@ impl Game<'_> { } let won = self.fight.previously_killed; let gateway = self.first_gateway(); - if (0..256).any(|y| &*self.block_name([0, y, 0]) == "minecraft:bedrock") { - // The podium exists; the gateway may have been out of range when it was placed. + if self.exit_portal().is_none() { + // findExitPortal remembers the location of a podium that is already there. + if let Some(level) = self.podium_level() { + self.set_exit_portal([0, level, 0]); + } + } + if self.exit_portal().is_some() { + // The gateway may have been out of range when it was placed. if won && self.world.loaded(gateway[0], gateway[2]) && &*self.block_name(gateway) != "minecraft:end_gateway" @@ -648,17 +709,40 @@ impl Game<'_> { } Ok(()) } + /// The portal level of the podium around the centre column, read from the + /// bedrock that EndPodiumFeature places (rim at the portal level, disc + /// below it, the torch column) so a broken column does not hide it. + fn podium_level(&self) -> Option { + let mut offsets: Vec<[i32; 3]> = (0..4).map(|dy| [0, dy, 0]).collect(); + for z in -4..=4i32 { + for x in -4..=4i32 { + let flat = f64::from(x * x + z * z); + if (6.25..12.25).contains(&flat) { + offsets.push([x, 0, z]); + } else if flat + 1.0 < 6.25 { + offsets.push([x, -1, z]); + } + } + } + (1..253) + .map(|y| { + let score = offsets + .iter() + .filter(|o| &*self.block_name([o[0], y + o[1], o[2]]) == "minecraft:bedrock") + .count(); + (score, y) + }) + .filter(|&(score, _)| score >= 3) + .max() + .map(|(_, y)| y) + } /// `spawnExitPortal(true)` after the dragon dies. pub(super) fn activate_exit_portal(&mut self) -> Result<()> { let origin = match self.exit_portal() { Some(o) => o, None => { - // The rim's level: the top of the bedrock column minus three. - let top = (0..256) - .rev() - .find(|&y| &*self.block_name([0, y, 0]) == "minecraft:bedrock") - .unwrap_or(64); - [0, top - 3, 0] + // The rim's level, found without assuming the centre column is intact. + [0, self.podium_level().unwrap_or(61), 0] } }; self.place_podium(origin, true) @@ -761,6 +845,11 @@ impl Game<'_> { } } } + self.world + .block_entities + .get_or_insert_with((origin[0], origin[1], origin[2]), || { + BlockEntity::EndGateway(Default::default()) + }); Ok(()) } @@ -782,8 +871,7 @@ impl Game<'_> { self.end.exits.as_mut().expect("loaded exits") } - fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> { - self.gateway_exits().insert(gateway, (exit, exact)); + fn save_gateway_exits(&mut self) -> Result<()> { let list: Vec<_> = self .gateway_exits() .iter() @@ -795,6 +883,35 @@ impl Game<'_> { Ok(()) } + /// Drops a gateway's entry from the side file: its block entity is the source of truth. + fn forget_gateway_exit(&mut self, gateway: [i32; 3]) -> Result<()> { + if self.gateway_exits().remove(&gateway).is_some() { + self.save_gateway_exits()?; + } + Ok(()) + } + + fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> { + // TheEndGatewayBlockEntity.setExitPosition (also EndGatewayFeature.knownExit). + let key = (gateway[0], gateway[1], gateway[2]); + let chunk = (gateway[0] >> 4, gateway[2] >> 4); + // The gateway's chunk can be unloaded by now (travel waits for the destination): the + // exit then waits in the side file until the gateway is used again (`gateway_job`). + if self.world.chunks.contains_key(&chunk) + && let BlockEntity::EndGateway(g) = self + .world + .block_entities + .get_or_insert_with(key, || BlockEntity::EndGateway(Default::default())) + { + g.exit_portal = Some(exit); + g.exact_teleport = exact; + self.world.modified.insert(chunk); + return self.forget_gateway_exit(gateway); + } + self.gateway_exits().insert(gateway, (exit, exact)); + self.save_gateway_exits() + } + /// EndGatewayBlock.entityInside and TheEndGatewayBlockEntity.getPortalPosition: /// travel within the End, waiting for the destination chunks to load. fn enter_gateway(&mut self, gateway: [i32; 3]) -> Result<()> { @@ -814,25 +931,39 @@ impl Game<'_> { /// its exit, or the search for one, and the spot to load before either /// is resolved ([`Game::resolve_gateway`]). pub(super) fn gateway_job(&mut self, gateway: [i32; 3]) -> (GatewayJob, Vec3) { - let known = self.gateway_exits().get(&gateway).copied(); - let job = match known { - Some((exit, exact)) => GatewayJob::Known { exit, exact }, - // Worldgen return gateways (end_gateway_return) lead exactly to the End spawn. - None if f64::from(gateway[0]).hypot(f64::from(gateway[2])) > 512.0 => { - GatewayJob::Known { - exit: END_SPAWN, - exact: true, - } + let mut known = self.gateway_exits().get(&gateway).copied(); + // Once the gateway's chunk is loaded its block entity is the source of truth: an exit the + // side file kept for it moves there, and the entry is dropped, so removing or replacing + // the exit (`/data remove block`) is not undone by an old entry. + let key = (gateway[0], gateway[1], gateway[2]); + let chunk = (gateway[0] >> 4, gateway[2] >> 4); + if let Some(saved) = known + && self.world.chunks.contains_key(&chunk) + && let BlockEntity::EndGateway(g) = self + .world + .block_entities + .get_or_insert_with(key, || BlockEntity::EndGateway(Default::default())) + { + if adopt_saved_exit(g, saved) { + self.world.modified.insert(chunk); } - None => GatewayJob::Find { gateway }, - }; + known = None; + let _ = self.forget_gateway_exit(gateway); + } + let job = GatewayJob::for_gateway( + gateway, + self.world + .block_entities + .get(&(gateway[0], gateway[1], gateway[2])), + known, + ); let destination = match job { GatewayJob::Known { exit, .. } => Vec3::new( f64::from(exit[0]) + 0.5, f64::from(exit[1]), f64::from(exit[2]) + 0.5, ), - GatewayJob::Find { gateway } => { + GatewayJob::Find { gateway, .. } => { let d = glam::DVec2::new(f64::from(gateway[0]), f64::from(gateway[2])) .normalize_or_zero() * 1024.0; @@ -889,12 +1020,10 @@ impl Game<'_> { [p[0], p[1] + 1, p[2]] }; match job { - GatewayJob::Known { exit, exact } => Ok(bottom_center(if exact { - exit - } else { - find_exit(self, exit) - })), - GatewayJob::Find { gateway } => { + GatewayJob::Known { exit, exact } => Ok(bottom_center(exit_target(exit, exact, |e| { + find_exit(self, e) + }))), + GatewayJob::Find { gateway, exact } => { // findExitPortalXZPosTentative over the loaded chunks. let dir = glam::DVec2::new(f64::from(gateway[0]), f64::from(gateway[2])) .normalize_or_zero(); @@ -954,8 +1083,11 @@ impl Game<'_> { let exit = [tallest[0], tallest[1] + 10, tallest[2]]; self.place_gateway(exit)?; self.set_gateway_exit(exit, gateway, false)?; - self.set_gateway_exit(gateway, exit, false)?; - Ok(bottom_center(find_exit(self, exit))) + // setExitPosition keeps the gateway's own exactTeleport. + self.set_gateway_exit(gateway, exit, exact)?; + Ok(bottom_center(exit_target(exit, exact, |e| { + find_exit(self, e) + }))) } } } @@ -1247,8 +1379,103 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light: full, + + glint_uv: [0.0, 0.0], }); } } } } + +#[cfg(test)] +mod tests { + use super::*; + use horizon_client::containers::EndGateway; + + #[test] + fn a_saved_exit_moves_into_a_gateway_without_one() { + let saved = ([8, 100, 0], true); + let mut bare = EndGateway::default(); + assert!(adopt_saved_exit(&mut bare, saved)); + assert_eq!(bare.exit_portal, Some([8, 100, 0])); + assert!(bare.exact_teleport); + // The block entity's own exit wins over a stale entry. + let mut own = EndGateway { + exit_portal: Some([1, 2, 3]), + ..Default::default() + }; + assert!(!adopt_saved_exit(&mut own, saved)); + assert_eq!(own.exit_portal, Some([1, 2, 3])); + assert!(!own.exact_teleport); + } + + #[test] + fn a_new_exit_keeps_the_gateways_exact_teleport() { + let exact = BlockEntity::EndGateway(EndGateway { + exact_teleport: true, + ..Default::default() + }); + let plain = BlockEntity::EndGateway(EndGateway::default()); + assert!(exact_teleport(Some(&exact))); + assert!(!exact_teleport(Some(&plain))); + assert!(!exact_teleport(None)); + assert!(!exact_teleport(Some(&BlockEntity::DaylightDetector))); + let exit = [8, 100, 0]; + // Exact: the exit itself, nothing is searched for. + assert_eq!(exit_target(exit, true, |_| panic!("searched")), exit); + assert_eq!( + exit_target(exit, false, |e| [e[0], e[1] + 11, e[2]]), + [8, 111, 0] + ); + } + + #[test] + fn end_gateway_job_prefers_block_entity_then_legacy_then_heuristic() { + let gateway = [702, 100, 0]; + let exit = [8, 100, 0]; + for exact in [true, false] { + let entity = BlockEntity::EndGateway(EndGateway { + exit_portal: Some(exit), + exact_teleport: exact, + ..Default::default() + }); + assert_eq!( + GatewayJob::for_gateway(gateway, Some(&entity), Some((END_SPAWN, !exact))), + GatewayJob::Known { exit, exact }, + ); + } + let empty = BlockEntity::EndGateway(EndGateway::default()); + for entity in [None, Some(&empty)] { + assert_eq!( + GatewayJob::for_gateway(gateway, entity, Some((exit, false))), + GatewayJob::Known { exit, exact: false } + ); + assert_eq!( + GatewayJob::for_gateway(gateway, entity, None), + GatewayJob::Known { + exit: END_SPAWN, + exact: true + } + ); + let nearby = [96, 75, 0]; + let exact = BlockEntity::EndGateway(EndGateway { + exact_teleport: true, + ..Default::default() + }); + assert_eq!( + GatewayJob::for_gateway(nearby, Some(&exact), None), + GatewayJob::Find { + gateway: nearby, + exact: true + } + ); + assert_eq!( + GatewayJob::for_gateway(nearby, entity, None), + GatewayJob::Find { + gateway: nearby, + exact: false + } + ); + } + } +} diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs index b2191aa9f..88ef4263a 100644 --- a/crates/horizon-client/src/game/explosion.rs +++ b/crates/horizon-client/src/game/explosion.rs @@ -307,6 +307,12 @@ impl Game<'_> { ) { outcome = o; + // dealDefaultKnockback's `indicateDamage` points at the blast + // (the source position), not the no-direction fallback. + if o.knockback && o.blocked <= 0.0 { + p.health + .indicate_damage(center[0] - feet[0], center[2] - feet[2], p.yaw); + } } if !spectator && !(creative && flying) { p.velocity = Vec3::new( @@ -394,7 +400,14 @@ impl Game<'_> { // it kills drop its charged-creeper loot (`Creeper.killedEntity`). let source = horizon_client::mobs::Damage { kind: horizon_client::mobs::DamageKind::Explosion, - attacker: exploding.map(horizon_client::mobs::Who::Mob), + // A projectile's owner (`getIndirectSourceEntity`), else + // the exploding mob itself. + attacker: self + .combat + .explosion_owner + .or(exploding) + .filter(|&o| o != m.id) + .map(horizon_client::mobs::Who::Mob), from: Some(center), }; if hurtable && !m.damage(damage(dist, exposure), source) { @@ -490,6 +503,15 @@ impl Game<'_> { ); } } + /// Runs an explosion whose source empties the hives it destroys + /// (`BeehiveBlock.getDrops`: primed TNT, creeper, wither skull, wither, + /// TNT minecart). + pub(super) fn with_hive_emptying_blast(&mut self, blast: impl FnOnce(&mut Self) -> R) -> R { + self.combat.hive_emptying_blast = true; + let result = blast(self); + self.combat.hive_emptying_blast = false; + result + } /// `Level.explode` on the server: positions, entities, blocks, fire; then /// the client's explosion sound. pub(super) fn server_explode( @@ -606,6 +628,22 @@ impl Game<'_> { // Block.onExplosionHit: the drops copy from the block entity, which // then spills its contents as the block turns to air. let key = (pos[0], pos[1], pos[2]); + let is_hive = matches!(&*name, "minecraft:beehive" | "minecraft:bee_nest"); + // BeehiveBlock.getDrops: the bees of a hive blown up by TNT, a + // creeper, a wither skull, a wither or a TNT minecart come out. + if is_hive && self.combat.hive_emptying_blast { + let facing = self + .pack + .assets + .registry + .state(state) + .and_then(|s| s.properties.get("facing").cloned()); + self.empty_hive( + pos, + horizon_client::beehive::facing_step(facing.as_deref()), + horizon_client::beehive::Release::Emergency, + ); + } if let Some(entity) = self.world.block_entities.get(&key).cloned() { let custom = self.world.block_names.get(&key).cloned(); self.pending.record(pos, &entity, &name, custom); @@ -638,6 +676,10 @@ impl Game<'_> { } self.pending.clear(pos); self.level_set(pos, self.world.air)?; + // BeehiveBlock.onExplosionHit: the bees about turn on the player. + if is_hive { + self.anger_nearby_bees(pos); + } // TntBlock.wasExploded: new PrimedTnt (its push drawn first), then // getRandomShortFuse(80); no game event. if is_tnt && self.ui.rules.bool("tnt_explodes") { diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs index c42dad427..e3f4fd025 100644 --- a/crates/horizon-client/src/game/fishing.rs +++ b/crates/horizon-client/src/game/fishing.rs @@ -2,6 +2,7 @@ //! bobbing, lure and bite timers, open water, hooking mobs, retrieving the //! `gameplay/fishing` loot) and `FishingHookRenderer` (bobber and line). use super::{Game, view_vector}; +use horizon_client::advancements::EntityView; use horizon_client::lan::{entity::States, hub::Hub}; use horizon_client::{ blocks::Fluid, @@ -77,7 +78,7 @@ impl Game<'_> { let at = [p.position.x, p.position.y, p.position.z]; let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8); if self.hook.is_some() { - let damage = self.retrieve_hook(); + let damage = self.retrieve_hook(stack); self.damage_held(damage); self.audio.play( "minecraft:entity.fishing_bobber.retrieve", @@ -143,7 +144,7 @@ impl Game<'_> { true } /// `FishingHook.retrieve`: the rod damage it costs. - fn retrieve_hook(&mut self) -> u32 { + fn retrieve_hook(&mut self, rod: &ItemStack) -> u32 { let Some(hook) = self.hook.take() else { return 0; }; @@ -167,6 +168,15 @@ impl Game<'_> { item.velocity = pulled(item.velocity); hooked_item = true; } + // CriteriaTriggers.FISHING_ROD_HOOKED with no items. + let hooked = self + .mobs + .iter() + .find(|m| m.id == id) + .map(|m| self.mob_entity(m)); + if let Some(hooked) = hooked { + self.trigger_fishing_rod_hooked(rod, &hooked, &[]); + } // `hookedIn instanceof ItemEntity ? 3 : 5`. damage = if hooked_item { 3 } else { 5 }; } else if hook.nibble > 0 { @@ -191,6 +201,7 @@ impl Game<'_> { Some(hook.open_water), ); self.world.random = random; + let mut caught = Vec::new(); for stack in items { // FishingHook.retrieve: fish_caught for each catch in #minecraft:fishes. if self @@ -222,6 +233,7 @@ impl Game<'_> { if let Some(potion) = &stack.potion { item = item.with_potion(potion); } + caught.push(item.clone()); let (dx, dy, dz) = ( owner.x - hook.position.x, owner.y - hook.position.y, @@ -241,6 +253,15 @@ impl Game<'_> { let xp = self.world.random.next_int_bound(6).unwrap_or(0) as u32 + 1; self.spawn_orbs([owner.x, owner.y + 0.5, owner.z + 0.5], xp); } + // CriteriaTriggers.FISHING_ROD_HOOKED: the hook itself is the entity. + let bobber = EntityView { + kind: "minecraft:fishing_bobber".into(), + position: [hook.position.x, hook.position.y, hook.position.z], + on_ground: hook.on_ground, + fishing_open_water: Some(hook.open_water), + ..Default::default() + }; + self.trigger_fishing_rod_hooked(rod, &bobber, &caught); damage = 1; } if hook.on_ground { @@ -645,6 +666,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light: packed, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/fov.rs b/crates/horizon-client/src/game/fov.rs index 95e2e1e6e..364f89189 100644 --- a/crates/horizon-client/src/game/fov.rs +++ b/crates/horizon-client/src/game/fov.rs @@ -114,7 +114,7 @@ impl Game<'_> { living: Some(HurtBob { hurt_time: p.health.hurt_animation_time as f32 - partial, hurt_duration: hurt.hurt_duration, - hurt_dir: 0.0, + hurt_dir: p.health.hurt_dir, death_time: self.death_time().map(|t| t as f32 + partial), }), player: Some(( diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs index 946d1c017..f4721ae26 100644 --- a/crates/horizon-client/src/game/frames.rs +++ b/crates/horizon-client/src/game/frames.rs @@ -378,6 +378,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light, + + glint_uv: [0.0, 0.0], }); } }; diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs index d91d3b979..60869952f 100644 --- a/crates/horizon-client/src/game/hand.rs +++ b/crates/horizon-client/src/game/hand.rs @@ -3,7 +3,7 @@ //! `continueAttack`, `MultiPlayerGameMode` block breaking), the arm swing //! (`LivingEntity.SwingState`) and the first-person equip heights //! (`FirstPersonHandsAndItems`) with the item swap ticker they read. -use super::{Game, Mining, Screen}; +use super::{Game, Mining, Screen, minecarts::CartKind}; use horizon_client::{ Result, attack_strength::HeldStack, @@ -289,6 +289,64 @@ impl Game<'_> { // Only alive mobs are hit, so a picked living entity is alive. Some(true) } + /// `Hud.canRenderCrosshairForSpectator` for the nearest hit in reach: an + /// entity that is a `MenuProvider` (a chest or hopper minecart, a chest + /// boat), or a block whose `showAsInteractableInSpectatorMode` holds. + pub(super) fn spectator_crosshair(&self) -> bool { + let cart = self.cart_hit().map(|(i, d)| { + let kind = &self.carts[i].kind; + (d, matches!(kind, CartKind::Chest | CartKind::Hopper)) + }); + let boat = self.boat_hit().map(|(i, d)| (d, self.boats[i].chest)); + let others = [ + self.mob_hit().map(|h| h.1), + self.armor_stand_hit().map(|h| h.1), + self.cushion_hit().map(|h| h.1), + self.painting_hit().map(|h| h.1), + self.frame_hit().map(|h| h.1), + self.dragon_hit().map(|h| h.1), + ]; + let nearest = cart + .into_iter() + .chain(boat) + .chain(others.into_iter().flatten().map(|d| (d, false))) + .min_by(|a, b| a.0.total_cmp(&b.0)); + if let Some((distance, menu)) = nearest + && self.before_block(distance) + { + return menu; + } + let Some(hit) = self.pick() else { + return false; + }; + let name = &*self + .res + .facts() + .get(self.world.block(hit.pos[0], hit.pos[1], hit.pos[2])) + .name; + let name = name.trim_start_matches("minecraft:"); + match name { + // BlockBehaviour.getMenuProvider and `instanceof Portal`. + "crafting_table" | "enchanting_table" | "anvil" | "chipped_anvil" | "damaged_anvil" + | "stonecutter" | "loom" | "cartography_table" | "grindstone" | "smithing_table" + | "barrel" | "furnace" | "blast_furnace" | "smoker" | "brewing_stand" | "hopper" + | "dispenser" | "dropper" | "crafter" | "lectern" | "beacon" | "nether_portal" + | "end_portal" | "end_gateway" => true, + // ChestBlock.getMenuProvider: none while a redstone conductor + // sits on top of either half (a sitting cat aside). + "chest" | "trapped_chest" => { + let key = (hit.pos[0], hit.pos[1], hit.pos[2]); + let blocked = |p: (i32, i32, i32)| { + let above = self.world.block(p.0, p.1 + 1, p.2); + self.res.behaviours().facts(above).flags + & horizon_world::level::data::state_flags::CONDUCTOR + != 0 + }; + !blocked(key) && self.chest_other_half(key).is_none_or(|o| !blocked(o)) + } + _ => name.ends_with("shulker_box"), + } + } /// `Attributes.ATTACK_SPEED` with the main-hand item's modifier. pub(super) fn main_hand_attack_speed(&self) -> f64 { horizon_client::attack_strength::BASE_ATTACK_SPEED diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index 7d81c971d..df40ff377 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -420,6 +420,8 @@ impl Game<'_> { s.flags.published.store(0, Ordering::Relaxed); } if let Some(mut host) = self.lan.take() { + // PlayerList.removeAll: the owner and every guest leave the game. + host.award_leave_game_to_all(); for g in &host.hub.guests { self.save_guest(&host, g); } diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index f6edd746e..efb83e5db 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -298,8 +298,32 @@ impl Game<'_> { x, y, self.started.elapsed().as_secs_f32(), + self.settings.file.double("glintSpeed") as f32, + self.settings.file.double("glintStrength") as f32, ); } + /// The `GLINT_TEXTURING` inputs the atlas and options provide. + pub(super) fn glint(&self) -> Option { + self.gui + .atlas + .sprites + .get("misc/enchanted_glint_item") + .copied() + .map(|_| item_render::Glint { + speed: self.settings.file.double("glintSpeed") as f32, + alpha: self.settings.file.double("glintStrength") as f32, + millis: self.started.elapsed().as_secs_f32() * 1000.0, + scale: 0.5, + }) + } + /// The glint scroll phase shared by world items and armour + /// (`item_render::Glint::scroll_ticks`). + pub(super) fn glint_ticks(&self) -> f32 { + item_render::Glint::scroll_ticks( + self.started.elapsed().as_secs_f32() * 1000.0, + self.settings.file.double("glintSpeed") as f32, + ) + } /// Submit a resolved item under `pose` (camera-relative) at `light` /// (packed lightmap coordinates). pub(super) fn submit_item_world( @@ -313,6 +337,7 @@ impl Game<'_> { out, light, lights: Some(diffuse_lights(self.dim == Dim::Nether)), + glint: self.glint(), }; state.submit( &self.pack.item_renderer, @@ -334,6 +359,7 @@ impl Game<'_> { out, light, lights: None, + glint: self.glint(), }; state.submit( &self.pack.item_renderer, diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index fb637e2db..506c6c419 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -92,6 +92,33 @@ pub(super) struct LanHost { states: lan::entity::States, } +impl LanHost { + /// `PlayerList.remove`: `player.awardStat(Stats.LEAVE_GAME)` before the + /// player is saved. Once per guest, however often they are saved. + pub(super) fn award_leave_game(&mut self, conn: u32) { + if let Some(play) = self.play.get_mut(&conn) + && !play.left_game + { + play.left_game = true; + play.stats.custom("leave_game", 1); + } + } + + /// `PlayerList.removeAll`: every player who joined leaves with the world. + pub(super) fn award_leave_game_to_all(&mut self) { + let conns: Vec = self + .hub + .guests + .iter() + .filter(|g| g.placed) + .map(|g| g.conn) + .collect(); + for conn in conns { + self.award_leave_game(conn); + } + } +} + /// The player who owns an integrated server's world: a guest whose state is /// the world's own player (`players/data/.dat`), as in /// single player. @@ -162,6 +189,7 @@ fn mob_meta( m: &Mob, hub: &Hub, player_entity: Option, + game_time: i64, meta: &mut Vec<(u8, i32, Value)>, defaults: &mut Vec<(u8, i32, Value)>, ) { @@ -172,6 +200,12 @@ fn mob_meta( if shared != 0 { meta.push((0, serializer::BYTE, Value::Byte(shared))); } + // Entity.DATA_POSE: the pose the species keeps in its own fields (a + // pose back at standing goes out by the entity's own default). + let pose = horizon_client::mobs::sync::pose_id(m); + if pose != 0 { + meta.push((6, serializer::POSE, Value::Id(i32::from(pose)))); + } if let Some(name) = &m.custom_name { meta.push(( 2, @@ -401,6 +435,41 @@ fn mob_meta( } defaults.push((17, serializer::BYTE, Value::Byte(0))); } + // Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace. + "minecraft:warden" => { + let anger = e.warden.as_ref().map_or(0, |w| w.client_anger); + if anger != 0 { + meta.push((16, serializer::INT, Value::Int(anger))); + } + defaults.push((16, serializer::INT, Value::Int(0))); + } + // Sniffer.DATA_STATE (after AgeableMob's two). + "minecraft:sniffer" => { + if e.variant != 0 { + meta.push(( + 18, + serializer::SNIFFER_STATE, + Value::Id(i32::from(e.variant)), + )); + } + defaults.push((18, serializer::SNIFFER_STATE, Value::Id(0))); + } + // Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID (16 + // for none). + "minecraft:shulker" => { + if e.variant3 != 0 { + meta.push((16, serializer::DIRECTION, Value::Id(i32::from(e.variant3)))); + } + defaults.push((16, serializer::DIRECTION, Value::Id(0))); + if e.counter != 0 { + meta.push((17, serializer::BYTE, Value::Byte(e.counter as i8))); + } + defaults.push((17, serializer::BYTE, Value::Byte(0))); + if e.color != 16 { + meta.push((18, serializer::BYTE, Value::Byte(e.color as i8))); + } + defaults.push((18, serializer::BYTE, Value::Byte(16))); + } // Enderman.DATA_CARRY_STATE. "minecraft:enderman" => { if let Some(state) = e.carried { @@ -413,6 +482,18 @@ fn mob_meta( } _ => {} } + // Camel.DASH and LAST_POSE_CHANGE_TICK (after AbstractHorse's flags). + if horizon_client::mobs::camel::is_camel(m.species()) { + if e.flag2 { + meta.push((19, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((19, serializer::BOOLEAN, Value::Bool(false))); + let tick = horizon_client::mobs::camel::synced_pose_tick(m, game_time); + if tick != 0 { + meta.push((20, serializer::LONG, Value::Long(tick))); + } + defaults.push((20, serializer::LONG, Value::Long(0))); + } } /// What a client shakes a mob by: Entity.DATA_TICKS_FROZEN (7), whose full @@ -731,6 +812,7 @@ impl Game<'_> { let Some(mut host) = self.lan.take() else { return; }; + host.award_leave_game_to_all(); for g in &host.hub.guests { self.save_guest(&host, g); } @@ -938,7 +1020,7 @@ impl Game<'_> { out.clear(); for m in self.mobs.iter().filter(|m| !m.removed) { // The lead's holder: the player the mob sees (a guest, else the - // host) or another mob. A fence knot isn't an entity here. + // host), another mob or a fence knot (game/lan_entities.rs). let player_entity = mob_players .get(&m.id) .and_then(|conn| hub.guest(*conn)) @@ -947,7 +1029,7 @@ impl Game<'_> { let leash = m.extra.leash.and_then(|h| match h { Holder::Player => player_entity, Holder::Mob(id) => Some(id as i32), - Holder::Knot(_) => None, + Holder::Knot(p) => self.knot_ids.get(&p).map(|&id| id as i32), }); let e = out.add(m.id as i32, entity_uuid(m.id), m.kind.id.as_str()); e.position = [m.position.x, m.position.y, m.position.z]; @@ -955,7 +1037,14 @@ impl Game<'_> { e.on_ground = m.on_ground; e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z]; e.needs_sync = m.needs_sync; - mob_meta(m, hub, player_entity, &mut e.meta, &mut e.defaults); + mob_meta( + m, + hub, + player_entity, + self.world.game_time, + &mut e.meta, + &mut e.defaults, + ); mob_freeze_meta(m, &mut e.meta, &mut e.defaults); mob_equipment(m, hub, &mut e.equipment); self.mob_attributes(m, &mut e.attributes); @@ -1080,6 +1169,8 @@ impl Game<'_> { self.ui.rules.bool("player_movement_check"), self.ui.rules.bool("elytra_movement_check"), ); + host.hub + .set_immediate_respawn(self.ui.rules.bool("immediate_respawn")); // A server with several levels runs a pass for each // (`tick_server`): the network is read once, before the first. let pass = self.level_pass; @@ -1150,6 +1241,9 @@ impl Game<'_> { } } self.lan_crafting_left(&mut host, &mut guest); + if guest.placed { + host.award_leave_game(guest.conn); + } self.save_guest(&host, &guest); host.models.remove(&guest.conn); host.play.remove(&guest.conn); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index f9a61f280..dde9b590d 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -74,7 +74,12 @@ pub(super) struct GuestPlay { potions: super::potions::BodyPotions, /// `ServerPlayer.getStats` and the inventory `inventory_changed` last saw. pub(super) stats: super::stats::Stats, + /// `Stats.LEAVE_GAME` is counted: a guest is saved more than once on the + /// way out, the statistic is awarded once (`LanHost::award_leave_game`). + pub(super) left_game: bool, last_inventory: u64, + /// `ServerPlayer.levitationStartPos` and `levitationStartTime`. + levitation: Option<([f64; 3], u64)>, /// `Entity.portalProcess` and `portalCooldown` (game/server_travel.rs). pub(super) portal: horizon_client::nether_portal::PortalState, /// `ServerPlayer.wonGame`: the End poem is showing, the player waits for @@ -158,6 +163,7 @@ pub(super) struct GuestSwap { host_ender: Option<(i32, i32, i32)>, adv_loaded: bool, last_inventory: u64, + levitation: Option<([f64; 3], u64)>, death_cause: Option, /// The guest's own damage record, in place while they act. combat: super::combat::CombatTracker, @@ -386,6 +392,7 @@ impl Game<'_> { std::mem::swap(&mut self.hook, &mut play.hook); let adv_loaded = std::mem::replace(&mut self.adv.loaded, true); let last_inventory = std::mem::replace(&mut self.adv.last_inventory, play.last_inventory); + let levitation = std::mem::replace(&mut self.adv.levitation, play.levitation); let death_cause = std::mem::replace(&mut self.ui.death_cause, play.death_cause.take()); let acting = ( self.lan_acting.replace(conn), @@ -457,6 +464,7 @@ impl Game<'_> { host_ender, adv_loaded, last_inventory, + levitation, death_cause, acting, packets, @@ -516,6 +524,7 @@ impl Game<'_> { host_ender, adv_loaded, last_inventory, + levitation, death_cause, combat, acting, @@ -638,6 +647,7 @@ impl Game<'_> { std::mem::swap(&mut self.hook, &mut play.hook); self.adv.loaded = adv_loaded; play.last_inventory = std::mem::replace(&mut self.adv.last_inventory, last_inventory); + play.levitation = std::mem::replace(&mut self.adv.levitation, levitation); let stat_events = std::mem::take(&mut play.stats.events); let name = g.name.clone(); self.potions.swap_player(&mut g.effects, &mut play.potions); @@ -681,6 +691,13 @@ impl Game<'_> { g.sprinting = false; } m.sprinting = false; + // ServerPlayer.indicateDamage: the hit's direction to the player. + if let Some(yaw) = m.health.indicated_dir.take() { + g.send(&C::HurtAnimation(play::HurtAnimation { + id: g.entity_id, + yaw, + })); + } let teleported = std::mem::take(&mut m.teleported); let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum(); g.motion = Some(Box::new(m)); @@ -882,13 +899,17 @@ impl Game<'_> { } /// The guest's open container is closing (`AbstractContainerMenu.removed`): - /// it no longer counts among the openers of the lid. + /// it no longer counts among the openers of the lid, and the lid's close + /// sound is played for everyone around (`ChestBlockEntity.onClose`, a + /// `playSound` with no player), the guest included, once the last opener + /// has left. pub(super) fn guest_container_closed(&mut self, host: &mut LanHost, conn: u32) { if let Some(g) = host.hub.guest(conn) && let Some(pos) = g.menu.as_ref().and_then(|m| m.pos) && !g.spectator() + && self.container_openers_changed(pos, false) { - self.container_openers_changed(pos, false); + self.container_edge_sound(pos, false); } } @@ -982,6 +1003,20 @@ impl Game<'_> { // The pause between two blocks is the client's (MultiPlayerGameMode's // destroyDelay); the server digs from the START it receives. play.destroy_delay = 0; + // ServerPlayerGameMode.handleBlockBreakAction: a survival START + // attacks the block at once, so a tap released in the same tick + // still plays a note. The dig is marked begun for tick_mining. + let pos = a.pos; + self.as_guest(host, conn, |g| { + if g.may_build() && !g.creative { + let _ = g.attack_block(pos); + g.mining = Some(Mining { + pos, + progress: 0.0, + ticks: 0, + }); + } + }); } 1 => {} 3 => { diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs index db6235c4d..461eaf5e1 100644 --- a/crates/horizon-client/src/game/lan_crafting.rs +++ b/crates/horizon-client/src/game/lan_crafting.rs @@ -127,9 +127,18 @@ impl Game<'_> { } let dropped = std::mem::take(&mut menu.dropped); let equipped = std::mem::take(&mut menu.equipped); + let brewed = std::mem::take(&mut menu.brewed); menu.drops.clear(); menu.crafted.clear(); store_player(menu, &mut host.hub.guests[gi]); + if !brewed.is_empty() { + let conn = host.hub.guests[gi].conn; + self.as_guest(host, conn, |g| { + for stack in &brewed { + g.trigger_brewed_potion(stack); + } + }); + } if !equipped.is_empty() { let conn = host.hub.guests[gi].conn; self.as_guest(host, conn, |g| { @@ -576,16 +585,18 @@ impl Game<'_> { /// A guest left: what their crafting grids and workstation held goes back into their /// inventory before it is saved (dropped where they stood if full). pub(super) fn lan_crafting_left(&mut self, host: &mut LanHost, g: &mut Guest) { - let play = host.play.remove(&g.conn); + // The guest's play state stays: their statistics are awarded and saved + // after this (`HostEvent::Left`), which removes it. + let play = host.play.get_mut(&g.conn); let mut grid: Vec = g.craft_grid.iter_mut().filter_map(Option::take).collect(); g.craft_result = None; if let Some(play) = play { - if let Some((_, _, menu, _)) = play.crafting.table { + if let Some((_, _, menu, _)) = play.crafting.table.take() { grid.extend((1..10).filter_map(|s| menu.slot(s).cloned())); } // A workstation's inputs too. - if let Some(station) = &play.station { - grid.extend(super::lan_stations::station_inputs(station)); + if let Some(station) = play.station.take() { + grid.extend(super::lan_stations::station_inputs(&station)); } } if grid.is_empty() { diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index f5e35631d..ecfa0aea5 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -225,6 +225,16 @@ impl Game<'_> { } out.push(e); } + for (p, &id) in &self.knot_ids { + // LeashFenceKnotEntity.getAddEntityPacket: the fence's block. + out.push(state( + id, + "minecraft:leash_knot", + p.map(f64::from), + 0.0, + false, + )); + } for p in &self.paintings { let mut e = state(p.id, "minecraft:painting", p.pos.map(f64::from), 0.0, false); // Direction.get2DDataValue (south 0, west 1, north 2, east 3) to its @@ -270,6 +280,24 @@ impl Game<'_> { /// Gives the entities Horizon keeps without an id one (`Entity.id`, from /// the same counter as the rest) before they are first tracked. pub(super) fn lan_assign_ids(&mut self) { + // LeashFenceKnotEntity: one per fence post with a lead on it + // (`notifyLeasheeRemoved` discards it once the last lead is gone). + let knots: Vec<[i32; 3]> = self + .mobs + .iter() + .filter(|m| !m.removed) + .filter_map(|m| match m.extra.leash { + Some(horizon_client::mobs::leash::Holder::Knot(p)) => Some(p), + _ => None, + }) + .collect(); + self.knot_ids.retain(|p, _| knots.contains(p)); + for p in knots { + self.knot_ids.entry(p).or_insert_with(|| { + self.next_entity += 1; + self.next_entity + }); + } let next = &mut self.next_entity; let mut give = |id: &mut u32| { if *id == 0 { diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index 973e645d0..49eedbe55 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -5,7 +5,7 @@ //! (hits, pushes, fire, its projectiles) runs with that guest swapped in. use super::{Game, lan::LanHost}; use horizon_client::{ - mobs::{Mob, MobEvent, PlayerView, Who}, + mobs::{Mob, MobEvent, PlayerView, Species, Who}, projectiles::{Hit, Projectile}, }; use horizon_core::geometry::{Aabb, Vec3}; @@ -28,6 +28,22 @@ pub(super) fn player_for( ) -> Option { let targeting = m.ai.target == Some(Who::Player) || m.ai.last_hurt_by == Some(Who::Player) && m.age as i32 - m.ai.last_hurt_by_time <= 100; + // A tame wolf or cat sees its owner (`TamableAnimal.getOwner`), while they + // are in play, whoever is nearer. Not while it targets or was just hurt by + // a player: then `Who::Player` is that attacker, whoever it is, and the + // owner goals ignore it until the wolf lets go. + if !targeting + && matches!(m.species(), Species::Wolf | Species::Cat) + && m.extra.tame + && let Some(owner) = m.extra.owner + { + if host.is_some_and(|v| v.alive && v.uuid == owner) { + return None; + } + if let Some((conn, _)) = guests.iter().find(|(_, v)| v.alive && v.uuid == owner) { + return Some(*conn); + } + } choose(m.position, targeting, host, guests, bound) } @@ -358,6 +374,7 @@ mod tests { off_hand: None, head: None, armor_cover: 0.0, + invisible: false, spectator: false, gold_armor: false, hurt_by: None, diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs index 5554d6f21..aa5981e0b 100644 --- a/crates/horizon-client/src/game/lan_particles.rs +++ b/crates/horizon-client/src/game/lan_particles.rs @@ -247,14 +247,10 @@ impl Game<'_> { return; }; let (d, s) = (p.dist.map(f64::from), p.max_speed.map(f64::from)); - // ClientLevel.addParticle: the camera's 32 blocks unless the packet - // (`force`) or the type overrides the limiter. + // ClientLevel.addParticle: the camera's 32 blocks and the Particles + // option, unless the packet or the type overrides the limiter. let add = |particles: &mut horizon_client::particles::ParticleEngine, at, v| { - if p.override_limiter { - particles.create(&options, at, v); - } else { - particles.add(&options, at, v); - } + particles.add_with(&options, at, v, p.override_limiter, p.always_show); }; if p.count == 0 { add( diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index aa969305f..937fa28f4 100644 --- a/crates/horizon-client/src/game/lan_pvp.rs +++ b/crates/horizon-client/src/game/lan_pvp.rs @@ -267,6 +267,30 @@ impl Game<'_> { } else { Default::default() }; + // ServerPlayer.awardKillScore: the blow that kills a player. + if hurt { + let died = match victim { + // A totem that fired is applied on the next tick_totem, so the + // victim is still at zero health but is not dying. + Victim::Host => self + .player + .as_ref() + .is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used), + Victim::Guest(conn) => host + .hub + .guest(conn) + .and_then(|g| g.motion.as_deref()) + .is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used), + }; + if died { + match s.attacker { + Some(conn) => { + self.as_guest(host, conn, |g| g.stats.custom("player_kills", 1)); + } + None => self.stats.custom("player_kills", 1), + } + } + } if hurt && (s.crit || s.magic) { let target = match victim { Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)), diff --git a/crates/horizon-client/src/game/leads.rs b/crates/horizon-client/src/game/leads.rs index ca70351c6..877609d57 100644 --- a/crates/horizon-client/src/game/leads.rs +++ b/crates/horizon-client/src/game/leads.rs @@ -386,6 +386,8 @@ impl Game<'_> { layer: 0, color, light: packed, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs index 8a5c0bed8..7c6fb5598 100644 --- a/crates/horizon-client/src/game/level_particles.rs +++ b/crates/horizon-client/src/game/level_particles.rs @@ -12,19 +12,17 @@ use horizon_world::registry::BlockStateId; impl Game<'_> { pub(super) fn dragon_egg_particles(&mut self, pos: [i32; 3], data: i32) { - self.particles - .block_teleportation(pos, data, [16, 8, 16], self.settings.particles); + self.particles.block_teleportation(pos, data, [16, 8, 16]); } /// Event 2016: `Shulker.teleportSomewhere`'s particles between the /// shell's old and new cells. pub(super) fn shulker_teleport_particles(&mut self, pos: [i32; 3], data: i32) { - self.particles - .block_teleportation(pos, data, [8, 8, 8], self.settings.particles); + self.particles.block_teleportation(pos, data, [8, 8, 8]); } /// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles. pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) { self.particles - .block_teleportation(pos, data, [127, 127, 127], self.settings.particles); + .block_teleportation(pos, data, [127, 127, 127]); } /// `LevelEventHandler.levelEvent` 3002 to 3005, drawing from the client /// level's random. diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs index b0c10e34b..ab316c4c6 100644 --- a/crates/horizon-client/src/game/levels.rs +++ b/crates/horizon-client/src/game/levels.rs @@ -66,6 +66,8 @@ pub(super) struct Parked { tnts: Vec, hoppers: HashMap<(i32, i32, i32), machines::HopperState>, mobs: Vec, + /// The entity ids of the level's fence knots (`knot_ids`). + knot_ids: HashMap<[i32; 3], u32>, projectiles: Vec, dropped: Vec, orbs: Vec, @@ -170,6 +172,7 @@ impl Game<'_> { tnts: Vec::new(), hoppers: HashMap::new(), mobs: Vec::new(), + knot_ids: HashMap::new(), projectiles: Vec::new(), dropped: Vec::new(), orbs: Vec::new(), @@ -223,6 +226,7 @@ impl Game<'_> { swap(&mut self.tnts, &mut p.tnts); swap(&mut self.hoppers, &mut p.hoppers); swap(&mut self.mobs, &mut p.mobs); + swap(&mut self.knot_ids, &mut p.knot_ids); swap(&mut self.creatures.projectiles, &mut p.projectiles); swap(&mut self.dropped, &mut p.dropped); swap(&mut self.orbs, &mut p.orbs); diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 0224f67e3..921244e6d 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -278,6 +278,13 @@ impl Game<'_> { } self.strike_rod(b.at); } + // LightningBolt.tick runs clearCopperOnLightningStrike for + // every server bolt, a skeleton trap's visual one included; + // a client's copy of a server bolt (spawn_remote_bolt) only + // flashes. + if self.remote.is_none() { + self.bolt_clear_copper(b.at); + } } b.life -= 1; if b.life < 0 { @@ -334,6 +341,16 @@ impl Game<'_> { self.level_event_at(3002, p, axis); } } + /// `LightningBolt.clearCopperOnLightningStrike` at the block the bolt struck. + fn bolt_clear_copper(&mut self, at: [f64; 3]) { + let p = BlockPos::new( + at[0].floor() as i32, + (at[1] - 1.0e-6).floor() as i32, + at[2].floor() as i32, + ); + self.with_level(|b, level, ticks| b.lightning_clear_copper(level, ticks, p)); + let _ = self.process_level_events(); + } /// `thunderHit` for entities within 3 blocks (up to 9 above). fn thunder_hit(&mut self, b: &mut Bolt) { let at = b.at; diff --git a/crates/horizon-client/src/game/llamas.rs b/crates/horizon-client/src/game/llamas.rs index 1ce518f31..080343952 100644 --- a/crates/horizon-client/src/game/llamas.rs +++ b/crates/horizon-client/src/game/llamas.rs @@ -25,11 +25,13 @@ impl Game<'_> { }; let m = &mut self.mobs[index]; let mut used = false; + let mut loved = false; if item == "minecraft:hay_block" && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0 { m.extra.in_love = 600; m.extra.love_player = true; used = true; + loved = true; } if m.health < m.attrs.max_health { m.health = (m.health + heal).min(m.attrs.max_health); @@ -57,6 +59,10 @@ impl Game<'_> { if !used { return false; } + // Animal.setInLove: entity event 18. + if loved { + self.mob_event_particles(self.mobs[index].id, 18); + } self.llama_sound(index, "entity.llama.eat", 1.0); self.consume_held(); true diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index bb936744b..78dbfe66b 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -626,46 +626,8 @@ impl Game<'_> { /// `HopperBlockEntity.suckInItems`: from the container above, or item entities. fn hopper_suck(&mut self, pos: Pos, hopper: &View) -> bool { let above = (pos.0, pos.1 + 1, pos.2); - let c = self.containers(); - if let Some(source) = c.view(above, false) { - if let Kind::Composter(level) = source.kind { - if level != 8 { - return false; - } - // tryTakeInItemFromSlot on the OutputContainer: removeItem calls - // its setChanged, which empties the composter, and so does the - // second setChanged after the move or, when the hopper has no - // room, the setItem putting the bone meal back into the detached - // container (whose bone meal is lost with it). - let bone_meal = c.bone_meal.clone(); - let at = BlockPos::new(above.0, above.1, above.2); - self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at)); - let moved = self.add_item(None, hopper, bone_meal, None).is_none(); - self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at)); - self.world.modified.insert((above.0 >> 4, above.2 >> 4)); - return moved; - } - let source_hopper = (source.kind == Kind::Hopper).then_some(above); - for slot in source.slots_for_face(Some(Direction::Down)) { - let c = self.containers(); - let Some(stack) = c.get(&source, slot) else { - continue; - }; - if !c.can_take(&source, slot, stack, Direction::Down) { - continue; - } - let Some(one) = self.take_one(&source, slot) else { - continue; - }; - match self.add_item(source_hopper, hopper, one, None) { - None => { - self.view_changed(&source); - return true; - } - Some(rest) => self.put_back(&source, slot, rest), - } - } - return false; + if let Some(took) = self.suck_from_container(above, hopper) { + return took; } let above_state = self.world.block(above.0, above.1, above.2); let blocked = self.res.facts().get(above_state).full_collision @@ -695,6 +657,56 @@ impl Game<'_> { { return false; } + self.suck_item_entities(hopper, min, max) + } + /// The container half of `HopperBlockEntity.suckInItems`: one item from the + /// container at `above`, through its bottom face. `None` when there is no + /// container there. + fn suck_from_container(&mut self, above: Pos, hopper: &View) -> Option { + let c = self.containers(); + let source = c.view(above, false)?; + if let Kind::Composter(level) = source.kind { + if level != 8 { + return Some(false); + } + // tryTakeInItemFromSlot on the OutputContainer: removeItem calls + // its setChanged, which empties the composter, and so does the + // second setChanged after the move or, when the hopper has no + // room, the setItem putting the bone meal back into the detached + // container (whose bone meal is lost with it). + let bone_meal = c.bone_meal.clone(); + let at = BlockPos::new(above.0, above.1, above.2); + self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at)); + let moved = self.add_item(None, hopper, bone_meal, None).is_none(); + self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at)); + self.world.modified.insert((above.0 >> 4, above.2 >> 4)); + return Some(moved); + } + let source_hopper = (source.kind == Kind::Hopper).then_some(above); + for slot in source.slots_for_face(Some(Direction::Down)) { + let c = self.containers(); + let Some(stack) = c.get(&source, slot) else { + continue; + }; + if !c.can_take(&source, slot, stack, Direction::Down) { + continue; + } + let Some(one) = self.take_one(&source, slot) else { + continue; + }; + match self.add_item(source_hopper, hopper, one, None) { + None => { + self.view_changed(&source); + return Some(true); + } + Some(rest) => self.put_back(&source, slot, rest), + } + } + Some(false) + } + /// The item half of `HopperBlockEntity.suckInItems` (`getItemsAtAndAbove`): + /// adds the item entities that meet the box, until one is taken whole. + fn suck_item_entities(&mut self, hopper: &View, min: [f64; 3], max: [f64; 3]) -> bool { let mut i = 0; while i < self.dropped.len() { let b = self.dropped[i].bounds(); @@ -719,6 +731,66 @@ impl Game<'_> { } false } + /// `MinecartHopper.tick`'s `tryConsumeItems` (`suckInItems`) for an enabled + /// hopper minecart: one item from the container above, else the item + /// entities over it or touching it, each tick without a cooldown. + pub(super) fn hopper_cart_suck(&mut self, cart: &mut super::minecarts::Minecart) { + // The cart's slots are edited as a container under the placeholder key + // its menu uses; when that menu is open the placeholder is the live copy. + let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, cart.id as i32); + let open = self.world.block_entities.contains_key(&key); + if !open { + let items = BlockEntity::Chest(std::mem::take(&mut cart.items)); + self.world.block_entities.insert(key, items); + } + let size = self + .world + .block_entities + .get(&key) + .map_or(0, |e| e.slots().len()); + let view = View { + parts: vec![(key, size)], + kind: Kind::Generic, + }; + let p = cart.position; + // getLevelY is the cart's y + 0.5, so the container is the block at + // y + 1.5, and Hopper.SUCK_AABB (moved by getLevel - 0.5) starts 11/16 + // above the cart. + let above = ( + p.x.floor() as i32, + (p.y + 1.5).floor() as i32, + p.z.floor() as i32, + ); + let took = match self.suck_from_container(above, &view) { + Some(took) => took, + None => self.suck_item_entities( + &view, + [p.x - 0.5, p.y + 11.0 / 16.0, p.z - 0.5], + [p.x + 0.5, p.y + 2.0, p.z + 0.5], + ), + }; + if !took { + // The cart's own box, inflated by 0.25 sideways. + let b = cart.bounds(); + let (lo, hi) = (b.min_position(), b.max_position()); + self.suck_item_entities( + &view, + [lo.x - 0.25, lo.y, lo.z - 0.25], + [hi.x + 0.25, hi.y, hi.z + 0.25], + ); + } + // The cart's own items stay the one source of truth: a menu copy that + // is still around (open, or left by a guest's close) gets the pulled + // items back into `cart.items`, so reopening never restores a stale copy. + let slots = if open { + self.world.block_entities.get(&key).cloned() + } else { + self.world.block_entities.remove(&key) + }; + if let Some(BlockEntity::Chest(items)) = slots { + cart.items = items; + } + } // ---- dispensers and droppers ---- diff --git a/crates/horizon-client/src/game/maps.rs b/crates/horizon-client/src/game/maps.rs index eb8c3687b..1617eab56 100644 --- a/crates/horizon-client/src/game/maps.rs +++ b/crates/horizon-client/src/game/maps.rs @@ -1143,6 +1143,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light, + + glint_uv: [0.0, 0.0], }); } }; @@ -1194,6 +1196,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light, + + glint_uv: [0.0, 0.0], }); } }; @@ -1266,6 +1270,8 @@ impl Game<'_> { layer: 0, color: 0xFFFF_FFFF, light, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 2b54b0f2c..9dead141c 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -558,7 +558,6 @@ impl Game<'_> { // applyGravity c.velocity.y -= if self.cart_in_water(c) { 0.005 } else { 0.04 }; let pos = self.rail_block(c.position); - let fall_speed = c.velocity; if let Some(rail) = self.rail(pos[0], pos[1], pos[2]) { self.move_along_track(c, pos, &rail, intent); if &*rail.name == "minecraft:activator_rail" { @@ -600,22 +599,26 @@ impl Game<'_> { } } CartKind::Tnt => { - let speed = fall_speed.x * fall_speed.x + fall_speed.z * fall_speed.z; + // MinecartTNT.tick: the fuse and the collision check are separate. if c.fuse > 0 { c.fuse -= 1; let at = [c.position.x, c.position.y + 0.5, c.position.z]; self.particles .add(&ParticleOptions::simple(ParticleType::Smoke), at, [0.0; 3]); - } else if c.fuse == 0 || (c.horizontal_collision && speed >= 0.01) { + } else if c.fuse == 0 { + // explode(horizontalDistanceSqr()): a rising cart's + // vertical speed adds nothing. let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z; - let speed = if c.fuse == 0 && c.velocity.y > 0.0 { - c.velocity.y * c.velocity.y - } else { - speed - }; self.explode_cart(c, speed); return false; } + if c.horizontal_collision { + let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z; + if speed >= f64::from(0.01_f32) { + self.explode_cart(c, speed); + return false; + } + } } _ => {} } @@ -659,51 +662,9 @@ impl Game<'_> { // The cart is the explosion's source: it is gone before the blast // looks for entities, so it can't hit itself. self.carts.retain(|x| x.id != c.id); - let _ = self.server_explode(at, power, BlockInteraction::Destroy, false); - } - /// `MinecartHopper.suckInItems`: items above, into the five slots. - fn hopper_cart_pickup(&mut self, c: &mut Minecart) { - if !c.enabled { - return; - } - let p = c.position; - let zone = Aabb::new( - Vec3::new(p.x - 0.5, p.y - 0.5 + 0.0, p.z - 0.5), - Vec3::new(p.x + 0.5, p.y + 1.5, p.z + 0.5), - ); - let mut i = 0; - while i < self.dropped.len() { - let e = &self.dropped[i]; - if e.pickup_delay > 0 || !zone.contains(e.position) { - i += 1; - continue; - } - let mut stack = e.stack.clone(); - for slot in c.items.iter_mut() { - match slot { - None => { - *slot = Some(stack.clone()); - stack.count = 0; - } - Some(s) if s.same_item_same_components(&stack) => { - let max = self.res.items().get(&s.item).map_or(64, |i| i.max_stack); - let moved = stack.count.min(max.saturating_sub(s.count)); - s.count += moved; - stack.count -= moved; - } - _ => {} - } - if stack.count == 0 { - break; - } - } - if stack.count == 0 { - self.dropped.remove(i); - } else { - self.dropped[i].stack = stack; - i += 1; - } - } + let _ = self.with_hive_emptying_blast(|g| { + g.server_explode(at, power, BlockInteraction::Destroy, false) + }); } /// `AbstractMinecart.push` from each player walking into a cart /// (`LivingEntity.pushEntities`): the window's player and every server @@ -837,8 +798,8 @@ impl Game<'_> { } let mut c = self.carts[i].clone(); let alive = self.tick_cart(&mut c, [0.0; 2]); - if c.kind == CartKind::Hopper { - self.hopper_cart_pickup(&mut c); + if c.kind == CartKind::Hopper && c.enabled { + self.hopper_cart_suck(&mut c); } let Some(i) = self.carts.iter().position(|c| c.id == id) else { continue; @@ -1329,6 +1290,7 @@ impl Game<'_> { layer: 0, color, light, + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/mob_blocks.rs b/crates/horizon-client/src/game/mob_blocks.rs index a0ce5e9db..a57accfaa 100644 --- a/crates/horizon-client/src/game/mob_blocks.rs +++ b/crates/horizon-client/src/game/mob_blocks.rs @@ -204,6 +204,8 @@ impl Game<'_> { layer: overlay, color, light, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs index fa0052bc5..617d86aaa 100644 --- a/crates/horizon-client/src/game/mounts.rs +++ b/crates/horizon-client/src/game/mounts.rs @@ -228,10 +228,12 @@ impl Game<'_> { return false; } let mut used = false; + let mut loved = false; if love && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0 { m.extra.in_love = 600; m.extra.love_player = true; used = true; + loved = true; } if m.health < m.attrs.max_health && heal > 0.0 { m.health = (m.health + heal).min(m.attrs.max_health); @@ -251,6 +253,7 @@ impl Game<'_> { // eating(): the mouth opens and the horse eats. m.anim.v[2] = 1.0; let at = m.center(); + let id = m.id; let sound = match m.species() { Species::Camel => "minecraft:entity.camel.eat", Species::CamelHusk => "minecraft:entity.camel_husk.eat", @@ -260,6 +263,10 @@ impl Game<'_> { }; let pitch = (self.world.random.next_float() - self.world.random.next_float()) * 0.2 + 1.0; self.audio.play(sound, Some(at), 1.0, pitch); + // Animal.setInLove: entity event 18. + if loved { + self.mob_event_particles(id, 18); + } self.consume_held(); true } @@ -465,14 +472,16 @@ impl Game<'_> { m.extra.owner = owner; m.persistent = true; // AbstractHorse.tameWithName: entity event 7, spawnTamingParticles(true). - self.particles_around_mob( - mob, - "heart", - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(mob, 7); } } - MobEvent::Buck { mob } if self.riding == Some(mob) => self.dismount_mount(), + MobEvent::Buck { mob } => { + if self.riding == Some(mob) { + self.dismount_mount(); + } + // RunAroundLikeCrazyGoal.tick: entity event 6, smoke. + self.mob_event_particles(mob, 6); + } _ => {} } } diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index 6b5324e3a..3ecd2d245 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -379,6 +379,7 @@ impl Game<'_> { layer, color, light, + glint_uv: [0.0, 0.0], }); } }; diff --git a/crates/horizon-client/src/game/natural_spawning.rs b/crates/horizon-client/src/game/natural_spawning.rs index 0035f5082..5afa72416 100644 --- a/crates/horizon-client/src/game/natural_spawning.rs +++ b/crates/horizon-client/src/game/natural_spawning.rs @@ -504,7 +504,8 @@ impl<'a> Game<'a> { m.position.z.floor() as i32, ], is_mob: true, - persistent: m.persistent, + persistent: m.persistent + || horizon_client::mobs::ai::requires_custom_persistence(m), }) .collect(); let players = players diff --git a/crates/horizon-client/src/game/nautili.rs b/crates/horizon-client/src/game/nautili.rs index e7f16ca18..5e384db98 100644 --- a/crates/horizon-client/src/game/nautili.rs +++ b/crates/horizon-client/src/game/nautili.rs @@ -85,13 +85,8 @@ impl Game<'_> { m.ai.target = None; } let sound = nautilus::eat_sound(m); - let kind = if tamed { "heart" } else { "smoke" }; // TamableAnimal.spawnTamingParticles (entity event 7 or 6). - self.particles_around_mob( - self.mobs[index].id, - kind, - horizon_client::particles::Burst::TAMING, - ); + self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); self.nautilus_sound(index, sound); if tamed { let view = self.mob_entity(&self.mobs[index]); @@ -145,6 +140,8 @@ impl Game<'_> { let sound = nautilus::eat_sound(m); self.use_nautilus_food(item); self.nautilus_sound(index, sound); + // Animal.setInLove: entity event 18. + self.mob_event_particles(self.mobs[index].id, 18); return true; } false diff --git a/crates/horizon-client/src/game/paintings.rs b/crates/horizon-client/src/game/paintings.rs index 1b839f5b0..d0e984c29 100644 --- a/crates/horizon-client/src/game/paintings.rs +++ b/crates/horizon-client/src/game/paintings.rs @@ -307,6 +307,8 @@ impl Game<'_> { layer: 0, color, light: packed, + + glint_uv: [0.0, 0.0], }); } }; diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index 4daa03902..2c4cd1571 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -729,6 +729,8 @@ mod preview_tests { color: u32::MAX, light: 0, normal: [0; 4], + + glint_uv: [0.0, 0.0], }) }; // A shield and arm can intersect: neither average depth orders both ends. diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index a87a15254..c0d7f1e3c 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -21,8 +21,8 @@ use horizon_client::{ text::Text, }; use horizon_core::{ - geometry::{Aabb, Vec3}, - random::RandomSource, + geometry::{Aabb, Direction, Vec3}, + random::{LegacyRandom, RandomSource}, }; /// A thrown splash or lingering potion in flight. @@ -70,7 +70,7 @@ impl PotionCloud { } } /// A mob's effect ids carry the `minecraft:` namespace. -fn mob_effect_id(id: &str) -> Option<&'static str> { +pub(super) fn mob_effect_id(id: &str) -> Option<&'static str> { use std::{collections::HashMap, sync::OnceLock}; static IDS: OnceLock> = OnceLock::new(); let id = id.trim_start_matches("minecraft:"); @@ -120,6 +120,153 @@ fn mob_can_be_affected( } } impl Game<'_> { + /// `LivingEntity.triggerOnDeathMobEffects` (`onMobRemoved` with the reason + /// KILLED) for what Oozing, Weaving and Wind Charged do when their bearer + /// dies. `bearer` is the dying mob's id, `player` whether it is a player, + /// `random` the dying mob's own (`mob.getRandom()`; the world's for the + /// player). + pub(super) fn effects_on_death( + &mut self, + effects: &[&str], + bounds: Aabb, + player: bool, + bearer: Option, + mut random: Option<&mut LegacyRandom>, + ) { + let feet = bounds.bottom_center(); + if effects.contains(&"oozing") { + // OozingMobEffect.numberOfSlimesToSpawn: two, fewer when the + // slimes close by already fill the cramming limit. + let limit = self.ui.rules.int("max_entity_cramming"); + let mut count = 2; + if limit >= 1 { + let near = bounds.inflate(Vec3::new(2.0, 2.0, 2.0)); + let nearby = self + .mobs + .iter() + .filter(|m| { + m.species() == horizon_client::mobs::Species::Slime + && Some(m.id) != bearer + && m.bounds().intersects(near) + }) + .count() + .min(limit as usize) as i32; + count = (limit - nearby).clamp(0, count); + } + for _ in 0..count { + // spawnSlimeOffspring: a size 2 slime half a block up. + if let Some(id) = self.spawn_mob_for( + "minecraft:slime", + [feet.x, feet.y + 0.5, feet.z], + false, + true, + ) && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) + { + horizon_client::mobs::cube::set_size(m, 2); + } + } + } + if effects.contains(&"weaving") && (player || self.ui.rules.bool("mob_griefing")) { + self.spawn_cobwebs_around( + [ + feet.x.floor() as i32, + feet.y.floor() as i32, + feet.z.floor() as i32, + ], + random.as_deref_mut(), + ); + } + if effects.contains(&"wind_charged") { + // A burst centred at half the height, radius 3 to 5. + let center = [feet.x, feet.y + bounds.size().y / 2.0, feet.z]; + let r = random.unwrap_or(&mut self.world.random); + let radius = 3.0 + r.next_float() * 2.0; + let _ = self.wind_burst(center, radius, 1.0, false, false); + } + } + /// `WeavingMobEffect.spawnCobwebsRandomlyAround`: two or three cobwebs in + /// free spaces with a solid floor, picked among 15 random blocks within one + /// block of `pos`. + fn spawn_cobwebs_around(&mut self, pos: [i32; 3], mut random: Option<&mut LegacyRandom>) { + let r = random.as_deref_mut().unwrap_or(&mut self.world.random); + let wanted = 2 + r.next_int_bound(2).unwrap_or(0) as usize; + let mut chosen: Vec<[i32; 3]> = Vec::new(); + for _ in 0..15 { + let r = random.as_deref_mut().unwrap_or(&mut self.world.random); + let at = [ + pos[0] - 1 + r.next_int_bound(3).unwrap_or(0), + pos[1] - 1 + r.next_int_bound(3).unwrap_or(0), + pos[2] - 1 + r.next_int_bound(3).unwrap_or(0), + ]; + let facts = self.res.facts(); + let here = facts.get(self.world.block(at[0], at[1], at[2])); + let below = facts.get(self.world.block(at[0], at[1] - 1, at[2])); + if !chosen.contains(&at) + && here.replaceable + && below.sturdy_full & (1 << Direction::Up as u8) != 0 + { + chosen.push(at); + if chosen.len() >= wanted { + break; + } + } + } + for at in chosen { + if self.set_state_named(at, "minecraft:cobweb", &[]).is_ok() { + self.level_event_at(3018, at, 0); + } + } + } + /// `InfestedMobEffect.onMobHurt` for the player: from half its height up, + /// along where it looks. + pub(super) fn player_infested(&mut self) { + if let Some(p) = self.player.as_ref() { + let at = [ + p.position.x, + p.position.y + f64::from(p.dimensions.height) / 2.0, + p.position.z, + ]; + let look = super::view_vector(self.yaw, self.pitch); + self.infested_hurt(at, look, None); + } + } + /// A living mob's own random (`Entity.random`), else the world's. + fn bearer_random(&mut self, bearer: Option) -> &mut LegacyRandom { + match bearer.and_then(|id| self.mobs.iter().position(|m| m.id == id)) { + Some(i) => &mut self.mobs[i].random, + None => &mut self.world.random, + } + } + /// `InfestedMobEffect.onMobHurt`: a 10% chance of one or two silverfish at + /// `at` (half the bearer's height up), thrown along its look direction. + /// The draws are the bearer's (`mob.getRandom()`): `bearer` is the mob, + /// none for the player (the world's random). + pub(super) fn infested_hurt(&mut self, at: [f64; 3], look: [f64; 3], bearer: Option) { + if self.bearer_random(bearer).next_float() > 0.1 { + return; + } + let count = 1 + self.bearer_random(bearer).next_int_bound(2).unwrap_or(0); + for _ in 0..count { + // Mth.randomBetween(-PI / 2, PI / 2), then the look direction + // scaled by (0.3, 0.45, 0.3) and turned about the y axis. + let half = std::f32::consts::FRAC_PI_2; + let angle = self.bearer_random(bearer).next_float() * (2.0 * half) - half; + let (sin, cos) = angle.sin_cos(); + let (x, z) = (look[0] * 0.3, look[2] * 0.3); + let velocity = Vec3::new( + f64::from(x as f32 * cos + z as f32 * sin), + look[1] * 0.3 * 1.5, + f64::from(-x as f32 * sin + z as f32 * cos), + ); + if let Some(id) = self.spawn_mob_for("minecraft:silverfish", at, false, true) + && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) + { + m.velocity = velocity; + } + self.audio + .play("minecraft:entity.silverfish.hurt", Some(at), 1.0, 1.0); + } + } /// A splash potion, lingering potion or experience bottle in flight (the /// player's throws and dispensers both end up here). pub(super) fn launch_thrown( @@ -473,12 +620,34 @@ impl Game<'_> { return; }; if player.health.dead_or_dying() { - // LivingEntity.die → removeAllEffects. + // LivingEntity.die → removeAllEffects. Vanilla runs the effects + // that act on death (`onMobRemoved`) when the dead player is + // removed, up to 20 ticks later; here it is as the effects go. + let w = f64::from(player.dimensions.width) / 2.0; + let bounds = Aabb::new( + Vec3::new( + player.position.x - w, + player.position.y, + player.position.z - w, + ), + Vec3::new( + player.position.x + w, + player.position.y + f64::from(player.dimensions.height), + player.position.z + w, + ), + ); + let ids: Vec<&'static str> = self.potions.effects.list.iter().map(|e| e.id).collect(); self.potions.effects.clear(); + if !ids.is_empty() { + self.effects_on_death(&ids, bounds, true, None, None); + } } // The omens act from inside the effect tick (BadOmenMobEffect, // RaidOmenMobEffect). - let absorption_empty = player.health.absorption() <= 0.0; + let absorption_empty = self + .player + .as_ref() + .is_some_and(|p| p.health.absorption() <= 0.0); let mut effects = std::mem::take(&mut self.potions.effects); let (actions, raid_omen_added) = effects.tick_with(&mut |e| self.omen_tick(e), absorption_empty); diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs index c51fbdc0b..8fbcfc6dd 100644 --- a/crates/horizon-client/src/game/raids.rs +++ b/crates/horizon-client/src/game/raids.rs @@ -762,7 +762,7 @@ impl Game<'_> { } positions.push((m.id, m.position, s.active_raid)); } - let banners: Vec<(usize, Vec3)> = self + let banners: Vec<(usize, u32, Vec3)> = self .dropped .iter() .enumerate() @@ -771,7 +771,7 @@ impl Game<'_> { && e.stack.data().is_some_and(|d| d.ominous_banner) && e.pickup_delay == 0 }) - .map(|(i, e)| (i, e.position)) + .map(|(i, e)| (i, e.id, e.position)) .collect(); let mut taken: Vec = Vec::new(); let mut collectors: Vec<(usize, u32)> = Vec::new(); @@ -858,20 +858,33 @@ impl Game<'_> { && raids.get(id).is_some_and(|r| r.leader(s.wave).is_none()) && !leaders.contains(&(id, s.wave)) { + let in_reach = |(i, _, p): &&(usize, u32, Vec3)| { + !taken.contains(i) + && (p.x - position.x).abs() <= range + && (p.z - position.z).abs() <= range + && (p.y - position.y).abs() <= 8.0 + }; + let by_distance = |a: &&(usize, u32, Vec3), b: &&(usize, u32, Vec3)| { + a.2.distance_squared(position) + .total_cmp(&b.2.distance_squared(position)) + }; + // The unreachable cache only picks the navigation target; + // a banner next to the raider is still picked up. let near = banners .iter() - .filter(|(i, p)| { - !taken.contains(i) - && (p.x - position.x).abs() <= range - && (p.z - position.z).abs() <= range - && (p.y - position.y).abs() <= 8.0 + .filter(in_reach) + .filter(|(_, item, _)| { + !s.unreachable_banners + .iter() + .any(|&(b, until)| b == *item && now < until) }) - .min_by(|a, b| { - a.1.distance_squared(position) - .total_cmp(&b.1.distance_squared(position)) - }); - if let Some((i, p)) = near { + .min_by(by_distance); + let nearest = banners.iter().filter(in_reach).min_by(by_distance); + let adjacent = + nearest.filter(|(_, _, p)| p.distance_squared(position) < 1.414 * 1.414); + if let Some((i, item, p)) = adjacent.or(near) { s.banner_at = Some([p.x, p.y, p.z]); + s.banner_item = *item; if p.distance_squared(position) < 1.414 * 1.414 { // pickUpItem: the banner becomes the wave's leader. taken.push(*i); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 9035f151c..8720cb8fa 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -203,6 +203,8 @@ pub(super) struct Remote { stop_mining: bool, placing: Option<([i32; 3], u64)>, death_message: Option, + /// `LocalPlayer.showDeathScreen`: off with `immediate_respawn`. + show_death_screen: bool, player_type: Option>, /// Inventory as last synchronised, for creative-mode slot updates. synced: Vec>, @@ -496,6 +498,7 @@ impl Game<'_> { stop_mining: false, placing: None, death_message: None, + show_death_screen: true, player_type, synced: vec![None; 36], decode_errors: 0, @@ -1664,6 +1667,7 @@ impl Game<'_> { r.online_mode = p.online_mode; r.entity_id = p.player_id; r.view_distance = p.chunk_radius; + r.show_death_screen = p.show_death_screen; } self.streaming.radius = self.settings.render_distance.min(p.chunk_radius + 1).max(2); @@ -1914,7 +1918,8 @@ impl Game<'_> { } C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers), // ClientPacketListener.handleEntityLinkPacket: who holds a mob's - // lead (this player, another player or a mob), for the rope. + // lead (this player, another player, a mob or a fence knot), for + // the rope. C::SetEntityLink(p) => { let me = self.remote.as_ref().map(|r| r.entity_id); if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.source as u32) { @@ -1922,7 +1927,12 @@ impl Game<'_> { m.extra.leash = match p.dest { 0 => None, d if Some(d) == me => Some(Holder::Player), - d => Some(Holder::Mob(d as u32)), + d => match self.remote_knots.get(&(d as u32)) { + Some(&block) => Some(Holder::Knot(block)), + // Not a known knot yet: kept by id until the knot + // arrives (game/remote_objects.rs). + None => Some(Holder::Mob(d as u32)), + }, }; } } @@ -2194,8 +2204,9 @@ impl Game<'_> { } C::HurtAnimation(p) => { if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) { + // Player.animateHurt: the tilt turns around the yaw. if let Some(pl) = self.player.as_mut() { - pl.health.animate_hurt(); + pl.health.animate_hurt_dir(p.yaw); } } else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { m.hurt_time = 10; @@ -2232,6 +2243,10 @@ impl Game<'_> { { m.health = 0.0; } + // The events that start a mob's animation (the warden's). + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { + horizon_client::mobs::sync::entity_event(m, p.event as u8); + } // LivingEntity.handleEntityEvent 60: the poof as the dead body goes. if p.event == 60 && let Some(m) = self.mobs.iter().find(|m| m.id == p.id as u32) @@ -2242,6 +2257,37 @@ impl Game<'_> { if p.event == super::totem::TOTEM_EVENT { self.remote_totem(p.id); } + // Mob.handleEntityEvent 20: the spawn poof. + if p.event == 20 && self.mobs.iter().any(|m| m.id == p.id as u32) { + self.poof_particles(p.id as u32); + } + // Villager 12, 13 and 14, TamableAnimal and AbstractHorse 6 and + // 7, Animal and Allay 18: the particles about the mob. + if matches!(p.event, 6 | 7 | 12 | 13 | 14 | 18) { + self.entity_event_particles(p.id as u32, p.event); + } + // Snowball and ThrownEgg.handleEntityEvent 3: the crumbs where + // the projectile is (the server removes it right after). + if p.event == 3 { + let crumbs = self + .creatures + .projectiles + .iter() + .find(|pr| pr.id == p.id as u32) + .and_then(|pr| { + let item = match pr.kind { + horizon_client::projectiles::ProjectileKind::Snowball => { + "minecraft:snowball" + } + horizon_client::projectiles::ProjectileKind::Egg => "minecraft:egg", + _ => return None, + }; + Some(([pr.position.x, pr.position.y, pr.position.z], item)) + }); + if let Some((at, item)) = crumbs { + self.item_burst(at, item); + } + } if p.event == super::combat::DROWN_EVENT { self.remote_drown(p.id); } @@ -2316,7 +2362,11 @@ impl Game<'_> { pl.health.flash_health_change(p.health); } self.apply_remote_health(); - if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() { + // The death screen opens (or the respawn is asked for) with the + // death packet when the rule hides it. + let shown = self.remote.as_ref().is_none_or(|r| r.show_death_screen); + if p.health <= 0.0 && shown && self.screen != Screen::Dead && self.player.is_some() + { self.screen = Screen::Dead; self.ui.death_time = 0; self.capture(false); @@ -2332,11 +2382,16 @@ impl Game<'_> { r.death_message = Some(message); } // ClientPacketListener.handlePlayerCombatKill: the death - // screen, whatever health was last sent. + // screen, whatever health was last sent, or `respawn()` at + // once when it is hidden. if me && self.screen != Screen::Dead && self.player.is_some() { - self.screen = Screen::Dead; - self.ui.death_time = 0; - self.capture(false); + if self.remote.as_ref().is_none_or(|r| r.show_death_screen) { + self.screen = Screen::Dead; + self.ui.death_time = 0; + self.capture(false); + } else { + self.respawn_player()?; + } } } C::TrackedWaypoint(p) => self.handle_waypoint(&p), @@ -2412,6 +2467,12 @@ impl Game<'_> { r.game_mode = mode; } } + // IMMEDIATE_RESPAWN: LocalPlayer.setShowDeathScreen. + 11 => { + if let Some(r) = self.remote.as_mut() { + r.show_death_screen = p.param == 0.0; + } + } 7 => { self.world.weather.rain_level = (p.param, p.param); self.world.weather.raining = p.param > 0.0; @@ -3291,6 +3352,15 @@ impl Game<'_> { fn tick_remote_level(&mut self) -> Result<()> { self.ticks += 1; + // AbstractSignEditScreen.tick: the editor closes once its sign is removed. + if let Some(edit) = &self.sign_edit + && !matches!( + self.world.block_entities.get(&edit.pos), + Some(BlockEntity::Sign(_)) + ) + { + self.close_sign_editor(); + } self.track_experience_display(); // Leaving a slot clears its bundle's selection here and on the server. self.tick_bundle_hover(); @@ -3666,6 +3736,7 @@ impl Game<'_> { m.fluids = fluids; } } + let game_time = self.world.game_time; let Some(r) = self.remote.as_mut() else { return; }; @@ -3789,6 +3860,8 @@ impl Game<'_> { if m.species() == horizon_client::mobs::Species::Bat { horizon_client::mobs::bat::setup_animation_states(m); } + // The animation states a server computes in its own `ai_step`. + horizon_client::mobs::sync::client_tick(m, game_time); } for o in self.orbs.iter_mut().filter(|_| running) { o.previous = o.position; @@ -4390,6 +4463,16 @@ impl Game<'_> { if self.keys.contains(&KeyCode::ShiftLeft) && hands_full { return (false, DryUse::default()); } + // BeehiveBlock.useItemOn: shears or a glass bottle on a full hive + // (honey level 5) is SUCCESS, so the click ends after UseItemOn and + // no UseItem follows (the server does the harvest, see `use_beehive`). + if held.is_some_and(|s| matches!(&*s.item, "minecraft:shears" | "minecraft:glass_bottle")) + && self + .hive_state(hit.pos) + .is_some_and(|(honey, _)| honey == Some(5)) + { + return (true, DryUse::default()); + } use horizon_core::geometry::Direction; let face = match hit.face { [0, 1, 0] => Direction::Up, diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index d6e4372f6..f85a96119 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -4,7 +4,7 @@ //! own simulation, which a client of a server doesn't run. use super::Game; use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; -use horizon_client::mobs::{Mob, Species, Who, bat, tame}; +use horizon_client::mobs::{Mob, Species, Who, bat, camel, sniffer, sync, tame}; use horizon_client::particles::{ParticleOptions, ParticleType}; use horizon_protocol::entity_data::{Particle, ParticleData, Value}; use horizon_protocol::registry::Builtin; @@ -27,6 +27,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti // client, which draws the flames. A client doesn't count the // fire down: the flag goes off when the server's fire is out. (0, Value::Byte(flags)) => m.fire_ticks = i32::from(flags & 1), + // Entity.DATA_POSE: the pose the species animates by. + (6, Value::Id(pose)) => sync::set_pose(m, (*pose).clamp(0, 17) as u8), // LivingEntity.DATA_LIVING_ENTITY_FLAGS: using an item 1, in the // off hand 2. The flag starts and stops the use; the client ticks // the count itself (a bow's pull follows it). @@ -100,6 +102,29 @@ 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); } + // Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace. + (Species::Warden, 16, Value::Int(anger)) => { + if let Some(st) = m.extra.warden.as_mut() { + st.client_anger = *anger; + } + } + // Sniffer.DATA_STATE (after AgeableMob's two): the animation + // follows it in `sync::client_tick`. + (Species::Sniffer, 18, Value::Id(state)) => { + sniffer::set_state(m, (*state).clamp(0, 6) as u8); + } + // Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID. + (Species::Shulker, 16, Value::Id(face)) => m.extra.variant3 = (*face).clamp(0, 5) as u8, + (Species::Shulker, 17, Value::Byte(peek)) => m.extra.counter = i32::from(*peek), + (Species::Shulker, 18, Value::Byte(color)) => m.extra.color = *color as u8, + // Camel.DASH and LAST_POSE_CHANGE_TICK (after AbstractHorse's + // flags). + (Species::Camel | Species::CamelHusk, 19, Value::Bool(dashing)) => { + camel::set_dashing(m, *dashing); + } + (Species::Camel | Species::CamelHusk, 20, Value::Long(tick)) => { + camel::set_synced_pose_tick(m, *tick); + } // Pillager.IS_CHARGING_CROSSBOW: the charge pose (Raider's // IS_CELEBRATING takes 16). (Species::Pillager, 17, Value::Bool(charging)) => m.extra.flag = *charging, diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs index 05b1a2b9e..7f484c35f 100644 --- a/crates/horizon-client/src/game/remote_objects.rs +++ b/crates/horizon-client/src/game/remote_objects.rs @@ -1,9 +1,10 @@ -//! Boats, minecarts, armor stands, item frames and paintings on a server's +//! Boats, minecarts, armor stands, item frames, paintings and fence knots on a server's //! client (`ClientPacketListener.handleAddEntity`, `handleSetEntityData`, //! `handleSetEquipment`): the server simulates them, the client places them //! where it says and interpolates their moves like a mob's. use super::Game; use horizon_client::entities::{ArmorStand, Cushion, ItemFrame, Painting}; +use horizon_client::mobs::leash::Holder; use horizon_core::geometry::Vec3; use horizon_protocol::entity_data::Value; use std::sync::Arc; @@ -24,7 +25,17 @@ impl Game<'_> { let at = Vec3::new(position[0], position[1], position[2]); let block = position.map(|v| v.floor() as i32); self.remove_remote_object(id); - if kind == "minecraft:text_display" { + if kind == "minecraft:leash_knot" { + // A lead that came before its knot waits as a mob holder with the + // knot's id (handleEntityLinkPacket's delayed holder); now it can + // be tied to the fence. + self.remote_knots.insert(id, block); + for m in &mut self.mobs { + if m.extra.leash == Some(Holder::Mob(id)) { + m.extra.leash = Some(Holder::Knot(block)); + } + } + } else if kind == "minecraft:text_display" { self.text_displays.insert( id as i32, super::text_displays::RemoteTextDisplay::new(position, yaw), @@ -304,6 +315,7 @@ impl Game<'_> { /// Every object a server sent (a new connection, level or dimension). pub(super) fn clear_remote_objects(&mut self) { self.text_displays.clear(); + self.remote_knots.clear(); self.carts.clear(); self.boats.clear(); self.armor_stands.clear(); @@ -314,6 +326,7 @@ impl Game<'_> { pub(super) fn remove_remote_object(&mut self, id: u32) { self.text_displays.remove(&(id as i32)); + self.remote_knots.remove(&id); self.carts.retain(|c| c.id != id); self.boats.retain(|b| b.id != id); self.armor_stands.retain(|a| a.id != id); diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 9b6ad331a..00d4abaed 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -74,7 +74,8 @@ pub(super) fn cloud_client_tick( ]; (particle.clone(), v) }; - particles.add(&options, at, velocity); + // `addAlwaysVisibleParticle`. + particles.add_with(&options, at, velocity, false, true); } } diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index c6c632f02..fecb58615 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -245,6 +245,7 @@ impl Game<'_> { 1.0, ); } + self.particles.particle_level = self.settings.particles; if let Some(e) = eye { self.particles.camera = e; } @@ -288,13 +289,16 @@ impl Game<'_> { e[2].floor() as i32, ]; animate_tick(self.res.animate(), &mut self.particles, &ctx, block); - // The Horizon Weather option off means no rain visuals at all. + // The Horizon Weather option off means no rain visuals or sounds at all. if rain > 0.0 && self.settings.horizon.weather { - // ClientLevel.tickWeatherEffects: rain splashes within the weather radius. + // ClientLevel.tickWeatherEffects: rain splashes within the weather + // radius, and the rain sound. let mut random = LegacyRandom::new(self.world.game_time.wrapping_mul(312_987_231)); let radius = self.settings.weather_radius; let diameter = 2 * radius + 1; - let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32; + let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32 + / if self.settings.particles == 1 { 2 } else { 1 }; + let mut rain_position = None; for _ in 0..count { let x = block[0] + random.next_int_bound(diameter).unwrap_or(0) - radius; let z = block[2] + random.next_int_bound(diameter).unwrap_or(0) - radius; @@ -307,6 +311,12 @@ impl Game<'_> { continue; } let below = top - 1; + rain_position = Some([x, below, z]); + // The Minimal option stops at the first spot that rains (the + // rain sound still plays there). + if self.settings.particles >= 2 { + break; + } let (bx, bz) = (random.next_double(), random.next_double()); let state = world.block(x, below, z); let f = facts.get(state); @@ -338,6 +348,26 @@ impl Game<'_> { self.particles .add(&ParticleOptions::simple(ty), p, [0.0; 3]); } + // The last rain column of the tick makes the sound, more often the + // longer it has been quiet; indoors it is the quieter one. + if let Some(at) = rain_position { + let waited = self.rain_sound_time; + self.rain_sound_time += 1; + if random.next_int_bound(3).unwrap_or(0) < waited { + self.rain_sound_time = 0; + let roof = + motion_blocking(world, facts, block[0], block[2], MIN_Y + HEIGHT); + let (name, volume, pitch) = if at[1] > block[1] + 1 && roof > block[1] { + ("minecraft:weather.rain.above", 0.1, 0.5) + } else { + ("minecraft:weather.rain", 0.2, 1.0) + }; + let p = at.map(|c| f64::from(c) + 0.5); + // playLocalSound: guests make their own rain, so a host + // must not capture it for them. + self.audio.play_unshared(name, Some(p), volume, pitch); + } + } } } if let Some(r) = &self.renderer { diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index 750895adb..4b5c4c333 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -322,6 +322,58 @@ impl Game<'_> { ); } } + /// LocalPlayer.respawn: the player comes back (the death screen's + /// button, or at once with `immediate_respawn`). + pub(super) fn respawn_player(&mut self) -> Result<()> { + if self.remote.is_none() { + // PlayerList.respawn removes the dead player, and Player.remove's + // inventoryMenu.removed drops what the cursor held, whatever + // keep_inventory says (the 20-tick branch handles a later respawn). + if let Some(stack) = self.carried.take() + && let Some(eye) = self.eye_position() + { + self.throw_from_eyes(stack, eye, false); + } + let keep = self.ui.rules.bool("keep_inventory") || self.spectator(); + self.experience.respawn(keep); + // The guests are sent the respawned host as a new entity, not the dead body. + if let Some(host) = self.lan.as_mut() { + let id = host.host_entity; + host.hub.respawned(id); + } + // Autosaves keep a login position; death must resolve the respawn point instead. + self.level.position = None; + } + if self.remote.is_some() { + self.ui.death_text = None; + self.toggles.respawn(); + self.remote_respawn(); + } else if self.respawn_config.is_some() { + // LocalPlayer.respawn: KeyMapping.resetToggleKeys. + self.toggles.respawn(); + // PlayerList.respawn at the respawn anchor, once it is loaded. + self.begin_anchor_respawn()?; + self.screen = Screen::Playing; + self.ui.death_text = None; + self.spawn_player()?; + self.capture(true); + } else { + // LocalPlayer.respawn: KeyMapping.resetToggleKeys. + self.toggles.respawn(); + self.respawn_out_of_end()?; + self.player = None; + self.screen = Screen::Playing; + self.ui.death_text = None; + self.spawn_player()?; + self.capture(true); + } + // ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's + // respawned player only watches. + if self.remote.is_none() && self.level.hardcore { + self.set_mode(GameMode::Spectator); + } + Ok(()) + } pub(super) fn death_click(&mut self) -> Result<()> { if self .ui @@ -339,51 +391,11 @@ impl Game<'_> { .into_iter() .find(|d| ui::hovered(self.cursor, d.0, d.1, 200.0, 20.0)) .map(|d| d.3); - if hit == Some(0) && self.remote.is_none() { - let keep = self.ui.rules.bool("keep_inventory") || self.spectator(); - self.experience.respawn(keep); - // The guests are sent the respawned host as a new entity, not the dead body. - if let Some(host) = self.lan.as_mut() { - let id = host.host_entity; - host.hub.respawned(id); - } - // Autosaves keep a login position; death must resolve the respawn point instead. - self.level.position = None; - } match hit { - Some(0) if self.remote.is_some() => { - self.ui.death_text = None; - self.toggles.respawn(); - self.remote_respawn(); - } - Some(0) if self.respawn_config.is_some() => { - // LocalPlayer.respawn: KeyMapping.resetToggleKeys. - self.toggles.respawn(); - // PlayerList.respawn at the respawn anchor, once it is loaded. - self.begin_anchor_respawn()?; - self.screen = Screen::Playing; - self.ui.death_text = None; - self.spawn_player()?; - self.capture(true); - } - Some(0) => { - // LocalPlayer.respawn: KeyMapping.resetToggleKeys. - self.toggles.respawn(); - self.respawn_out_of_end()?; - self.player = None; - self.screen = Screen::Playing; - self.ui.death_text = None; - self.spawn_player()?; - self.capture(true); - } + Some(0) => self.respawn_player()?, Some(1) => self.close_world()?, _ => {} } - // ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's - // respawned player only watches. - if hit == Some(0) && self.remote.is_none() && self.level.hardcore { - self.set_mode(GameMode::Spectator); - } if hit.is_some() { self.audio.play_button_click(); } diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs index 473509f0a..65dfede1a 100644 --- a/crates/horizon-client/src/game/sculk.rs +++ b/crates/horizon-client/src/game/sculk.rs @@ -1515,6 +1515,16 @@ impl Game<'_> { fn tick_entity_events(&mut self) { self.tick_player_sculk_events(); self.tick_mob_sculk_events(); + // Dropped items are entities too: Entity.applyEffectsFromBlocks. + let items: Vec<[f64; 3]> = self + .dropped + .iter() + .filter(|i| i.on_ground) + .map(|i| [i.position.x, i.position.y, i.position.z]) + .collect(); + for at in items { + self.step_on_redstone_ore(at, false); + } } /// Entity.move emits on the authoritative server too, for each ServerPlayer. @@ -1530,6 +1540,9 @@ impl Game<'_> { }); if let Some((at, on_ground, health, flying)) = player { let crouch = self.keys.contains(&KeyCode::ShiftLeft); + if on_ground && !self.spectator() { + self.step_on_redstone_ore(at, crouch); + } let in_water = self.in_water_at(at); self.entity_motion_events( Who::Player, @@ -1548,6 +1561,26 @@ impl Game<'_> { } } + /// `RedStoneOreBlock.stepOn`: standing on the ore lights it, unless the + /// entity is stepping carefully (`attack_block` only lights an unlit ore). + fn step_on_redstone_ore(&mut self, at: [f64; 3], carefully: bool) { + if carefully { + return; + } + // getOnPosLegacy: 0.2 below the feet. + let pos = [ + at[0].floor() as i32, + (at[1] - 0.2).floor() as i32, + at[2].floor() as i32, + ]; + if matches!( + &*self.block_name(pos), + "minecraft:redstone_ore" | "minecraft:deepslate_redstone_ore" + ) { + let _ = self.attack_block(pos); + } + } + fn tick_mob_sculk_events(&mut self) { let snapshot: Vec<(u32, [f64; 3], bool, bool, Species, Option)> = self .mobs @@ -1565,6 +1598,9 @@ impl Game<'_> { }) .collect(); for (id, at, on_ground, in_water, species, damaged) in snapshot { + if on_ground { + self.step_on_redstone_ore(at, false); + } let emits = !matches!(species, Species::Shulker); if emits { self.entity_motion_events(Who::Mob(id), at, on_ground, in_water, false, false); diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs index c4f7f98d1..a26bc5d75 100644 --- a/crates/horizon-client/src/game/shield.rs +++ b/crates/horizon-client/src/game/shield.rs @@ -182,12 +182,17 @@ impl Game<'_> { return; }; let (mx, mz) = (m.position.x, m.position.z); - let disable = m - .extra - .main_hand - .as_deref() - .and_then(|item| self.res.items().get(item)) - .map_or(0.0, |i| i.disable_blocking_seconds); + // LivingEntity.getSecondsToDisableBlocking: the held weapon's value; + // Warden overrides it with a flat 5 seconds. + let disable = if m.species() == horizon_client::mobs::Species::Warden { + 5.0 + } else { + m.extra + .main_hand + .as_deref() + .and_then(|item| self.res.items().get(item)) + .map_or(0.0, |i| i.disable_blocking_seconds) + }; // Ravager.blockedByItem: stunned half the time (the defender pushed // apart), else the defender flung away; no roar in progress. if m.species() == horizon_client::mobs::Species::Ravager { diff --git a/crates/horizon-client/src/game/sign_edit.rs b/crates/horizon-client/src/game/sign_edit.rs index 3d946ce7b..c26314513 100644 --- a/crates/horizon-client/src/game/sign_edit.rs +++ b/crates/horizon-client/src/game/sign_edit.rs @@ -21,6 +21,9 @@ pub(super) struct SignEditor { pub line: usize, /// The line being edited (`AbstractSignEditScreen`'s text field). edit: EditBox, + /// `AbstractSignEditScreen.messages`: the side's lines as edited, sent + /// when the editor closes, even if the sign is gone by then. + lines: [String; 4], } fn sign_box() -> EditBox { @@ -185,11 +188,19 @@ impl Game<'_> { } /// `SignBlock.openTextEdit` for the front side after placement. pub(super) fn open_sign_editor(&mut self, pos: (i32, i32, i32), front: bool) { + // Minecraft.setScreen: the editor already open is removed first. + self.close_sign_editor(); + let lines = match self.world.block_entities.get(&pos) { + Some(BlockEntity::Sign(sign)) if front => sign.front.lines.clone(), + Some(BlockEntity::Sign(sign)) => sign.back.lines.clone(), + _ => Default::default(), + }; self.sign_edit = Some(SignEditor { pos, front, line: 0, edit: sign_box(), + lines, }); self.sign_load(); self.keys.clear(); @@ -202,14 +213,11 @@ impl Game<'_> { pub(super) fn close_sign_editor(&mut self) { if let Some(edit) = self.sign_edit.take() { if self.remote.is_some() { - if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&edit.pos) { - let side = if edit.front { &sign.front } else { &sign.back }; - self.send(S::SignUpdate(play::SignUpdate { - pos: [edit.pos.0, edit.pos.1, edit.pos.2], - lines: side.lines.clone(), - front: edit.front, - })); - } + self.send(S::SignUpdate(play::SignUpdate { + pos: [edit.pos.0, edit.pos.1, edit.pos.2], + lines: edit.lines, + front: edit.front, + })); } else { self.mark_block_entity_updated(edit.pos); } @@ -358,7 +366,8 @@ impl Game<'_> { edit.edit.set_value(&text); } } - /// The box's text onto the sign, when it still fits the line. + /// The box's text onto the editor's lines and the sign + /// (`AbstractSignEditScreen.setMessage`), when it still fits the line. fn sign_write(&mut self) { let Some(edit) = self.sign_edit.as_ref() else { return; @@ -367,6 +376,9 @@ impl Game<'_> { if !self.sign_fits(&value) { return; } + if let Some(edit) = self.sign_edit.as_mut() { + edit.lines[line].clone_from(&value); + } let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&pos) else { return; }; diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs index 5dd907afb..a3761cf7a 100644 --- a/crates/horizon-client/src/game/spawner.rs +++ b/crates/horizon-client/src/game/spawner.rs @@ -257,8 +257,17 @@ impl Game<'_> { let Some(m) = self.mobs.iter().find(|m| m.id == id) else { return; }; - let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height())); + let at = m.position; self.lan_entity_event(id as i32, 20, [at.x, at.y, at.z]); + self.poof_particles(id); + } + /// `Mob.handleEntityEvent` 20 (`spawnAnim` on a client): the poof about + /// mob `id`. + pub(super) fn poof_particles(&mut self, id: u32) { + let Some(m) = self.mobs.iter().find(|m| m.id == id) else { + return; + }; + let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height())); let options = ParticleOptions::simple(ParticleType::Poof); for _ in 0..20 { let r = self.particles.level_random(); diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs index e5cb0ab26..81895dba3 100644 --- a/crates/horizon-client/src/game/storage.rs +++ b/crates/horizon-client/src/game/storage.rs @@ -3,6 +3,7 @@ //! player's `PlayerEnderChestContainer`, saved as `EnderItems`). use super::Game; use horizon_client::{containers::BlockEntity, items::ItemStack, text::Text}; +use horizon_core::random::RandomSource; pub(super) fn is_shulker_box(name: &str) -> bool { name.ends_with("shulker_box") @@ -156,6 +157,79 @@ impl Game<'_> { ); paired.then_some((other, kind == "right")) } + /// The open or close sound of a container block (`ChestBlockEntity.playSound`, + /// `BarrelBlockEntity.playSound`, `ShulkerBoxBlockEntity.startOpen`): volume + /// 0.5 and pitch 0.9 to 1.0. A double chest sounds once from the middle of + /// both halves, a barrel from the face it opens on. + pub(super) fn container_sound(&mut self, sound: &str, key: (i32, i32, i32), name: &str) { + let mut at = [ + f64::from(key.0) + 0.5, + f64::from(key.1) + 0.5, + f64::from(key.2) + 0.5, + ]; + if let Some((other, _)) = self.chest_partner(key) { + at[0] = f64::from(key.0 + other.0) / 2.0 + 0.5; + at[2] = f64::from(key.2 + other.2) / 2.0 + 0.5; + } else if name == "minecraft:barrel" + && let Some(state) = self + .pack + .assets + .registry + .state(self.world.block(key.0, key.1, key.2)) + && let Some(facing) = state.properties.get("facing") + { + let (dx, dy, dz) = match facing.as_str() { + "up" => (0.0, 0.5, 0.0), + "down" => (0.0, -0.5, 0.0), + f => { + let (x, z) = facing_step(f); + (f64::from(x) / 2.0, 0.0, f64::from(z) / 2.0) + } + }; + at = [at[0] + dx, at[1] + dy, at[2] + dz]; + } + let pitch = self.world.random.next_float() * 0.1 + 0.9; + self.audio.play(sound, Some(at), 0.5, pitch); + } + /// The open or close sound of the container block at `key`, if it has one. + /// Callers play it only when the opener count crosses zero + /// (`ContainerOpenersCounter.onOpen` / `onClose`). + pub(super) fn container_edge_sound(&mut self, key: (i32, i32, i32), open: bool) { + let name = self + .res + .facts() + .get(self.world.block(key.0, key.1, key.2)) + .name + .clone(); + let sound = if is_shulker_box(&name) { + if open { + "minecraft:block.shulker_box.open" + } else { + "minecraft:block.shulker_box.close" + } + } else if &*name == "minecraft:ender_chest" { + if open { + "minecraft:block.ender_chest.open" + } else { + "minecraft:block.ender_chest.close" + } + } else if name.contains("chest") { + if open { + "minecraft:block.chest.open" + } else { + "minecraft:block.chest.close" + } + } else if &*name == "minecraft:barrel" { + if open { + "minecraft:block.barrel.open" + } else { + "minecraft:block.barrel.close" + } + } else { + return; + }; + self.container_sound(sound, key, &name); + } /// The other half of a double chest at `key`, for neighbour updates. pub(super) fn chest_other_half(&self, key: (i32, i32, i32)) -> Option<(i32, i32, i32)> { self.chest_partner(key).map(|p| p.0) diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs index 587db3382..6812be7bf 100644 --- a/crates/horizon-client/src/game/text_displays.rs +++ b/crates/horizon-client/src/game/text_displays.rs @@ -269,6 +269,8 @@ impl Game<'_> { light, layer: if through { 2 } else { 0 }, normal: [0; 4], + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/tnt.rs b/crates/horizon-client/src/game/tnt.rs index 177e3bf80..beaac42cc 100644 --- a/crates/horizon-client/src/game/tnt.rs +++ b/crates/horizon-client/src/game/tnt.rs @@ -178,7 +178,9 @@ impl Game<'_> { ]; self.tnts.remove(i); count -= 1; - self.server_explode(center, 4.0, BlockInteraction::Destroy, false)?; + self.with_hive_emptying_blast(|g| { + g.server_explode(center, 4.0, BlockInteraction::Destroy, false) + })?; } else { i += 1; } @@ -332,6 +334,8 @@ impl Game<'_> { layer: if lit { 5 } else { 0 }, color, light: packed, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs index 9d6b3f9c5..bca582d1a 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -6,6 +6,7 @@ use super::{Game, view_vector}; use horizon_client::{ collisions::SceneCollisions, + enchant::EffectContext, items::ItemStack, mesher::Vertex, mobs::{Damage, DamageKind, Who, anim::Poses}, @@ -32,6 +33,8 @@ pub(super) struct ThrownTrident { pub(super) no_physics: bool, returning: u32, creative_only: bool, + /// The guest that threw it (`Projectile.getOwner`); `None` for the host. + guest: Option, } impl ThrownTrident { /// A trident a server sent (`handleAddEntity`): placed and moved by it. @@ -51,6 +54,7 @@ impl ThrownTrident { no_physics: false, returning: 0, creative_only: false, + guest: None, } } /// One tick of a server's client: the previous position, then `step`. @@ -302,11 +306,33 @@ impl Game<'_> { no_physics: false, returning: 0, creative_only: self.creative, + guest: self.lan_acting, }); self.player_projectile_shot(); self.audio .play("minecraft:item.trident.throw", at, 1.0, 1.0); } + /// The thrower's `PLAYER_HURT_ENTITY` for a trident hit: run as the + /// guest that threw it, and not at all once they have left. + fn thrower_hit( + &mut self, + guest: Option, + victim: &horizon_client::advancements::EntityView, + direct: horizon_client::advancements::EntityView, + damage: f32, + ) { + let Some(conn) = guest.filter(|c| self.lan_acting != Some(*c)) else { + self.player_hit(victim, "minecraft:trident", Some(direct), damage); + return; + }; + let Some(mut host) = self.lan.take() else { + return; + }; + self.as_guest(&mut host, conn, |g| { + g.player_hit(victim, "minecraft:trident", Some(direct), damage) + }); + self.lan = Some(host); + } pub(super) fn tick_tridents(&mut self) { let Some(eye) = self.eye_position() else { return; @@ -367,11 +393,29 @@ impl Game<'_> { } } if let Some((id, _)) = hit_mob { - let impaling = t.stack.enchantment_level("minecraft:impaling") as f32; - let aquatic = self.mobs.iter().find(|m| m.id == id).is_some_and(|m| { - m.kind.flags.aquatic_swimmer || m.kind.flags.breathes_water - }); - let damage = 8.0 + if aquatic { 2.5 * impaling } else { 0.0 }; + // ThrownTrident.getDamage: `EnchantmentHelper.modifyDamage` on 8 + // (impaling hits `#sensitive_to_impaling`, the aquatic tag). + let victim = self + .mobs + .iter() + .find(|m| m.id == id) + .map(|m| m.kind.id.clone()); + let ctx = EffectContext { + this: victim.as_deref(), + attacker: Some("minecraft:player"), + direct_attacker: Some("minecraft:trident"), + is_direct: true, + damage_type: Some("minecraft:trident"), + items: Some(self.res.items()), + ..Default::default() + }; + let damage = self.res.stations().enchantments.modify_value( + Some(&t.stack), + "minecraft:damage", + &ctx, + &mut self.world.random, + 8.0, + ); t.dealt_damage = true; let mut hurt_at = None; if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { @@ -394,6 +438,18 @@ impl Game<'_> { { self.channel_lightning(at); } + if hurt_at.is_some() + && let Some(m) = self.mobs.iter().find(|m| m.id == id) + { + // LivingEntity.hurtServer: PLAYER_HURT_ENTITY. + let victim = self.mob_entity(m); + let direct = horizon_client::advancements::EntityView { + kind: "minecraft:trident".into(), + position: [t.position.x, t.position.y, t.position.z], + ..Default::default() + }; + self.thrower_hit(t.guest, &victim, direct, damage); + } self.audio.play( "minecraft:item.trident.hit", Some([t.position.x, t.position.y, t.position.z]), diff --git a/crates/horizon-client/src/game/villagers.rs b/crates/horizon-client/src/game/villagers.rs index c04b18604..36c79f893 100644 --- a/crates/horizon-client/src/game/villagers.rs +++ b/crates/horizon-client/src/game/villagers.rs @@ -148,7 +148,7 @@ impl Game<'_> { // VillagerMakeLove: entity event 13 for the partner, then the parent. for i in [ib, ia] { let id = self.mobs[i].id; - self.villager_particles(id, "angry_villager"); + self.mob_event_particles(id, 13); } return; }; @@ -173,12 +173,31 @@ impl Game<'_> { child.extra.bed = Some(bed); } // VillagerMakeLove.giveBirth: entity event 12 for the child. - self.villager_particles(id, "heart"); + self.mob_event_particles(id, 12); } - /// `Villager.handleEntityEvent` 12, 13, 14 and 42: - /// `AbstractVillager.addParticlesAroundSelf`. - pub(super) fn villager_particles(&mut self, id: u32, kind: &'static str) { - self.particles_around_mob(id, kind, horizon_client::particles::Burst::VILLAGER); + /// `Level.broadcastEntityEvent` of an event whose `handleEntityEvent` + /// draws particles about the mob (villager 12, 13 and 14, taming 6 and 7, + /// love 18): the guests get the byte, and this game draws it as its own + /// client would. + pub(super) fn mob_event_particles(&mut self, id: u32, event: i8) { + let Some(m) = self.mobs.iter().find(|m| m.id == id) else { + return; + }; + let at = [m.position.x, m.position.y, m.position.z]; + self.lan_entity_event(id as i32, event, at); + self.entity_event_particles(id, event); + } + /// `handleEntityEvent(event)`'s particles about mob `id` + /// (`Villager`, `TamableAnimal`, `AbstractHorse`, `Animal`, `Allay`). + pub(super) fn entity_event_particles(&mut self, id: u32, event: i8) { + let Some(m) = self.mobs.iter().find(|m| m.id == id) else { + return; + }; + if let Some((kind, burst)) = + horizon_client::particles::entity_event_burst(&m.kind.id, event as u8) + { + self.particles_around_mob(id, kind, burst); + } } /// `particles::around_self` about mob `id`. pub(super) fn particles_around_mob( @@ -315,7 +334,7 @@ impl Game<'_> { } // Villager.setLastHurtByMob: entity event 13. for id in angry { - self.villager_particles(id, "angry_villager"); + self.mob_event_particles(id, 13); } } /// `Villager.tellWitnessesThatIWasMurdered`: the villagers that saw a @@ -370,7 +389,7 @@ impl Game<'_> { gossip::REPUTATION_CHANGE_PER_TRADE, ); // Villager.customServerAiStep after a trade: entity event 14. - self.villager_particles(id, "happy_villager"); + self.mob_event_particles(id, 14); } /// `Villager.getPlayerReputation` of the local player. pub(super) fn villager_reputation(&self, id: u32) -> i32 { diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs index 8084425ca..5f01633b0 100644 --- a/crates/horizon-client/src/game/wither.rs +++ b/crates/horizon-client/src/game/wither.rs @@ -2,11 +2,53 @@ //! its boss bar, and its skulls hitting and exploding. use super::Game; use horizon_client::{ + items::ItemStack, mobs::{Damage, DamageKind, Species, Who}, projectiles::{Projectile, ProjectileKind}, }; +use horizon_core::position::BlockPos; impl Game<'_> { + /// `LivingEntity.createWitherRose`: a mob a wither killed leaves a wither + /// rose where it stood (with mobGriefing, on air that can hold it), else + /// drops one. + pub(super) fn create_wither_rose(&mut self, m: &horizon_client::mobs::Mob) { + // getKillCredit: the player who last hurt it, else the last mob (kept + // for 100 ticks). + let by_wither = m.ai.last_hurt_by_player <= 0 + && m.age as i32 - m.ai.last_hurt_by_time <= 100 + && matches!(m.ai.last_hurt_by, Some(Who::Mob(id)) + if self.mobs.iter().any(|o| o.id == id && o.alive() && o.species() == Species::Wither)); + if !by_wither { + return; + } + let pos = [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ]; + let registry = self.pack.assets.registry; + let rose = registry.default_state("minecraft:wither_rose"); + if self.ui.rules.bool("mob_griefing") + && let Some(rose) = rose + && self + .res + .facts() + .is_air(self.world.block(pos[0], pos[1], pos[2])) + && self.with_level(|b, level, ticks| { + b.can_survive(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]), rose) + }) + { + let _ = self.level_set(pos, rose); + return; + } + self.spawn_item( + ItemStack::new("minecraft:wither_rose", 1), + [m.position.x, m.position.y, m.position.z], + super::dispenser::new_item_motion(), + 0, + ); + } fn is_wither_skull(&self, p: [i32; 3]) -> bool { let name = &*self .res @@ -130,7 +172,10 @@ impl Game<'_> { if let Some(id) = owner { self.note_attacker("minecraft:explosion", id); } - self.explode(at, 1.0) + self.combat.explosion_owner = owner; + let result = self.with_hive_emptying_blast(|g| g.explode(at, 1.0)); + self.combat.explosion_owner = None; + result } } /// Wither skulls drawn as the skull model, blue when dangerous. diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs index 454f9f2eb..d7c4f2b03 100644 --- a/crates/horizon-client/src/game/world_loading.rs +++ b/crates/horizon-client/src/game/world_loading.rs @@ -93,7 +93,12 @@ impl WorldRequest { level.hardcore = o.hardcore; level.difficulty = horizon_client::title::DIFFICULTIES[o.difficulty()].into(); level.allow_commands = Some(o.commands(creative)); - horizon_client::save::write_world_gen_settings(&save_root, level.seed, o.world_gen())?; + horizon_client::save::write_world_gen_settings_with( + &save_root, + level.seed, + o.world_gen(), + o.flat_settings(), + )?; // WorldCreationUiState.getGameRules, written with the level. level.game_rules = o.rules.by_name(); } diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index dc5369024..801dedde9 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -39,7 +39,7 @@ mod entity_outline; mod weather; use entity_batch::EntityBatch; pub use entity_batch::{ - SHADOW_OVERLAY, TRANSLUCENT_GLINT_ITEM_OVERLAY, TRANSLUCENT_ITEM_OVERLAY, + ENERGY_SWIRL_OVERLAY, SHADOW_OVERLAY, TRANSLUCENT_GLINT_ITEM_OVERLAY, TRANSLUCENT_ITEM_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY, }; @@ -176,12 +176,13 @@ struct Globals { inverse_view: [[f32; 4]; 4], sunrise: [f32; 4], sun: [f32; 4], - /// x: sky fog end, y: cloud fog end, z: dark disc (camera below the horizon), w: unused. + /// x: sky fog end, y: cloud fog end, z: dark disc (camera below the horizon), + /// w: the glint strength (`GlintAlpha`). fog_ends: [f32; 4], /// Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png. end_portal_sprites: [[f32; 4]; 2], /// x: vanilla's `GameTime` uniform; y: nether cardinal lighting; z: how many - /// `dynamic_lights` are set; w unused. + /// `dynamic_lights` are set; w: the glint scroll clock (`Glint::scroll_ticks`). time: [f32; 4], /// Atlas rect of a destroy stage (entity.wgsl takes only its size: every stage's is the same, /// and each crack carries its own stage's origin). @@ -262,6 +263,12 @@ pub struct Frame<'a> { /// drawn after the hand at its projection, without the bob or fog. pub debug_crosshair: &'a [[f32; 8]], pub hud: &'a HudBatch, + /// `GlintAlpha` (accessibility Glint Strength); the entity shader uses it + /// for held/world items, independent of what the HUD batch last drew. + pub glint_alpha: f32, + /// The glint scroll clock (`Glint::scroll_ticks`): entity.wgsl's + /// `ARMOR_ENTITY_GLINT_TEXTURING` phase. + pub glint_ticks: f32, /// CardinalLighting.Type.NETHER, otherwise DEFAULT. pub nether_lighting: bool, /// Camera-relative entity geometry textured from the shared atlas. @@ -411,6 +418,8 @@ pub struct Renderer { cloud_uniform: wgpu::Buffer, cloud_group: wgpu::BindGroup, additive_pipeline: wgpu::RenderPipeline, + /// `RenderPipelines.ENERGY_SWIRL`: additive, unlit, the sprite repeated within itself. + energy_swirl_pipeline: wgpu::RenderPipeline, lightning_pipeline: wgpu::RenderPipeline, lightning: lightning::Renderer, see_through_pipeline: wgpu::RenderPipeline, @@ -1032,6 +1041,8 @@ impl Renderer { sprite_mips: &[crate::mipmap::Settings], animations: &[SpriteAnimation], hud_atlas: (&[u8], u32, u32), + glint: (&[u8], u32, u32), + glint_armor: (&[u8], u32, u32), forcefield: (&[u8], u32), panorama_faces: &panorama::Faces, prepared: Option, @@ -1591,7 +1602,68 @@ impl Renderer { atlas_pixels, ); let atlas_view = atlas.create_view(&Default::default()); - let mut hud = HudRenderer::new(&device, config.format.remove_srgb_suffix(), &atlas_view)?; + // vanilla's `GlintSampler`: enchanted_glint_item as its own texture, + // repeated per pixel (`clamp: false`), linear without mipmaps + // (`blur: true`). + let (glint_pixels, glint_width, glint_height) = glint; + let glint_texture = device.create_texture_with_data( + &queue, + &wgpu::TextureDescriptor { + label: Some("Enchanted glint"), + size: wgpu::Extent3d { + width: glint_width, + height: glint_height, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }, + wgpu::util::TextureDataOrder::LayerMajor, + glint_pixels, + ); + let glint_view = glint_texture.create_view(&Default::default()); + let glint_sampler = device.create_sampler(&wgpu::SamplerDescriptor { + label: Some("Glint"), + address_mode_u: wgpu::AddressMode::Repeat, + address_mode_v: wgpu::AddressMode::Repeat, + mag_filter: wgpu::FilterMode::Linear, + min_filter: wgpu::FilterMode::Linear, + ..Default::default() + }); + // ARMOR_ENTITY_GLINT_TEXTURING's sampler is vanilla's GlintSampler: the + // same repeat and linear filtering as the item glint. + let (glint_armor_pixels, glint_armor_width, glint_armor_height) = glint_armor; + let glint_armor_texture = device.create_texture_with_data( + &queue, + &wgpu::TextureDescriptor { + label: Some("Enchanted armor glint"), + size: wgpu::Extent3d { + width: glint_armor_width, + height: glint_armor_height, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }, + wgpu::util::TextureDataOrder::LayerMajor, + glint_armor_pixels, + ); + let glint_armor_view = glint_armor_texture.create_view(&Default::default()); + let mut hud = HudRenderer::new( + &device, + config.format.remove_srgb_suffix(), + &atlas_view, + &glint_view, + &glint_sampler, + )?; hud.atlas_texture = Some(atlas.clone()); let entity_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Horizon entities"), @@ -1637,6 +1709,29 @@ impl Renderer { vf, wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), ), + entry( + 5, + vf, + wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: true }, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + ), + entry( + 6, + vf, + wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), + ), + entry( + 7, + vf, + wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: true }, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + ), ], }); let weather = weather::Weather::new( @@ -1673,6 +1768,18 @@ impl Renderer { binding: 4, resource: wgpu::BindingResource::Sampler(&lightmap_sampler), }, + wgpu::BindGroupEntry { + binding: 5, + resource: wgpu::BindingResource::TextureView(&glint_view), + }, + wgpu::BindGroupEntry { + binding: 6, + resource: wgpu::BindingResource::Sampler(&glint_sampler), + }, + wgpu::BindGroupEntry { + binding: 7, + resource: wgpu::BindingResource::TextureView(&glint_armor_view), + }, ], }); let hand_group = device.create_bind_group(&wgpu::BindGroupDescriptor { @@ -1699,6 +1806,18 @@ impl Renderer { binding: 4, resource: wgpu::BindingResource::Sampler(&lightmap_sampler), }, + wgpu::BindGroupEntry { + binding: 5, + resource: wgpu::BindingResource::TextureView(&glint_view), + }, + wgpu::BindGroupEntry { + binding: 6, + resource: wgpu::BindingResource::Sampler(&glint_sampler), + }, + wgpu::BindGroupEntry { + binding: 7, + resource: wgpu::BindingResource::TextureView(&glint_armor_view), + }, ], }); let entity_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { @@ -1743,7 +1862,7 @@ impl Renderer { usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); - let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; + let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2]; let entity_vertex = [Some(wgpu::VertexBufferLayout { array_stride: std::mem::size_of::() as u64, step_mode: wgpu::VertexStepMode::Vertex, @@ -1899,7 +2018,29 @@ impl Renderer { alpha_blend, false, ); - let lightning_attributes = wgpu::vertex_attr_array![6=>Float32x3]; + // RenderPipelines.ENERGY_SWIRL: BlendFunction.ADDITIVE (one, one), no culling; no depth + // writes either: vanilla sorts the quads far to near, so every face passes the test. + let one_one = wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::One, + dst_factor: wgpu::BlendFactor::One, + operation: wgpu::BlendOperation::Add, + }; + let energy_swirl_pipeline = entity_pipeline_with( + "Energy swirls", + None, + false, + wgpu::CompareFunction::GreaterEqual, + Default::default(), + wgpu::BlendState { + color: one_one, + alpha: one_one, + }, + false, + "fs_energy_swirl", + wgpu::ColorWrites::ALL, + ); + // Attribute 7: 6 is the entity vertex buffer's glint UV. + let lightning_attributes = wgpu::vertex_attr_array![7=>Float32x3]; let lightning_vertex = [ entity_vertex[0].clone(), Some(wgpu::VertexBufferLayout { @@ -2421,6 +2562,7 @@ impl Renderer { cloud_uniform, cloud_group, additive_pipeline, + energy_swirl_pipeline, lightning_pipeline, lightning: lightning::Renderer::new(), see_through_pipeline, @@ -3530,7 +3672,7 @@ impl Renderer { frame.fog.map_or(frame.distance.min(512.0), |f| f.sky_end), frame.fog.map_or(2048.0, |f| f.cloud_end), if frame.dark_disc { 1.0 } else { 0.0 }, - 0.0, + frame.glint_alpha, ], end_portal_sprites: frame.end_portal_sprites, crumbling_sprite: frame.crumbling_sprite, @@ -3538,7 +3680,7 @@ impl Renderer { frame.shader_game_time, f32::from(frame.nether_lighting), frame.dynamic_lights.len().min(crate::dynamic_light::MAX) as f32, - 0.0, + frame.glint_ticks, ], outline_params: outline_params(self.config.width, self.config.height), dynamic_lights: { @@ -4053,6 +4195,7 @@ impl Renderer { crumbling_quads, translucent_crumbling_quads, water_mask_quads, + swirl_quads, shadow_quads, translucent_particle_quads, translucent_item_quads, @@ -4064,6 +4207,7 @@ impl Renderer { + crumbling_quads + translucent_crumbling_quads + water_mask_quads + + swirl_quads + shadow_quads + translucent_particle_quads + translucent_item_quads; @@ -4653,6 +4797,21 @@ impl Renderer { self.lightning.draw(&mut pass, &frame.lightning); pass.set_bind_group(0, &self.group, &[]); } + if swirl_quads > 0 { + pass.set_pipeline(&self.energy_swirl_pipeline); + pass.set_bind_group(0, &self.entity_group, &[]); + pass.set_vertex_buffer(0, self.entity_buffer.slice(..)); + pass.draw_indexed( + 0..swirl_quads * 6, + ((entity_quads + + crumbling_quads + + translucent_crumbling_quads + + water_mask_quads) + * 4) as i32, + 0..1, + ); + pass.set_bind_group(0, &self.group, &[]); + } if additive_quads > 0 { pass.set_pipeline(&self.additive_pipeline); pass.set_bind_group(0, &self.entity_group, &[]); @@ -5325,6 +5484,7 @@ mod tests { color: 0xffff_ffff, light: id, normal: [0; 4], + glint_uv: [0.0, 0.0], }; 4] }; let entities: Vec<_> = [ @@ -5343,7 +5503,7 @@ mod tests { let mut batch = super::EntityBatch::default(); let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8)); let vertices = &batch.combined; - assert_eq!(counts, [4, 1, 1, 0, 1, 1, 0]); + assert_eq!(counts, [4, 1, 1, 0, 0, 1, 1, 0]); assert_eq!( vertices .as_chunks::<4>() diff --git a/crates/horizon-client/src/gfx/end_sky.rs b/crates/horizon-client/src/gfx/end_sky.rs index 15e9001fc..d74e053df 100644 --- a/crates/horizon-client/src/gfx/end_sky.rs +++ b/crates/horizon-client/src/gfx/end_sky.rs @@ -72,6 +72,8 @@ fn vertices(uv: [f32; 4]) -> Vec { layer: 2, color: 0xFF28_2828, light: 0, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/gfx/end_sky/tests.rs b/crates/horizon-client/src/gfx/end_sky/tests.rs index 61266003d..5cd2bcf7f 100644 --- a/crates/horizon-client/src/gfx/end_sky/tests.rs +++ b/crates/horizon-client/src/gfx/end_sky/tests.rs @@ -12,15 +12,15 @@ fn geometry_matches_pre_residency_vertex_snapshots() { for (uv, expected) in [ ( [0.0, 0.0, 1.0, 1.0], - "f7ee23457fc557b33ecf09c9afaf858f3d8907e108abf06055f627523f733536", + "82a9be3f3ed1f733017df2c81dc6dff163f67bf739c768e3fd0f90f00c7802f6", ), ( [0.125, 0.25, 0.375, 0.5], - "f74c4b8d23ec2b7c11b5752821d0733851bf11358f1b26f9448226ff62a6a318", + "05a058bd8e70cff900c8e1c81061892ed27866d86498ebe1e8ae5af4c3b770ef", ), ( [0.13, 0.27, 0.41, 0.59], - "f0aaa39c5b22168bdc7c6c329acb4d3598a2feb61ff7b6f2850b644682749b39", + "93064b9fd2e745da46b927b2625edc8a381bb8c6e20b0f0880e816c4c1745ec1", ), ] { let mut mesh = vertices(uv); @@ -31,10 +31,8 @@ fn geometry_matches_pre_residency_vertex_snapshots() { if n == 0.0 { 0.0 } else { n } }); } - assert_eq!( - format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh))), - expected - ); + let hash = format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh))); + assert_eq!(hash, expected); } } @@ -95,7 +93,7 @@ fn separate_draws_match_combined_celestial_pixels() { label: Some("End sky differential shader"), source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()), }); - let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2]; let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("End sky differential pipeline"), layout: None, @@ -305,6 +303,8 @@ fn separate_draws_match_combined_celestial_pixels() { color: level * 0x01010101, light: 0, normal: [0; 4], + + glint_uv: [0.0, 0.0], }) .to_vec() }; diff --git a/crates/horizon-client/src/gfx/entity_batch.rs b/crates/horizon-client/src/gfx/entity_batch.rs index 08d749b54..f71545f2c 100644 --- a/crates/horizon-client/src/gfx/entity_batch.rs +++ b/crates/horizon-client/src/gfx/entity_batch.rs @@ -3,13 +3,18 @@ use super::Vertex; /// Entity materials by a quad's overlay (`Vertex::layer`), in draw order: /// ordinary entities, breaking cracks (11), translucent breaking cracks (12), -/// the boat water mask (13, `RenderPipelines.WATER_MASK`), entity shadows -/// (14, `RenderPipelines.ENTITY_SHADOW`) and translucent-layer particles (15, -/// drawn after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`) +/// the boat water mask (13, `RenderPipelines.WATER_MASK`), energy swirls +/// (34, `RenderPipelines.ENERGY_SWIRL`), entity shadows (14, +/// `RenderPipelines.ENTITY_SHADOW`), translucent-layer particles (15, drawn +/// after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`) /// and translucent item quads (32, drawn without depth writes). -const MATERIALS: usize = 7; +const MATERIALS: usize = 8; /// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`). pub const WATER_MASK_OVERLAY: u32 = 13; +/// The overlay of energy swirl quads (`RenderTypes.energySwirl`: the charged creeper's and the +/// powered wither's armour). The light bytes carry the sprite's origin and the colour bytes its +/// size (`breaking::stage_light`), the UV the scrolled position in the sprite. +pub const ENERGY_SWIRL_OVERLAY: u32 = 34; /// The overlay of entity shadow quads (`RenderTypes.entityShadow`). pub const SHADOW_OVERLAY: u32 = 14; /// The overlay of translucent-layer particles (`SingleQuadParticle.Layer.translucent`). @@ -49,9 +54,10 @@ impl EntityBatch { 11 => 1, 12 => 2, WATER_MASK_OVERLAY => 3, - SHADOW_OVERLAY => 4, - TRANSLUCENT_PARTICLE_OVERLAY => 5, - TRANSLUCENT_ITEM_OVERLAY | TRANSLUCENT_GLINT_ITEM_OVERLAY => 6, + ENERGY_SWIRL_OVERLAY => 4, + SHADOW_OVERLAY => 5, + TRANSLUCENT_PARTICLE_OVERLAY => 6, + TRANSLUCENT_ITEM_OVERLAY | TRANSLUCENT_GLINT_ITEM_OVERLAY => 7, _ => 0, }; self.buckets[material][counts[material]] = index; @@ -103,12 +109,13 @@ mod tests { ) -> (Vec, [u32; MATERIALS]) { let mut combined = Vec::with_capacity(entities.len() + additive.len() + hand.len()); let mut counts = [0; MATERIALS]; - for (i, layer) in [0, 11, 12, 13, 14, 15].into_iter().enumerate() { + for (i, layer) in [0, 11, 12, 13, 34, 14, 15].into_iter().enumerate() { for quad in entities.as_chunks::<4>().0 { let material = match quad[0].layer { 11 => 11, 12 => 12, 13 => 13, + 34 => 34, 14 => 14, 15 => 15, _ => 0, @@ -137,6 +144,8 @@ mod tests { color: index as u32, light: (index * 3) as u32, normal: [1, 2, 3, 4], + + glint_uv: [0.0, 0.0], }) .collect() } diff --git a/crates/horizon-client/src/gfx/lightning.rs b/crates/horizon-client/src/gfx/lightning.rs index 251dbf00e..d979bb368 100644 --- a/crates/horizon-client/src/gfx/lightning.rs +++ b/crates/horizon-client/src/gfx/lightning.rs @@ -77,6 +77,8 @@ fn geometry(seed: i64, uv: [f32; 2]) -> Vec { layer: 2, color, light: 240 | 240 << 8, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/gfx/lightning/tests/mod.rs b/crates/horizon-client/src/gfx/lightning/tests/mod.rs index f89f402de..66959ce54 100644 --- a/crates/horizon-client/src/gfx/lightning/tests/mod.rs +++ b/crates/horizon-client/src/gfx/lightning/tests/mod.rs @@ -60,6 +60,8 @@ fn reference(seed: i64, at: [f64; 3], camera: DVec3, uv: [f32; 2]) -> VecFloat32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; - let offsets = wgpu::vertex_attr_array![6=>Float32x3]; + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2]; + // Attribute 7: 6 is the entity vertex buffer's glint UV. + let offsets = wgpu::vertex_attr_array![7=>Float32x3]; let vertices = [Some(wgpu::VertexBufferLayout { array_stride: std::mem::size_of::() as u64, step_mode: wgpu::VertexStepMode::Vertex, diff --git a/crates/horizon-client/src/gfx/pack_entities.rs b/crates/horizon-client/src/gfx/pack_entities.rs index ab3c66c69..c6bcd8beb 100644 --- a/crates/horizon-client/src/gfx/pack_entities.rs +++ b/crates/horizon-client/src/gfx/pack_entities.rs @@ -405,12 +405,12 @@ pub(super) fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer { } /// Whether a run holds only geometry a gbuffers program can draw from the shared atlas: no -/// celestial body, cloud, beam, End portal or crack (overlay codes Horizon's entity shader -/// draws in its own way; entity.wgsl). +/// celestial body, cloud, beam, End portal, crack or energy swirl (overlay codes Horizon's entity +/// shader draws in its own way; entity.wgsl). fn plain(run: &[Vertex]) -> bool { run.iter() .step_by(4) - .all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12)) + .all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12 | 34)) } /// The programs of entity runs, in the order they draw. diff --git a/crates/horizon-client/src/gfx/pack_weather.rs b/crates/horizon-client/src/gfx/pack_weather.rs index 3479450af..f6bef0219 100644 --- a/crates/horizon-client/src/gfx/pack_weather.rs +++ b/crates/horizon-client/src/gfx/pack_weather.rs @@ -135,6 +135,8 @@ impl PackWeather { color: v.color, light: v.light, normal: [0; 4], + + glint_uv: [0.0, 0.0], } })); if self.scratch.len() > self.capacity { diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs index d55e44d99..cb097c114 100644 --- a/crates/horizon-client/src/graphics_ui.rs +++ b/crates/horizon-client/src/graphics_ui.rs @@ -5,8 +5,7 @@ use crate::{ graphics::{FarDetail, GraphicsApi, Overlay, Pacing, PresentMode, Preset}, graphics_style::{Cost, STYLE}, hud::{HudAtlas, HudBatch}, - options_ui::Opt, - settings::Settings, + settings::{Opt, Settings}, text::Text, ui, }; diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs index 31e4e8104..28391c496 100644 --- a/crates/horizon-client/src/health.rs +++ b/crates/horizon-client/src/health.rs @@ -25,29 +25,7 @@ use std::{fs, io, path::Path}; pub(crate) type Attributes = LiveAttributes i32>>; pub(crate) type State = HurtState; -#[derive(Clone, Copy, Debug)] -pub struct HealthRules { - pub difficulty: Difficulty, - pub natural_regeneration: bool, - /// The `drowning_damage`, `fall_damage`, `fire_damage` and - /// `freeze_damage` rules `Player.isInvulnerableTo` reads. - pub drowning_damage: bool, - pub fall_damage: bool, - pub fire_damage: bool, - pub freeze_damage: bool, -} -impl Default for HealthRules { - fn default() -> Self { - Self { - difficulty: Difficulty::Normal, - natural_regeneration: true, - drowning_damage: true, - fall_damage: true, - fire_damage: true, - freeze_damage: true, - } - } -} +pub use crate::world::HealthRules; pub struct HealthResources { pub damage: Catalog, pub ids: PlayerFloatIds, @@ -180,6 +158,12 @@ pub struct PlayerHealth { pub hurt: State, /// Client hurt animation; fully blocked hits only refresh the server's hurt state. pub hurt_animation_time: i32, + /// `Player.hurtDir` on a client: the yaw `ClientboundHurtAnimationPacket` + /// gave, which `GameRenderer.bobHurt` tilts the camera around. + pub hurt_dir: f32, + /// `ServerPlayer.hurtDir` of a hit the player's client hasn't been told + /// of yet (`indicateDamage`). + pub indicated_dir: Option, pub dead: bool, pub sync_velocity: bool, pub game_time: i64, @@ -230,6 +214,8 @@ impl PlayerHealth { last_stamp: 0, }, hurt_animation_time: 0, + hurt_dir: 0.0, + indicated_dir: None, dead: false, sync_velocity: false, game_time: 0, @@ -277,6 +263,18 @@ impl PlayerHealth { self.hurt.hurt_time = 10; self.hurt_animation_time = 10; } + /// `LivingEntity.animateHurt(yaw)` on a player: the tilt restarts around + /// `yaw` (`Player.animateHurt` keeps it as `hurtDir`). + pub fn animate_hurt_dir(&mut self, yaw: f32) { + self.animate_hurt(); + self.hurt_dir = yaw; + } + /// `ServerPlayer.indicateDamage`: the hit's direction relative to where + /// the player looks, kept for the packet to its client. + pub fn indicate_damage(&mut self, xd: f64, zd: f64, yaw: f32) { + use horizon_core::geometry::trig::{RAD_TO_DEG, atan2}; + self.indicated_dir = Some((atan2(zd, xd) * f64::from(RAD_TO_DEG) - f64::from(yaw)) as f32); + } /// `LocalPlayer.hurtTo` with `flashOnSetHealth`: a drop below the current /// health starts the hurt animation; `damageCooldownTime` (20 on a drop, /// 10 on a gain) is what lets `Hud.extractPlayerHealth` blink the hearts. @@ -380,6 +378,13 @@ impl PlayerMotion { if outcome.hurt { h.hurt_animation_time = h.hurt.hurt_time; } + // `dealDefaultKnockback` ends in `indicateDamage` unless blocked: a + // hit with no direction of its own (`xd` and `zd` zero) is sent as + // the opposite of the player's yaw. A hit that has a direction + // replaces this (`mob_hits_player`). + if outcome.knockback && outcome.blocked <= 0.0 { + h.indicate_damage(0.0, 0.0, self.yaw); + } let after = h.health() + h.absorption(); if self.hurt_log.len() >= HURT_LOG { self.hurt_log.remove(0); diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 850093780..2b9bae9b5 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -67,6 +67,11 @@ pub struct HudAtlas { pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>, /// The default font (bitmap sheets in this atlas, unifont rasterized on demand). pub font: crate::font::Font, + /// `misc/enchanted_glint_item` as its own image: vanilla's `GlintSampler` + /// repeats it per pixel, which one sprite inside this atlas cannot. + pub glint: (Vec, u32, u32), + /// `misc/enchanted_glint_armor`, the armour layers' `GlintSampler`. + pub glint_armor: (Vec, u32, u32), white: Rect, } /// Atlas rows reserved for glyphs rasterized at run time. @@ -526,6 +531,8 @@ impl HudAtlas { } } let white = sprites["horizon/white"]; + let glint = Self::glint_texture(root, defaults, "enchanted_glint_item"); + let glint_armor = Self::glint_texture(root, defaults, "enchanted_glint_armor"); let font = crate::font::Font::load( root, &sprites, @@ -542,10 +549,22 @@ impl HudAtlas { translucent, flags, fire_animations, + glint, + glint_armor, font, white, }) } + /// `misc/.png` on its own, or a transparent texel if the resource + /// pack lacks it. + fn glint_texture(root: &Path, defaults: &Path, name: &str) -> (Vec, u32, u32) { + let relative = format!("assets/minecraft/textures/misc/{name}.png"); + let mut path = root.join(&relative); + if !path.exists() && defaults != root { + path = defaults.join(&relative); + } + decode(&path).map_or((vec![0; 4], 1, 1), |(w, h, pixels)| (pixels, w, h)) + } } #[repr(C)] #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)] @@ -554,6 +573,9 @@ pub struct HudVertex { pub uv: [f32; 2], pub color: u32, pub depth: f32, + /// The `GLINT_TEXTURING` UV into the repeating glint texture, unused + /// unless `uv.x >= 2`. + pub glint_uv: [f32; 2], } /// The GUI Scale option (0 = auto). pub static GUI_SCALE: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0); @@ -569,6 +591,8 @@ pub struct HudBatch { pub blends: Vec<(std::ops::Range, Blend)>, /// The textures and time of the `Blend::EndPortal` runs. pub end_portal: EndPortalFill, + /// `options.glintStrength` for the glint pass (`GlintAlpha`). + pub glint_alpha: f32, /// Screen's first vertex: the preceding HUD is part of its blurred background. pub blur_at: u32, } @@ -620,6 +644,7 @@ impl HudBatch { patches: Vec::new(), blends: Vec::new(), end_portal: EndPortalFill::default(), + glint_alpha: 0.75, blur_at: 0, } } @@ -695,6 +720,26 @@ impl HudBatch { uv: uv[i], color, depth: 0.0, + glint_uv: [0.0, 0.0], + }); + } + } + /// A quad whose texture is the `GLINT_TEXTURING` sample at `glint_uv`; + /// `uv` is the item's atlas UV, which the shader masks by. + pub fn quad_glint( + &mut self, + p: [[f32; 2]; 4], + uv: [[f32; 2]; 4], + glint_uv: [[f32; 2]; 4], + color: u32, + ) { + for i in [0, 1, 2, 0, 2, 3] { + self.vertices.push(HudVertex { + pos: p[i], + uv: uv[i], + color, + depth: 0.0, + glint_uv: glint_uv[i], }); } } @@ -705,6 +750,7 @@ impl HudBatch { uv: uv[i], color, depth: p[i][2], + glint_uv: [0.0, 0.0], }); } } @@ -875,6 +921,7 @@ impl HudBatch { uv, color: c[i], depth: 0.0, + glint_uv: [0.0, 0.0], }); } } @@ -1055,6 +1102,8 @@ impl HudRenderer { device: &wgpu::Device, format: wgpu::TextureFormat, view: &wgpu::TextureView, + glint_view: &wgpu::TextureView, + glint_sampler: &wgpu::Sampler, ) -> Result { let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Horizon HUD"), @@ -1099,6 +1148,22 @@ impl HudRenderer { ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), count: None, }, + wgpu::BindGroupLayoutEntry { + binding: 3, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: true }, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + count: None, + }, + wgpu::BindGroupLayoutEntry { + binding: 4, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), + count: None, + }, ], }); let group = device.create_bind_group(&wgpu::BindGroupDescriptor { @@ -1117,6 +1182,14 @@ impl HudRenderer { binding: 2, resource: wgpu::BindingResource::Sampler(&sampler), }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::TextureView(glint_view), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: wgpu::BindingResource::Sampler(glint_sampler), + }, ], }); let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { @@ -1124,7 +1197,8 @@ impl HudRenderer { bind_group_layouts: &[Some(&layout)], ..Default::default() }); - let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32]; + let attributes = + wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32,4=>Float32x2]; let create = |label, blend, fragment_entry, depth: bool| { device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some(label), @@ -1339,7 +1413,12 @@ impl HudRenderer { &self.uniform, 0, bytemuck::bytes_of(&HudUniform::new( - [size[0] as f32, size[1] as f32, batch.scale, 0.0], + [ + size[0] as f32, + size[1] as f32, + batch.scale, + batch.glint_alpha, + ], batch.end_portal, )), ); @@ -1789,6 +1868,7 @@ mod tests { patches: Vec::new(), blends: Vec::new(), end_portal: EndPortalFill::default(), + glint_alpha: 0.75, blur_at: 0, }; for (image_width, image_height) in [(195, 136), (176, 166), (176, 222)] { diff --git a/crates/horizon-client/src/hud.wgsl b/crates/horizon-client/src/hud.wgsl index ebb6dc2cb..435f7f062 100644 --- a/crates/horizon-client/src/hud.wgsl +++ b/crates/horizon-client/src/hud.wgsl @@ -7,28 +7,35 @@ struct Hud { @group(0) @binding(0) var hud: Hud; @group(0) @binding(1) var atlas: texture_2d; @group(0) @binding(2) var atlas_sampler: sampler; +// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler). +@group(0) @binding(3) var glint_tex: texture_2d; +@group(0) @binding(4) var glint_sampler: sampler; struct Out { @builtin(position) clip: vec4, @location(0) uv: vec2, @location(1) color: vec4, // projection_from_position(gl_Position): the End portal's texProj0. @location(2) proj: vec4, + @location(3) glint_uv: vec2, } -@vertex fn vs_main(@location(0) pos: vec2, @location(1) uv: vec2, @location(2) color: vec4, @location(3) depth: f32) -> Out { +@vertex fn vs_main(@location(0) pos: vec2, @location(1) uv: vec2, @location(2) color: vec4, @location(3) depth: f32, @location(4) glint_uv: vec2) -> Out { let pixels = pos * hud.size.z; var out: Out; out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, depth, 1.0); out.uv = uv; out.color = color; out.proj = vec4(out.clip.xy * 0.5 + 0.5, out.clip.zw); + out.glint_uv = glint_uv; return out; } @fragment fn fs_main(in: Out) -> @location(0) vec4 { - // u >= 2: flat vertex colour masked by the texture's alpha (enchantment glint). + // u >= 2: the GLINT_TEXTURING sample over the item, masked by the item's + // texture alpha (item.fsh's ALPHA_CUTOUT and GLINT path). if in.uv.x >= 2.0 { - let m = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a * in.color.a; - if m < 0.004 { discard; } - return vec4(in.color.rgb, m); + let mask = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a; + if mask < 0.1 { discard; } + let glint = hud.size.w * textureSample(glint_tex, glint_sampler, in.glint_uv); + return vec4(glint.rgb * glint.rgb, mask); } let c = textureSample(atlas, atlas_sampler, in.uv) * in.color; if c.a < 0.004 { discard; } diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs index c6b098f75..8af2c2a0d 100644 --- a/crates/horizon-client/src/hud_overlays.rs +++ b/crates/horizon-client/src/hud_overlays.rs @@ -107,10 +107,11 @@ pub struct EffectIcon { impl From<&crate::effects::EffectInstance> for EffectIcon { fn from(effect: &crate::effects::EffectInstance) -> Self { - let def = crate::brewing::effect(effect.id); + let def = horizon_client_core::potions::effect(effect.id); Self { id: effect.id.to_owned(), - beneficial: def.is_some_and(|d| d.category == crate::brewing::Category::Beneficial), + beneficial: def + .is_some_and(|d| d.category == horizon_client_core::potions::Category::Beneficial), color: def.map_or(0, |d| d.color as i32), ambient: effect.ambient, duration: effect.duration, diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs index 9873752ca..1bd80437f 100644 --- a/crates/horizon-client/src/item_data.rs +++ b/crates/horizon-client/src/item_data.rs @@ -143,6 +143,9 @@ pub struct WrittenBook { pub author: String, pub generation: u8, pub pages: Vec, + /// Each page's component when it is not a plain string, so that its + /// click events survive; empty or one per page. + pub page_tags: Vec, } impl StackData { pub fn is_empty(&self) -> bool { @@ -214,6 +217,19 @@ impl ItemStack { pub fn has_any_enchantments(&self) -> bool { !self.enchantments().is_empty() || !self.stored_enchantments().is_empty() } + /// `ItemStack.hasFoil`: an explicit `minecraft:enchantment_glint_override` + /// component wins, then the item's default override (`item_glint`), then a + /// non-empty `minecraft:enchantments` component (`Item.isFoil` is + /// `ItemStack.isEnchanted`; stored book enchantments do not count). + pub fn has_foil(&self, item_glint: bool) -> bool { + if let Some(Tag::Byte(flag)) = self + .data() + .and_then(|d| d.other("minecraft:enchantment_glint_override")) + { + return *flag != 0; + } + item_glint || !self.enchantments().is_empty() + } pub fn repair_cost(&self) -> u32 { self.data().map_or(0, |d| d.repair_cost) } @@ -309,6 +325,21 @@ fn read_levels(t: Option<&Tag>) -> Levels { } /// A text component as stored by vanilla: a plain string or `{"text": ...}`. /// A `Filterable`: the value itself or `{raw: value}`. +/// `ComponentSerialization.CODEC`'s short form: a plain text component with +/// no style and no siblings is written as its string. +fn plain_component(t: &Tag) -> Tag { + if let Tag::Compound(c) = t + && let Some(text @ Tag::String(_)) = c.get(&"text".into()) + && c.iter().all(|(k, v)| { + k.to_string_lossy() == "text" + || (k.to_string_lossy() == "type" + && matches!(v, Tag::String(s) if s.to_string_lossy() == "text")) + }) + { + return text.clone(); + } + t.clone() +} fn filterable_text(t: &Tag) -> Option { match t.get("raw") { Some(raw) => read_text(raw), @@ -540,11 +571,14 @@ pub fn components_tag(damage: u32, data: Option<&StackData>) -> Option { )); } if let Some(w) = &d.written { - let pages = w - .pages - .iter() - .map(|p| raw(Tag::String(p.as_str().into()))) - .collect(); + let pages = if w.page_tags.len() == w.pages.len() { + w.page_tags.iter().cloned().map(raw).collect() + } else { + w.pages + .iter() + .map(|p| raw(Tag::String(p.as_str().into()))) + .collect() + }; entries.push(( "minecraft:written_book_content", Tag::compound({ @@ -725,6 +759,13 @@ pub fn decode_components(components: Option<&Tag>) -> (u32, Option pages.iter().filter_map(filterable_text).collect(), _ => Vec::new(), }, + page_tags: match b.get("pages") { + Some(Tag::List(pages)) => pages + .iter() + .map(|p| plain_component(p.get("raw").unwrap_or(p))) + .collect(), + _ => Vec::new(), + }, }), fireworks: c .get("minecraft:fireworks") diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs index 8dabae0bb..107da9208 100644 --- a/crates/horizon-client/src/item_render.rs +++ b/crates/horizon-client/src/item_render.rs @@ -41,6 +41,9 @@ use std::{ pub struct ItemQuad { pub pos: [Vec3; 4], pub uv: [[f32; 2]; 4], + /// The model UVs `GLINT_TEXTURING` scrolls for the glint (vanilla's UV0, + /// or UV3 for a special model). + pub foil_uv: [[f32; 2]; 4], pub normal: Vec3, pub color: u32, pub foil: Foil, @@ -50,6 +53,47 @@ pub struct ItemQuad { /// is a translucent sheet): drawn with the translucent entities. pub translucent: bool, } +/// `TextureTransform.setupGlintTexturing`'s inputs. +#[derive(Clone, Copy, Debug)] +pub struct Glint { + /// `options.glintSpeed` (vanilla default 0.5). + pub speed: f32, + /// `options.glintStrength` / shader `GlintAlpha` (vanilla default 0.75). + pub alpha: f32, + /// `Util.getMillis()`. + pub millis: f32, + /// The transform's scale: `GLINT_TEXTURING`'s 8.0 for GUI items, + /// `ENTITY_GLINT_TEXTURING`'s 0.5 for items in the world and + /// `ARMOR_ENTITY_GLINT_TEXTURING`'s 0.16 for armour (entity.wgsl). + pub scale: f32, +} +impl Glint { + /// `Util.getMillis() * glintSpeed * 8.0` as vanilla's long. + fn ticks(millis: f32, speed: f32) -> i64 { + (f64::from(millis) * f64::from(speed) * 8.0) as i64 + } + /// The scroll clock modulo the common period of both offsets (110000 and + /// 30000 divide 330000), for `globals.time.w`: the entity shader derives + /// `ARMOR_ENTITY_GLINT_TEXTURING` from it. + pub fn scroll_ticks(millis: f32, speed: f32) -> f32 { + (Self::ticks(millis, speed) % 330_000) as f32 + } + /// `TextureTransform.setupGlintTexturing(scale)` applied to the model UV: + /// translation(-o0, o1) * rotateZ(PI/18) * scale. The result repeats: + /// the shader samples the dedicated glint texture with vanilla's + /// repeating `GlintSampler`, so the UVs stay unwrapped. + pub fn uv(&self, model: [f32; 2]) -> [f32; 2] { + let ticks = Self::ticks(self.millis, self.speed); + let offset0 = (ticks % 110_000) as f32 / 110_000.0; + let offset1 = (ticks % 30_000) as f32 / 30_000.0; + let angle = std::f32::consts::PI / 18.0; + let (sin, cos) = angle.sin_cos(); + [ + model[0] * self.scale * cos - model[1] * self.scale * sin - offset0, + model[0] * self.scale * sin + model[1] * self.scale * cos + offset1, + ] + } +} /// Which glint render type a quad uses. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Foil { @@ -258,6 +302,7 @@ fn submit_quads( sink.quad(ItemQuad { pos, uv, + foil_uv: q.uv, normal: transform_normal(m, direction_vector(q.facing)), color: argb(color), foil, @@ -712,6 +757,8 @@ pub struct WorldSink<'a> { pub light: u32, /// The level's diffuse lights; `None` leaves the colour unshaded. pub lights: Option<(Vec3, Vec3)>, + /// The `GLINT_TEXTURING` sample for foil quads (`None` leaves them unglinted). + pub glint: Option, } impl ItemSink for WorldSink<'_> { fn quad(&mut self, q: ItemQuad) { @@ -726,13 +773,19 @@ impl ItemSink for WorldSink<'_> { } else { self.light }; - let overlay = match (q.foil, q.translucent) { - (Foil::None, true) => crate::gfx::TRANSLUCENT_ITEM_OVERLAY, - (Foil::None, false) => 0, - (_, true) => crate::gfx::TRANSLUCENT_GLINT_ITEM_OVERLAY, - (_, false) => 7, + let glint = if q.foil == Foil::None { + None + } else { + self.glint }; - for (p, uv) in q.pos.iter().zip(q.uv) { + let overlay = match (glint.is_some(), q.translucent) { + (false, true) => crate::gfx::TRANSLUCENT_ITEM_OVERLAY, + (false, false) => 0, + (true, true) => crate::gfx::TRANSLUCENT_GLINT_ITEM_OVERLAY, + (true, false) => 7, + }; + 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], pos: p.to_array(), @@ -740,6 +793,7 @@ impl ItemSink for WorldSink<'_> { layer: overlay, color, light, + glint_uv, }); } } diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs index e0c901c0e..a99969679 100644 --- a/crates/horizon-client/src/item_render/gui.rs +++ b/crates/horizon-client/src/item_render/gui.rs @@ -5,7 +5,7 @@ //! drawn far to near, and clipped to the item's 16x16 slot unless the model //! is oversized in the GUI (`GuiItemAtlas` draws each item into a scissored //! 16x16 slot; oversized items get a picture-in-picture of their bounds). -use super::{Foil, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost}; +use super::{Foil, Glint, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost}; use crate::hud::{HudBatch, Rect}; use glam::{EulerRot, Mat4, Vec2, Vec3}; use std::{collections::HashMap, f32::consts::PI, sync::Arc}; @@ -43,6 +43,7 @@ pub fn items_3d_lights() -> (Vec3, Vec3) { struct Point { p: Vec2, uv: [f32; 2], + glint_uv: [f32; 2], } fn lerp(a: Point, b: Point, t: f32) -> Point { Point { @@ -51,6 +52,10 @@ fn lerp(a: Point, b: Point, t: f32) -> Point { a.uv[0] + (b.uv[0] - a.uv[0]) * t, a.uv[1] + (b.uv[1] - a.uv[1]) * t, ], + glint_uv: [ + a.glint_uv[0] + (b.glint_uv[0] - a.glint_uv[0]) * t, + a.glint_uv[1] + (b.glint_uv[1] - a.glint_uv[1]) * t, + ], } } /// Sutherland-Hodgman against one half plane `dot(p, n) <= limit`. @@ -97,37 +102,25 @@ pub fn lit_color(q: &ItemQuad, lights: (Vec3, Vec3)) -> u32 { let c = |v: u8| (f32::from(v) * light) as u8; crate::hud::rgba(c(r), c(g), c(b), a) } -/// The glint's moving sheen at a GUI position (a stand-in for the -/// `GLINT_TEXTURING`-scrolled `enchanted_glint_item` texture added on top). -fn glint_color(p: Vec2, time: f32) -> u32 { - let d = ((p.x + p.y) / 32.0 - time * 0.35).rem_euclid(1.0); - let band = (1.0 - (d - 0.5).abs() * 6.0).max(0.0); - crate::hud::rgba( - (170.0 + 70.0 * band) as u8, - (90.0 + 110.0 * band) as u8, - 255, - (45.0 + 110.0 * band) as u8, - ) -} - -fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: bool) { - let shift = if glint { 2.0 } else { 0.0 }; +fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: Option<&Glint>) { for i in 1..fan.len().saturating_sub(1) { let (a, b, c) = (fan[0], fan[i], fan[i + 1]); let corners = [a, b, c, c]; - // `HudBatch.quad` draws (0, 1, 2) and (0, 2, 3): the second is empty. - batch.quad( - corners.map(|v| v.p.to_array()), - corners.map(|v| [v.uv[0] + shift, v.uv[1]]), - color(a.p), - ); - if glint { - // Per-vertex colours are flat per quad in the HUD batch: use the - // fan centre for the sheen. - let n = batch.vertices.len(); - for v in &mut batch.vertices[n - 6..] { - v.color = color(Vec2::from(v.pos)); - } + if let Some(glint) = glint { + let start = batch.vertices.len(); + batch.quad_glint( + corners.map(|v| v.p.to_array()), + corners.map(|v| [v.uv[0] + 2.0, v.uv[1]]), + corners.map(|v| glint.uv(v.glint_uv)), + u32::MAX, + ); + batch.blend_since(start, crate::hud::Blend::Additive); + } else { + batch.quad( + corners.map(|v| v.p.to_array()), + corners.map(|v| v.uv), + color(a.p), + ); } } } @@ -144,6 +137,8 @@ pub fn draw( x: f32, y: f32, time: f32, + glint_speed: f32, + glint_alpha: f32, ) { if state.is_empty() { return; @@ -162,7 +157,18 @@ pub fn draw( return; } let start = batch.vertices.len(); - draw_now(state, renderer, sprites, host, batch, x, y, time); + draw_now( + state, + renderer, + sprites, + host, + batch, + x, + y, + time, + glint_speed, + glint_alpha, + ); if let Some(key) = key && let Ok(mut drawn) = renderer.gui_drawn.lock() { @@ -236,6 +242,8 @@ fn draw_now( x: f32, y: f32, time: f32, + glint_speed: f32, + glint_alpha: f32, ) { let pose = Mat4::from_translation(Vec3::new(x + 8.0, y + 8.0, 0.0)) * Mat4::from_scale(Vec3::new(16.0, -16.0, 16.0)); @@ -256,7 +264,16 @@ fn draw_now( } else { [x, y, x + 16.0, y + 16.0] }; - draw_quads(&quads, lights, batch, rect, time); + let glint = sprites + .contains_key("misc/enchanted_glint_item") + .then_some(Glint { + speed: glint_speed, + alpha: glint_alpha, + millis: time * 1000.0, + scale: 8.0, + }); + batch.glint_alpha = glint_alpha; + draw_quads(&quads, lights, batch, rect, glint.as_ref()); } /// Lights, culls, sorts far to near and clips `quads` (GUI positions) to @@ -266,7 +283,7 @@ fn draw_quads( lights: (Vec3, Vec3), batch: &mut HudBatch, rect: [f32; 4], - time: f32, + glint: Option<&Glint>, ) { for face in depth::sort(quads) { let q = &quads[face.quad]; @@ -276,6 +293,7 @@ fn draw_quads( .map(|v| Point { p: v.pos.truncate(), uv: v.uv, + glint_uv: v.glint_uv, }) .collect(); let color = lit_color(q, lights); @@ -285,9 +303,9 @@ fn draw_quads( if fan.len() < 3 { continue; } - emit(batch, &fan, |_| color, false); + emit(batch, &fan, |_| color, None); if q.foil != Foil::None { - emit(batch, &fan, |p| glint_color(p, time), true); + emit(batch, &fan, |_| color, glint); } } } @@ -342,7 +360,7 @@ pub fn draw_banner_result( items_flat_lights(), batch, [x0, y0, x0 + 20.0, y0 + 40.0], - 0.0, + None, ); } @@ -354,6 +372,7 @@ mod tests { ItemQuad { pos: [(0.0, y0), (0.0, y1), (8.0, y1), (8.0, y0)].map(|(x, y)| Vec3::new(x, y, z(y))), uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]], + foil_uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]], normal: Vec3::Z, color, foil: Foil::None, @@ -395,7 +414,7 @@ mod tests { (Vec3::Z, Vec3::Z), &mut batch, [0.0, 0.0, 16.0, 16.0], - 0.0, + None, ); assert_eq!(color_at(&batch, Vec2::new(4.0, 0.5)), Some(u32::MAX)); } @@ -411,7 +430,7 @@ mod tests { (Vec3::Z, Vec3::Z), &mut batch, [0.0, 0.0, 16.0, 16.0], - 0.0, + None, ); assert_eq!( color_at(&batch, Vec2::new(4.0, 2.0)), @@ -443,7 +462,7 @@ mod tests { (Vec3::Z, Vec3::Z), &mut batch, [0.0, 0.0, 16.0, 16.0], - 0.0, + None, ); for y in [0.5, 6.0] { assert_eq!( @@ -469,6 +488,7 @@ mod tests { let p = |x: f32, y: f32| Point { p: Vec2::new(x, y), uv: [x, y], + glint_uv: [0.0, 0.0], }; let fan = clip_triangle( [p(-4.0, 0.0), p(8.0, 0.0), p(8.0, 8.0)], diff --git a/crates/horizon-client/src/item_render/gui/depth.rs b/crates/horizon-client/src/item_render/gui/depth.rs index 9fecfdee7..aaaa0c55d 100644 --- a/crates/horizon-client/src/item_render/gui/depth.rs +++ b/crates/horizon-client/src/item_render/gui/depth.rs @@ -10,6 +10,7 @@ use glam::{Vec3, Vec4}; pub(super) struct Corner { pub pos: Vec3, pub uv: [f32; 2], + pub glint_uv: [f32; 2], } pub(super) struct Face { @@ -38,6 +39,9 @@ fn split(face: Face, distances: &[f32]) -> (Face, Face) { let corner = Corner { pos: a.pos.lerp(b.pos, t), uv: std::array::from_fn(|k| a.uv[k] + (b.uv[k] - a.uv[k]) * t), + glint_uv: std::array::from_fn(|k| { + a.glint_uv[k] + (b.glint_uv[k] - a.glint_uv[k]) * t + }), }; back.push(corner); front.push(corner); @@ -73,6 +77,7 @@ pub(super) fn sort(quads: &[ItemQuad]) -> Vec { corners: std::array::from_fn::<_, 4, _>(|k| Corner { pos: q.pos[k], uv: q.uv[k], + glint_uv: q.foil_uv[k], }) .to_vec(), }) diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs index 445ebcdad..6a1d049af 100644 --- a/crates/horizon-client/src/item_render/special.rs +++ b/crates/horizon-client/src/item_render/special.rs @@ -115,6 +115,7 @@ fn draw( sprite.v0 + (sprite.v1 - sprite.v0) * v[4], ] }), + foil_uv: poly.map(|v| [v[3], v[4]]), normal, color, foil, diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 2deb5905e..9f83e1457 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -669,11 +669,14 @@ fn network_stack( title: w.title.clone(), author: w.author.clone(), generation: i32::from(w.generation), - pages: w - .pages - .iter() - .map(|p| horizon_protocol::text::literal(p)) - .collect(), + pages: if w.page_tags.len() == w.pages.len() { + w.page_tags.clone() + } else { + w.pages + .iter() + .map(|p| horizon_protocol::text::literal(p)) + .collect() + }, resolved: true, }, ), diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index 7395cc0a4..12967d778 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -43,6 +43,7 @@ pub mod game_event { pub const RAIN_LEVEL: u8 = 7; pub const THUNDER_LEVEL: u8 = 8; pub const GUARDIAN_ELDER_EFFECT: u8 = 10; + pub const IMMEDIATE_RESPAWN: u8 = 11; pub const LEVEL_CHUNKS_LOAD_START: u8 = 13; } @@ -172,6 +173,8 @@ pub struct Hub { /// The `player_movement_check` and `elytra_movement_check` game rules, /// set by the game before each tick. pub movement_checks: (bool, bool), + /// The `immediate_respawn` game rule, as the players were last told. + immediate_respawn: bool, /// An integrated server's owner (`MinecraftServer.isSingleplayerOwner`), /// whose moves are never checked. pub singleplayer_owner: Option, @@ -352,6 +355,7 @@ impl Hub { guests: Vec::new(), sync, ticks: 0, + immediate_respawn: false, movement_checks: (true, true), singleplayer_owner: None, riding: Default::default(), @@ -429,6 +433,17 @@ impl Hub { g.sender.send(body.clone()); } } + /// MinecraftServer.onGameRuleChanged: every player is told when + /// `immediate_respawn` changes; a joining player's Login carries it. + pub fn set_immediate_respawn(&mut self, on: bool) { + if self.immediate_respawn != on { + self.immediate_respawn = on; + self.broadcast(&C::GameEvent(play::GameEvent { + event: game_event::IMMEDIATE_RESPAWN, + param: if on { 1.0 } else { 0.0 }, + })); + } + } /// PlayerList.setViewDistance: every player is told the new radius, /// and each one's chunks follow it, up to what they asked for /// (ChunkMap.getPlayerViewDistance). @@ -663,7 +678,7 @@ impl Hub { chunk_radius: self.config.view_distance, simulation_distance: self.config.simulation_distance, reduced_debug_info: false, - show_death_screen: true, + show_death_screen: !self.immediate_respawn, limited_crafting: false, spawn: self.spawn_info(mode), // MinecraftServer.usesAuthentication, enforceSecureProfile. diff --git a/crates/horizon-client/src/menu.rs b/crates/horizon-client/src/menu.rs index da24eb176..1aeeec1e1 100644 --- a/crates/horizon-client/src/menu.rs +++ b/crates/horizon-client/src/menu.rs @@ -288,6 +288,9 @@ pub struct Menu { pub player_sounds: Vec<&'static str>, /// Recipes whose result was taken (`awardUsedRecipes`), for the caller. pub crafted: Vec, + /// Potions taken from a brewing stand's bottle slots + /// (`PotionSlot.onTake`), for the caller. + pub brewed: Vec, /// `LivingEntity.onEquipItem` calls that change the item: the /// `EquipmentSlot` name and the new stack, in order, for the caller. pub equipped: Vec<(&'static str, Option)>, @@ -683,6 +686,7 @@ impl Menu { sounds: Vec::new(), player_sounds: Vec::new(), crafted: Vec::new(), + brewed: Vec::new(), equipped: Vec::new(), merchant: None, stone: Stonecutter::default(), @@ -1504,7 +1508,17 @@ impl Menu { } /// `ResultSlot.onTake` and the other `Slot.onTake` overrides. - fn on_take(&mut self, env: &Env, s: usize) { + fn on_take(&mut self, env: &Env, s: usize, taken: &ItemStack) { + if self.slots[s].role == Role::Potion { + // BrewingStandMenu.PotionSlot.onTake: a stack with potion contents. + if matches!( + &*taken.item, + "minecraft:potion" | "minecraft:splash_potion" | "minecraft:lingering_potion" + ) { + self.brewed.push(taken.clone()); + } + return; + } if self.slots[s].role == Role::MerchantResult { self.merchant_take(env); return; @@ -1671,7 +1685,7 @@ impl Menu { max_amount: u32, ) -> Option { let mut result = self.try_remove(env, s, amount, max_amount)?; - self.on_take(env, s); + self.on_take(env, s, &result); if self.slots[s].role == Role::CartoResult { Self::map_crafted(env, &mut result); } @@ -2346,7 +2360,7 @@ impl Menu { return None; } if after_take || matches!(self.kind, Kind::Inventory | Kind::Crafting) { - self.on_take(env, index); + self.on_take(env, index, &clicked); } // What the result slot's move left over is dropped. if (index == 0 && matches!(self.kind, Kind::Inventory | Kind::Crafting)) @@ -2594,7 +2608,7 @@ impl Menu { }; if let Some(mut taken) = self.try_remove(env, s, amount, u32::MAX) { self.carried = Some(taken.clone()); - self.on_take(env, s); + self.on_take(env, s, &taken); if self.slots[s].role == Role::CartoResult { // onTake's onCraftedBy edits the carried stack. Self::map_crafted(env, &mut taken); @@ -2628,7 +2642,7 @@ impl Menu { if let Some(c) = self.carried.as_mut() { c.count += taken.count; } - self.on_take(env, s); + self.on_take(env, s, &taken); if self.slots[s].role == Role::CartoResult { // onCraftedBy edits the taken stack, not the carried one. Self::map_crafted(env, &mut taken); @@ -2656,7 +2670,7 @@ impl Menu { if self.may_pickup(env, target) { self.containers[PLAYER][inv_slot] = Some(taken.clone()); self.set_by_player(env, target, None); - self.on_take(env, target); + self.on_take(env, target, &taken); if self.slots[target].role == Role::CartoResult && let Some(stack) = self.containers[PLAYER][inv_slot].as_mut() { @@ -2684,14 +2698,14 @@ impl Menu { let part = split(&mut source, max); self.containers[PLAYER][inv_slot] = Some(source); self.set_by_player(env, target, Some(part)); - self.on_take(env, target); + self.on_take(env, target, &taken); if !self.inventory_add(env, &mut taken) { self.drop_stack(&taken); } } else { - self.containers[PLAYER][inv_slot] = Some(taken); + self.containers[PLAYER][inv_slot] = Some(taken.clone()); self.set_by_player(env, target, Some(source)); - self.on_take(env, target); + self.on_take(env, target, &taken); } } } diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index 48d2f08bd..7594e7e31 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -38,6 +38,8 @@ pub struct Vertex { pub light: u32, /// RGBA8_SNORM face normal; w = -127 for two-sided lighting, 0 to keep baked/unlit colour. pub normal: [i8; 4], + /// The `GLINT_TEXTURING` atlas UV for a foil item quad; zero elsewhere. + pub glint_uv: [f32; 2], } /// A section vertex: vanilla's `DefaultVertexFormat.BLOCK` (position, colour, /// UV0, UV2) with the sprite's array layer beside the light, in 24 bytes diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 3118706d4..f4ab3f834 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -66,6 +66,7 @@ pub mod spawning; pub mod species; pub mod strider; pub mod sulfur_cube; +pub mod sync; pub mod tame; pub mod trader; pub mod transport_items; @@ -802,6 +803,8 @@ pub struct Extra { pub memories: Vec<(&'static str, i64, i64)>, /// A camel's `LAST_POSE_CHANGE_TICK`. pub pose_change_tick: i64, + /// `Entity.DATA_POSE` as a mob of a server has it (`sync::pose_id`). + pub pose: u8, /// The school leader a fish follows, and a tropical fish that swims alone. pub leader: Option, pub lone: bool, @@ -920,6 +923,12 @@ pub enum MobEvent { mob: u32, at: [f64; 3], }, + /// `Level.broadcastEntityEvent` for a mob: guests run `sync::entity_event`. + EntityEvent { + mob: u32, + event: i8, + at: [f64; 3], + }, 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). @@ -943,6 +952,10 @@ pub enum MobEvent { slot: usize, stack: Option, }, + /// `InfestedMobEffect.onMobHurt`: the mob was hurt while infested. + Infested { + mob: u32, + }, /// `OfferFlowerGoal.stop`: the item goes to the target's antenna (saddle) /// slot if it is empty, as a guaranteed drop. Gift { @@ -1026,7 +1039,9 @@ pub enum MobEvent { mob: u32, charged: bool, }, - Explode([f64; 3], f32), + /// The centre, the radius and the kind of the mob blowing up (it may be + /// gone from the list by the time the blast is handled). + Explode([f64; 3], f32, Species), /// Melee or ranged damage to another mob. AttackMob { target: u32, @@ -1090,8 +1105,11 @@ pub enum MobEvent { at: [f64; 3], count: u32, }, - /// Client particles about a mob's box (`particles::around_self`). + /// Client particles about a mob's box (`particles::around_self`) and the + /// entity event `event` that shows them, sent for mob `mob`. AroundSelf { + mob: u32, + event: i8, kind: &'static str, feet: [f64; 3], width: f64, @@ -1219,6 +1237,12 @@ pub enum MobEvent { table: &'static str, at: [f64; 3], }, + /// `Armadillo.customServerAiStep`: the armadillo sheds a scute. + ShedScute { + mob: u32, + at: [f64; 3], + pitch: f32, + }, /// A lead snaps or loses its holder: the lead item drops when asked. LeashBreak { mob: u32, @@ -1575,6 +1599,8 @@ pub struct PlayerView { pub off_hand: Option>, pub head: Option>, pub armor_cover: f32, + /// The Invisibility effect (`isInvisible`). + pub invisible: bool, pub spectator: bool, /// `PiglinAi.isWearingSafeArmor`: some golden armour. pub gold_armor: bool, @@ -1600,6 +1626,17 @@ pub struct PlayerView { pub passenger: bool, } impl PlayerView { + /// `LivingEntity.getVisibilityPercent` without the worn-skull scaling. + pub fn visibility_percent(&self) -> f64 { + let mut visibility = 1.0; + if self.sneaking { + visibility *= 0.8; + } + if self.invisible { + visibility *= 0.7 * f64::from(self.armor_cover).max(0.1); + } + visibility + } /// `LivingEntity.hasEffect`, by id without namespace. pub fn has_effect(&self, effect: &str) -> bool { self.effects.contains(&effect) @@ -1634,6 +1671,8 @@ pub struct MobWorld<'a> { pub biomes: &'a crate::biome::Biomes, /// The `mob_griefing` game rule. pub mob_griefing: bool, + /// The `mob_drops` game rule (`shouldDropLoot`). + pub mob_drops: bool, /// `getCurrentDifficultyAt` near the player. pub difficulty: spawning::LocalDifficulty, /// The End (its dimension type's monster spawn light rules). @@ -1647,6 +1686,8 @@ pub struct MobWorld<'a> { pub teams: std::sync::Arc>, /// Item data (max stack sizes), when the host has it. pub items: Option<&'a crate::items::Items>, + /// `ChestBlockEntity.getOpenCount`: the players with each chest open. + pub lid_openers: &'a HashMap<(i32, i32, i32), i32>, } /// `Entity.getTeam` of the player and of the mobs on a team. #[derive(Clone, Debug, Default)] @@ -1942,6 +1983,9 @@ impl Mob { } } } + if self.has_effect("minecraft:infested") { + self.outbox.push(MobEvent::Infested { mob: self.id }); + } // Squid.hurtServer: a squid hurt after a living entity hit it squirts ink. if matches!(self.species(), Species::Squid | Species::GlowSquid) && self.ai.last_hurt_by.is_some() @@ -2019,14 +2063,14 @@ impl Mob { } pub fn add_effect(&mut self, effect: &'static str, ticks: i32, amplifier: i32) { if let Some(e) = self.extra.effects.iter_mut().find(|e| e.0 == effect) { - // MobEffectInstance.update: a stronger effect replaces the old one - // with its own duration, an equal one keeps the longer duration, - // and a weaker one never changes the active effect. + // MobEffectInstance.update: a stronger effect replaces with its + // own duration, an equal one only extends it; a weaker one is + // ignored (vanilla keeps it hidden behind the active one). if amplifier > e.2 { e.1 = ticks; e.2 = amplifier; - } else if amplifier == e.2 { - e.1 = e.1.max(ticks); + } else if amplifier == e.2 && e.1 != -1 && (ticks == -1 || e.1 < ticks) { + e.1 = ticks; } } else { self.extra.effects.push((effect, ticks, amplifier)); @@ -2180,6 +2224,7 @@ pub fn render_model( layer: overlay, color: 0xFFFF_FFFF, light, + glint_uv: [0.0, 0.0], }); } } @@ -2314,7 +2359,7 @@ mod lighting_tests { #[test] fn packed_normal_uses_native_snorm_bytes_without_changing_vertex_offsets() { assert_eq!(std::mem::offset_of!(Vertex, normal), 32); - assert_eq!(std::mem::size_of::(), 36); + assert_eq!(std::mem::size_of::(), 44); let part = plane([0.0, 1.0, 0.0]); assert_eq!( part.polygons[0].vertex_normal(ModelNormals::new(Mat4::from_scale(Vec3::ZERO))), diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index 3d4b84f3e..ad130ea68 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -353,6 +353,10 @@ fn generic(m: &mut Mob) { g.add(5, Stroll::avoiding_water(if rabbit { 0.6 } else { 1.0 })); g.add(6, LookAtPlayer::new(6.0)); g.add(7, RandomLookAround::default()); + if m.kind.species == Species::Armadillo { + // Armadillo's constructor: pickNextScuteDropTime. + m.extra.egg_time = next_scute_time(m); + } } } /// Subclasses of `net.minecraft.world.entity.monster.Monster`. @@ -1080,9 +1084,31 @@ fn server_ai_step( } m.jump_control_tick(); } +/// `Armadillo.pickNextScuteDropTime`: 5 to 10 minutes. +fn next_scute_time(m: &mut Mob) -> i32 { + m.random.next_int_bound(20 * 60 * 5).unwrap_or(0) + 20 * 60 * 5 +} +/// `Armadillo.customServerAiStep`: the scute timer keeps counting down and is +/// only reset once `shouldDropLoot` (not a baby, `mob_drops` on) lets it shed. +fn armadillo_server_ai_step(m: &mut Mob, mob_drops: bool, events: &mut Vec) { + if !m.alive() { + return; + } + m.extra.egg_time -= 1; + if m.extra.egg_time <= 0 && !m.is_baby() && mob_drops { + let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0; + events.push(MobEvent::ShedScute { + mob: m.id, + at: [m.position.x, m.position.y, m.position.z], + pitch, + }); + m.extra.egg_time = next_scute_time(m); + } +} fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { match m.species() { Species::Rabbit => super::rabbit::server_ai_step(m), + Species::Armadillo => armadillo_server_ai_step(m, cx.w.mob_drops, cx.events), Species::Sheep => {} Species::Zombie | Species::Husk @@ -1175,6 +1201,19 @@ pub fn despawn_check(m: &mut Mob, w: &MobWorld) -> bool { } true } +/// `Mob.requiresCustomPersistence` and its overrides: a passenger or a leashed +/// mob, a raider in a raid, an enderman carrying a block, a tame nautilus, a +/// sulfur cube holding a block or let out of a bucket. The spawn caps do not +/// count these mobs either (`NaturalSpawner.createState`). +pub fn requires_custom_persistence(m: &Mob) -> bool { + super::riders::keeps_alive(m) + || m.extra.leash.is_some() + || super::raider::state(m).is_some_and(|s| s.raid_id.is_some()) + || m.species() == Species::Enderman && m.extra.carried.is_some() + || super::nautilus::is_nautilus(m.species()) && m.extra.tame + || m.species() == Species::SulfurCube + && (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0) +} /// Mob.checkDespawn, before the tick (players are the only despawn /// reference). Returns false when the mob is discarded. fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool { @@ -1190,12 +1229,7 @@ fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool { return true; }; let d = m.distance_sqr(p); - // requiresCustomPersistence: raiders in a raid, a tame nautilus, a sulfur - // cube holding a block or let out of a bucket. - let persistent = m.persistent - || super::nautilus::is_nautilus(m.species()) && m.extra.tame - || m.species() == Species::SulfurCube - && (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0); + let persistent = m.persistent || requires_custom_persistence(m); // removeWhenFarAway: animals, villagers, golems, patrols and raiders, // zombie villagers being cured and ridden mobs stay. let creature = m.kind.category == "creature"; @@ -1682,25 +1716,31 @@ fn tick_effects(m: &mut Mob) { let mut effects = std::mem::take(&mut m.extra.effects); for (effect, ticks, amp) in &mut effects { let interval = |base: i32| (base >> (*amp).max(0)).max(1); + // MobEffectInstance.tickServer: an infinite (-1) effect times its + // ticks by the mob's tickCount and never counts down. + let infinite = *ticks == -1; + let count = if infinite { m.age as i32 } else { *ticks }; match *effect { "minecraft:poison" - if *ticks % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 => + if count % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 => { m.damage(1.0, Damage::of(DamageKind::Magic)); } - "minecraft:wither" if *ticks % interval(40) == 0 => { + "minecraft:wither" if count % interval(40) == 0 => { m.damage(1.0, Damage::of(DamageKind::Magic)); } "minecraft:regeneration" - if *ticks % interval(50) == 0 && !m.kind.flags.undead && m.alive() => + if count % interval(50) == 0 && !m.kind.flags.undead && m.alive() => { m.health = (m.health + 1.0).min(m.attrs.max_health); } _ => {} } - *ticks -= 1; + if !infinite { + *ticks -= 1; + } } - effects.retain(|e| e.1 > 0); + effects.retain(|e| e.1 > 0 || e.1 == -1); m.extra .hidden_effects .retain(|h| effects.iter().any(|e| e.0 == *h)); diff --git a/crates/horizon-client/src/mobs/animal_brain.rs b/crates/horizon-client/src/mobs/animal_brain.rs index bd0eb9c90..d928c34ee 100644 --- a/crates/horizon-client/src/mobs/animal_brain.rs +++ b/crates/horizon-client/src/mobs/animal_brain.rs @@ -625,8 +625,7 @@ fn targetable(m: &mut Mob, w: &MobWorld, who: Who) -> bool { // TargetingConditions.forNonCombat(): in range (scaled by the // player's visibility, at least 2) and in sight. let Some(p) = &w.player else { return false }; - let visibility = if p.sneaking { 0.8 } else { 1.0 }; - let r = (range * visibility).max(2.0); + let r = (range * p.visibility_percent()).max(2.0); p.alive && !p.spectator && m.distance_sqr(p.position) <= r * r && m.sees(w, who) } Who::Mob(id) => { diff --git a/crates/horizon-client/src/mobs/breeze.rs b/crates/horizon-client/src/mobs/breeze.rs index 5d78fa8ab..dee48f3d0 100644 --- a/crates/horizon-client/src/mobs/breeze.rs +++ b/crates/horizon-client/src/mobs/breeze.rs @@ -31,6 +31,28 @@ pub fn pose(m: &Mob) -> u8 { pub(super) fn set_pose(m: &mut Mob, pose: u8) { m.extra.variant3 = pose; } +/// `Pose.id` of the pose (`sync::pose_id`), and its inverse. +pub fn pose_id(m: &Mob) -> u8 { + match pose(m) { + SHOOTING => 16, + INHALING => 17, + LONG_JUMPING => 6, + SLIDING => 15, + _ => 0, + } +} +pub(super) fn set_pose_id(m: &mut Mob, id: u8) { + set_pose( + m, + match id { + 16 => SHOOTING, + 17 => INHALING, + 6 => LONG_JUMPING, + 15 => SLIDING, + _ => STANDING, + }, + ); +} /// `Breeze.getFiringYPosition`. pub fn firing_y(m: &Mob) -> f64 { m.position.y + f64::from(m.height()) / 2.0 + f64::from(0.3_f32) diff --git a/crates/horizon-client/src/mobs/camel.rs b/crates/horizon-client/src/mobs/camel.rs index 703c8fa8f..427b4c5ca 100644 --- a/crates/horizon-client/src/mobs/camel.rs +++ b/crates/horizon-client/src/mobs/camel.rs @@ -46,6 +46,25 @@ pub fn sitting(m: &Mob) -> bool { fn in_transition(m: &Mob) -> bool { pose_time(m) < if sitting(m) { SIT_DOWN } else { STAND_UP } } +/// `Camel.getPoseTime` of a client mob from the `LAST_POSE_CHANGE_TICK` it +/// was sent and the client's game time, and whether that value says it sits. +fn client_pose(m: &Mob, game_time: i64) -> (i64, bool) { + let tick = m.extra.pose_change_tick; + (game_time - tick.abs(), tick < 0) +} +/// The camel's `LAST_POSE_CHANGE_TICK` as the server sends it: in game time +/// (a mob counts its own age), negative while sitting. +pub fn synced_pose_tick(m: &Mob, game_time: i64) -> i64 { + let tick = (game_time - pose_time(m)).max(0); + if sitting(m) { -tick.max(1) } else { tick } +} +/// `Entity.onSyncedDataUpdated` for the pose tick of a client mob: its sign +/// is whether it sits. `client_tick` keeps `egg_time` (in the mob's age, for +/// `sitting` and `refuse_to_move`) with it. +pub fn set_synced_pose_tick(m: &mut Mob, tick: i64) { + m.extra.pose_change_tick = tick; + m.extra.egg_time = if tick < 0 { -1 } else { 0 }; +} /// `Camel.refuseToMove`: sitting or getting up or down. pub fn refuse_to_move(m: &Mob) -> bool { sitting(m) || in_transition(m) @@ -167,7 +186,29 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec) { m.ai.zza = 0.0; m.ai.nav.stop(); } - // setupAnimationStates. + animation_states(m, pose_time(m), sitting(m)); +} +/// `Camel.tick` on a client that is not the server: the dash cooldown, which +/// the dash flag starts, and the keyframe states from the synced pose tick. +pub fn client_tick(m: &mut Mob, game_time: i64) { + if m.extra.anim_ticks > 0 { + m.extra.anim_ticks -= 1; + } + let (pose_time, sitting) = client_pose(m, game_time); + let since = (i64::from(m.age) - pose_time).max(0) as i32; + m.extra.egg_time = if sitting { -since.max(1) } else { since }; + animation_states(m, pose_time, sitting); +} +/// `Camel.onSyncedDataUpdated(DASH)`: a dash starts the cooldown unless it +/// runs. Not on the first tick. +pub fn set_dashing(m: &mut Mob, dashing: bool) { + if m.age > 0 && m.extra.anim_ticks == 0 { + m.extra.anim_ticks = DASH_COOLDOWN; + } + m.extra.flag2 = dashing; +} +/// `Camel.setupAnimationStates` for a pose time and whether it sits. +fn animation_states(m: &mut Mob, pose_time: i64, sitting: bool) { let age = m.age as f32; if m.extra.ints[0] <= 0 { m.extra.ints[0] = m.random.next_int_bound(40).unwrap_or(0) + 80; @@ -176,9 +217,9 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec) { m.extra.ints[0] -= 1; } // isCamelVisuallySitting: (poseTime < 0) != sitting. - let visually_sitting = (pose_time(m) < 0) != sitting(m); - let sitting_down = sitting(m) && pose_time(m) < SIT_DOWN && pose_time(m) >= 0; - let transition = in_transition(m) && pose_time(m) >= 0; + let visually_sitting = (pose_time < 0) != sitting; + let sitting_down = sitting && (0..SIT_DOWN).contains(&pose_time); + let transition = (0..if sitting { SIT_DOWN } else { STAND_UP }).contains(&pose_time); let dashing = m.extra.flag2; let st = &mut m.anim.states; if visually_sitting { diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs index bd17d7b5f..e6874ea0b 100644 --- a/crates/horizon-client/src/mobs/control.rs +++ b/crates/horizon-client/src/mobs/control.rs @@ -417,6 +417,13 @@ impl Mob { } /// BodyRotationControl.clientTick (Mob.tickHeadTurn). pub fn body_rotation_tick(&mut self) { + // Shulker.ShulkerBodyRotationControl.clientTick is empty: the body + // stays at 0 (recreateFromPacket), only the head turns. + if self.species() == super::Species::Shulker { + self.body_yaw = 0.0; + self.previous_body_yaw = 0.0; + return; + } let dx = self.position.x - self.previous.x; let dz = self.position.z - self.previous.z; let max = self.kind.max_head_y_rot; diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs index 3d9709ac4..6704246de 100644 --- a/crates/horizon-client/src/mobs/goals.rs +++ b/crates/horizon-client/src/mobs/goals.rs @@ -588,24 +588,38 @@ impl Mob { if p.creative || p.allies.contains(&self.id) { return false; } - self.player_in_range(w, range, check_sight) + self.player_in_range(w, range, check_sight, true) + } + /// forCombat().ignoreInvisibilityTesting() for the player: the check for + /// a target the mob already has, which ignores the visibility scaling. + pub fn can_keep_target_player(&mut self, w: &MobWorld, range: f64) -> bool { + let Some(p) = &w.player else { return false }; + if p.creative || p.allies.contains(&self.id) { + return false; + } + self.player_in_range(w, range, true, false) } /// TargetingConditions.forNonCombat().range(range).test for the player /// (seen by anyone, within range scaled by visibility, in sight). pub fn can_see_player(&mut self, w: &MobWorld, range: f64) -> bool { - self.player_in_range(w, range, true) + self.player_in_range(w, range, true, true) } - fn player_in_range(&mut self, w: &MobWorld, range: f64, check_sight: bool) -> bool { + /// `scale` is `TargetingConditions.testInvisible`: scale the range by + /// the player's visibility. + fn player_in_range( + &mut self, + w: &MobWorld, + range: f64, + check_sight: bool, + scale: bool, + ) -> bool { let Some(p) = &w.player else { return false }; if !p.alive || p.spectator { return false; } // LivingEntity.getVisibilityPercent - let mut visibility = 1.0; - if p.sneaking { - visibility *= 0.8; - } - if let Some(head) = &p.head { + let mut visibility = if scale { p.visibility_percent() } else { 1.0 }; + if let Some(head) = p.head.as_ref().filter(|_| scale) { let skull = match self.species() { Species::Zombie | Species::Husk | Species::Drowned | Species::ZombieVillager => { "minecraft:zombie_head" diff --git a/crates/horizon-client/src/mobs/guardian.rs b/crates/horizon-client/src/mobs/guardian.rs index 880655361..b630aeadd 100644 --- a/crates/horizon-client/src/mobs/guardian.rs +++ b/crates/horizon-client/src/mobs/guardian.rs @@ -399,6 +399,8 @@ pub fn beam_geometry( layer: 0, color, light: 240 | 240 << 8, + + glint_uv: [0.0, 0.0], }); }; // Sides: one quad per texture repeat. diff --git a/crates/horizon-client/src/mobs/happy_ghast.rs b/crates/horizon-client/src/mobs/happy_ghast.rs index 296644acc..418556750 100644 --- a/crates/horizon-client/src/mobs/happy_ghast.rs +++ b/crates/horizon-client/src/mobs/happy_ghast.rs @@ -364,8 +364,7 @@ impl Goal for GhastTempt { let Some(p) = &cx.w.player else { return false }; // getNearestPlayer(TargetingConditions.forNonCombat() // .ignoreLineOfSight().range(TEMPT_RANGE 16)): creative players too. - let visibility = if p.sneaking { 0.8 } else { 1.0 }; - let range = (16.0_f64 * visibility).max(2.0); + let range = (16.0_f64 * p.visibility_percent()).max(2.0); p.alive && !p.spectator && (Self::wants(m, &p.main_hand) || Self::wants(m, &p.off_hand)) diff --git a/crates/horizon-client/src/mobs/hostile.rs b/crates/horizon-client/src/mobs/hostile.rs index f1c990c48..34dc256f9 100644 --- a/crates/horizon-client/src/mobs/hostile.rs +++ b/crates/horizon-client/src/mobs/hostile.rs @@ -184,6 +184,7 @@ pub fn creeper_tick(m: &mut Mob, events: &mut Vec) { events.push(MobEvent::Explode( [m.position.x, m.position.y, m.position.z], radius, + m.species(), )); m.removed = true; } diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs index 3bda32eb3..10388d0c0 100644 --- a/crates/horizon-client/src/mobs/living.rs +++ b/crates/horizon-client/src/mobs/living.rs @@ -563,6 +563,17 @@ impl Mob { // Entity.checkSupportingBlock self.supporting = self.supporting_block(w, moved); self.movement_emission(w, moved, events); + // Entity.applyEffectsFromBlocks: bubble columns push the mob. + if crate::motion::bubble_column_push( + w.world, + w.registry, + w.facts, + w.collision, + self.bounds(), + &mut self.velocity, + ) { + self.fall_distance = 0.0; + } } /// LivingEntity.checkFallDamage: the fluid state refreshed out of water /// (touching water resets the fall), then Entity.checkFallDamage. @@ -575,11 +586,36 @@ impl Mob { } if self.on_ground { if self.fall_distance > 0.0 { + self.trample_farmland(w, events); self.cause_fall_damage(events); } self.fall_distance = 0.0; } } + /// `FarmlandBlock.fallOn`: a landing on farmland turns it to dirt with + /// chance `fallDistance - 0.5`, if mobs may grief and the mob's + /// `width * width * height` is over 0.512. `Block.pushEntitiesUp` lifts + /// the mob onto the dirt, which is a full block. + fn trample_farmland(&mut self, w: &MobWorld, events: &mut Vec) { + let p = self.block_on_legacy(w); + if w.block_name(p[0], p[1], p[2]) != "minecraft:farmland" { + return; + } + let roll = f64::from(self.random.next_float()); + let Some(dirt) = w.registry.default_state("minecraft:dirt") else { + return; + }; + if roll < self.fall_distance - 0.5 + && w.mob_griefing + && self.width() * self.width() * self.height() > 0.512 + { + events.push(MobEvent::SetBlock { + pos: p, + state: dirt, + }); + self.position.y = self.position.y.max(f64::from(p[1]) + 1.0); + } + } /// Entity.updateFluidInteraction: the fluid state, then touching water /// resets the fall and entering it (after the first tick) splashes. pub(super) fn update_fluids(&mut self, w: &MobWorld, events: &mut Vec) { diff --git a/crates/horizon-client/src/mobs/monster_brain.rs b/crates/horizon-client/src/mobs/monster_brain.rs index 827360406..8be270ec1 100644 --- a/crates/horizon-client/src/mobs/monster_brain.rs +++ b/crates/horizon-client/src/mobs/monster_brain.rs @@ -359,11 +359,14 @@ fn can_attack(m: &Mob, w: &MobWorld, who: Who) -> bool { /// `Sensor.isEntityAttackable`: `TargetingConditions.forCombat()` within the /// follow range, in sight. fn attackable(m: &mut Mob, w: &MobWorld, who: Who) -> bool { + // The current ATTACK_TARGET is tested with ignoreInvisibilityTesting. + let current = mem_ref(m).attack_target.value() == Some(who); let range = m.attrs.follow_range; if !can_attack(m, w, who) { return false; } match who { + Who::Player if current => m.can_keep_target_player(w, range), Who::Player => m.can_target_player(w, range, true), Who::Mob(id) => { let Some(s) = w.seen(id) else { return false }; diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs index d2ed62374..9b1d17eed 100644 --- a/crates/horizon-client/src/mobs/raider.rs +++ b/crates/horizon-client/src/mobs/raider.rs @@ -41,6 +41,11 @@ pub struct State { pub in_village: bool, /// A dropped ominous banner this raider may fetch. pub banner_at: Option<[f64; 3]>, + /// The item entity of `banner_at`. + pub banner_item: u32, + /// Banners with no path to them, and until when (game time): + /// `unreachableBannerCache`. + pub unreachable_banners: Vec<(u32, i64)>, /// Beds around the raid's centre. pub homes: Option>>, /// A ravager carrying a raider, set every tick from `Extra::rider`. @@ -116,7 +121,7 @@ pub fn register(m: &mut Mob) { } m.extra.raider = Some(Box::default()); m.ai.goals.add(4, LongDistancePatrol::new(0.7, 0.595)); - m.ai.goals.add(1, ObtainBanner); + m.ai.goals.add(1, ObtainBanner::default()); m.ai.goals.add(3, PathfindToRaid); m.ai.goals.add(4, MoveThroughVillage::new(1.05, 1.0)); m.ai.goals.add(5, Celebration); @@ -339,23 +344,37 @@ fn close_to_center(p: [i32; 3], at: Vec3, distance: f64) -> bool { /// `Raider.ObtainRaidLeaderBannerGoal`: walk to a fallen ominous banner when /// the wave has no living leader (the game finds the banner and picks it up). -#[derive(Clone, Debug)] -pub struct ObtainBanner; +#[derive(Clone, Debug, Default)] +pub struct ObtainBanner { + path_to_banner: Option, +} impl Goal for ObtainBanner { goal_clone!(); fn flags(&self) -> u8 { MOVE } - fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { - state(m).is_some_and(|s| s.banner_at.is_some()) + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let Some((at, item)) = state(m).and_then(|s| s.banner_at.map(|at| (at, s.banner_item))) + else { + return false; + }; + // A banner with no path to it is skipped for 600 ticks. + let path = m.create_path_to_entity(cx.w, at, 1); + if path.as_ref().is_some_and(|p| p.reached) { + self.path_to_banner = path; + return true; + } + let now = cx.w.game_time; + let s = state_mut(m); + s.unreachable_banners.retain(|&(_, until)| now < until); + s.unreachable_banners.push((item, now + 600)); + false } fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { !m.ai.nav.is_done() && state(m).is_some_and(|s| s.banner_at.is_some()) } - fn start(&mut self, m: &mut Mob, cx: &mut Cx) { - if let Some(at) = state(m).and_then(|s| s.banner_at) { - m.nav_move_to(cx.w, at, 1.15); - } + fn start(&mut self, m: &mut Mob, _cx: &mut Cx) { + m.nav_move_to_path(self.path_to_banner.take(), 1.15); } } diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 46eb14cc1..bbed917a4 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -14,6 +14,12 @@ use std::f32::consts::PI; /// A texture lookup into the shared atlas (name without namespace -> uv rect). pub type Atlas<'a> = &'a dyn Fn(&str) -> Option<[f32; 4]>; +/// The overlay code of an enchanted armour layer's glint. 7 and 8 are the +/// item glint and 9 to 12 Horizon's End-portal and breaking overlays, so 13 +/// marks the `ARMOR_ENTITY_GLINT_TEXTURING` sample: entity.wgsl transforms +/// the model UV and reads `enchanted_glint_armor`. +pub const ARMOR_GLINT: u32 = 13; + /// One draw of a model with a texture. pub struct Layer { pub model: String, @@ -664,14 +670,6 @@ pub fn layers(m: &Mob) -> Vec { white, false, ), - // EnergySwirlLayer (the scroll is not reproduced: atlas sprites do not wrap). - S::Creeper if m.extra.charged => push( - &mut v, - "creeper#armor", - "entity/creeper/creeper_armor", - 0x80FF_FFFF, - true, - ), S::TropicalFish => { // TropicalFishPatternLayer: the pattern tinted with the pattern colour. let (model, letter, n) = if m.extra.variant < 6 { @@ -1033,6 +1031,13 @@ fn draw_normals( let normal = poly.vertex_normal(normals); for v in poly.vertices { let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0); + // The armour glint scrolls the layer's model UV in the shader; + // the item path already passed its transformed UV. + let glint_uv = if overlay == ARMOR_GLINT { + [v[3], v[4]] + } else { + [0.0, 0.0] + }; out.push(Vertex { normal, pos: pos.to_array(), @@ -1043,6 +1048,7 @@ fn draw_normals( layer: overlay, color, light, + glint_uv, }); } } @@ -1203,9 +1209,9 @@ fn render_visible( light }; // EquipmentLayerRenderer draws armour with OverlayTexture.NO_OVERLAY: never - // the hurt tint, the glint (7) when enchanted. + // the hurt tint, the armour glint (13) when enchanted. let overlay = match armor_slot(&layer.model) { - Some(slot) if super::gear::enchanted(m, slot) => 7, + Some(slot) if super::gear::enchanted(m, slot) => ARMOR_GLINT, Some(_) => 0, None => overlay, }; @@ -1226,10 +1232,50 @@ fn render_visible( } } } + // EnergySwirlLayer: the armour model, additive, scrolling over the sprite. + if let Some((model, texture, x_offset)) = energy_swirl(m, s.age) + && let Some(part) = m.kind.layer(model) + && let Some([u0, v0, u1, v1]) = atlas(texture) + { + layer_poses.reset(part); + anim::setup(m, &s, &mut layer_poses, &data.animations); + // `RenderTypes.energySwirl`'s texture offset, as the sprite-local UV. + let (du, dv) = (x_offset % 1.0, s.age * 0.01 % 1.0); + let start = out.len(); + draw( + part, + base, + &layer_poses, + [du, dv, 1.0 + du, 1.0 + dv], + crate::breaking::stage_light([u1 - u0, v1 - v0]), + crate::breaking::stage_light([u0, v0]), + crate::gfx::ENERGY_SWIRL_OVERLAY, + out, + ); + // No lighting: the colour bytes carry the sprite's size (fs_energy_swirl). + for vertex in &mut out[start..] { + vertex.normal = [0; 4]; + } + } if shell_last { draw_body(out); } } +/// `EnergySwirlLayer`'s model, texture and `xOffset(t)` for a charged creeper +/// (`CreeperPowerLayer`) or a powered wither (`WitherArmorLayer`); `t` is `ageInTicks`. +fn energy_swirl(m: &Mob, t: f32) -> Option<(&'static str, &'static str, f32)> { + match m.species() { + Species::Creeper if m.extra.charged => { + Some(("creeper#armor", "entity/creeper/creeper_armor", t * 0.01)) + } + Species::Wither if super::wither::powered(m) => Some(( + "wither#armor", + "entity/wither/wither_armor", + (t * 0.02).mcos() * 3.0, + )), + _ => None, + } +} /// The equipment slot of a `HumanoidArmorLayer` model (`zombie#helmet`). fn armor_slot(model: &str) -> Option { Some(match model.rsplit('#').next()? { diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs index 32f952e15..c510409d9 100644 --- a/crates/horizon-client/src/mobs/shulker.rs +++ b/crates/horizon-client/src/mobs/shulker.rs @@ -325,6 +325,13 @@ pub fn look_yaw(m: &Mob, at: [f64; 3]) -> Option { f64::from(delta_forward), )) } +/// `Shulker.tick` on a client that is not the server: the lid eases to the +/// peek it was sent, and its body stays square (`ShulkerBodyRotationControl`). +pub fn client_tick(m: &mut Mob) { + m.anim.vo = m.anim.v; + ease_peek(m); + m.body_yaw = 0.0; +} /// `Shulker.hurtServer` before the damage: arrows bounce off a closed shell. pub fn accepts(m: &Mob, source: &Damage) -> bool { !(m.extra.counter == 0 && source.kind == DamageKind::Arrow) diff --git a/crates/horizon-client/src/mobs/sniffer.rs b/crates/horizon-client/src/mobs/sniffer.rs index c0c8d8155..72aa76cc2 100644 --- a/crates/horizon-client/src/mobs/sniffer.rs +++ b/crates/horizon-client/src/mobs/sniffer.rs @@ -74,23 +74,8 @@ pub fn head_block(m: &Mob) -> [i32; 3] { /// the dropped seed and the water malus. pub fn ai_step(m: &mut Mob, events: &mut Vec) { use super::path::PathType; - let age = m.age as f32; let current = state(m); - if current != m.extra.scratch[0] as u8 { - // resetAnimations, then the state's own. - for s in &mut m.anim.states[..5] { - s.stop(); - } - match current { - FEELING_HAPPY => m.anim.states[0].start_if_stopped(age), - SCENTING => m.anim.states[1].start_if_stopped(age), - SNIFFING => m.anim.states[2].start_if_stopped(age), - DIGGING => m.anim.states[3].start_if_stopped(age), - RISING => m.anim.states[4].start_if_stopped(age), - _ => {} - } - m.extra.scratch[0] = i32::from(current); - } + animate(m); if current == DIGGING && now(m) == m.extra.ints[3] { let h = head_block(m); events.push(MobEvent::GiftLoot { @@ -110,6 +95,27 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec) { let wet = m.fluids.in_water || m.fire_ticks > 0; m.set_malus(PathType::Water, if wet { 0.0 } else { -1.0 }); } +/// `Sniffer.onSyncedDataUpdated(DATA_STATE)`: the animation states of the +/// state it changed to (on a client, each tick for the state it has). +pub fn animate(m: &mut Mob) { + let age = m.age as f32; + let current = state(m); + if current != m.extra.scratch[0] as u8 { + // resetAnimations, then the state's own. + for s in &mut m.anim.states[..5] { + s.stop(); + } + match current { + FEELING_HAPPY => m.anim.states[0].start_if_stopped(age), + SCENTING => m.anim.states[1].start_if_stopped(age), + SNIFFING => m.anim.states[2].start_if_stopped(age), + DIGGING => m.anim.states[3].start_if_stopped(age), + RISING => m.anim.states[4].start_if_stopped(age), + _ => {} + } + m.extra.scratch[0] = i32::from(current); + } +} /// The brain memory holding the explored positions /// (`SNIFFER_EXPLORED_POSITIONS`). pub fn to_nbt(m: &Mob, map: &mut horizon_world::nbt::Compound) { diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs index e97134505..91c303467 100644 --- a/crates/horizon-client/src/mobs/sulfur_cube.rs +++ b/crates/horizon-client/src/mobs/sulfur_cube.rs @@ -371,6 +371,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { events.push(MobEvent::Explode( [m.position.x, m.position.y + 0.0625, m.position.z], power, + m.species(), )); m.removed = true; return; diff --git a/crates/horizon-client/src/mobs/sync.rs b/crates/horizon-client/src/mobs/sync.rs new file mode 100644 index 000000000..d1c5b6609 --- /dev/null +++ b/crates/horizon-client/src/mobs/sync.rs @@ -0,0 +1,85 @@ +//! A server's mobs as a client animates them. The server thread, a LAN host +//! and a dedicated server run each mob's animation state (`ai::tick`); a +//! client of a server only gets synched data and entity events, and runs the +//! animation steps vanilla runs on the client (`Entity.onSyncedDataUpdated`, +//! `handleEntityEvent` and the per tick animation states). The server's half +//! is `game/lan.rs` (`mob_meta`, with `pose_id` here for index 6) and +//! `MobEvent::EntityEvent`; the client's half is `game/remote_mob_data.rs`, +//! `game/remote.rs` (`C::EntityEvent`) and `client_tick` here. +//! +//! To animate another species for a client: +//! - send its synched data in `mob_meta` and read it in +//! `remote_mob_data::apply`; +//! - send its poses in `pose_id` and read them in `set_pose`; +//! - broadcast its entity events with `MobEvent::EntityEvent` and handle +//! them in `entity_event`; +//! - run its client side animation in `client_tick`, sharing the function +//! with the server's `ai_step` where the server computes the same. +use super::{Mob, Species, breeze, camel, shulker, sniffer, warden}; + +// `Pose.id` of the poses mobs take. +pub const STANDING: u8 = 0; +pub const LONG_JUMPING: u8 = 6; +pub const SITTING: u8 = 10; +pub const ROARING: u8 = 11; +pub const SNIFFING: u8 = 12; +pub const EMERGING: u8 = 13; +pub const DIGGING: u8 = 14; +pub const SLIDING: u8 = 15; +pub const SHOOTING: u8 = 16; +pub const INHALING: u8 = 17; + +/// `Entity.DATA_POSE` (index 6) of a mob of a server: the pose its species +/// keeps in its own fields. +pub fn pose_id(m: &Mob) -> u8 { + match m.species() { + Species::Warden => warden::pose_id(m), + Species::Breeze => breeze::pose_id(m), + Species::Camel | Species::CamelHusk if camel::sitting(m) => SITTING, + _ => STANDING, + } +} + +/// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client. +pub fn set_pose(m: &mut Mob, id: u8) { + m.extra.pose = id; + match m.species() { + Species::Warden => warden::set_pose_id(m, id), + Species::Breeze => breeze::set_pose_id(m, id), + _ => {} + } +} + +/// The per tick animation steps of a client's mobs (after `m.age` moved on), +/// for the species whose server runs them in `ai_step`. `game_time` is the +/// client level's. +pub fn client_tick(m: &mut Mob, game_time: i64) { + match m.species() { + Species::Warden => warden::client_tick(m), + Species::Sniffer => sniffer::animate(m), + Species::Breeze => breeze::ai_step(m), + Species::Camel | Species::CamelHusk => camel::client_tick(m, game_time), + Species::Shulker => shulker::client_tick(m), + _ => {} + } +} + +/// `handleEntityEvent` of the mob types that start animations by an event +/// (`ClientboundEntityEventPacket` for a mob of a client). +pub fn entity_event(m: &mut Mob, event: u8) { + let age = m.age as f32; + if m.species() == Species::Warden { + match event { + // Attack: the roar ends, the swing starts. + 4 => { + m.anim.states[warden::ROAR].stop(); + m.anim.states[warden::ATTACK].start(age); + } + // The tendrils twitch. + 61 => m.anim.v[warden::TENDRIL] = 10.0, + // The sonic boom. + 62 => m.anim.states[warden::SONIC_BOOM].start(age), + _ => {} + } + } +} diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index 0b2075c96..f38296d4b 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -2,7 +2,7 @@ //! sitting, following and defending the owner, begging, anger and shaking //! off water (`Wolf`, `WolfModel`). use super::{ - Damage, Mob, MobEvent, MobWorld, Species, Who, + Damage, Mob, MobEvent, MobWorld, PlayerView, Species, Who, anim::{Poses, State}, goals::{ Breed, Cx, Float, Goal, HurtByTarget, JUMP, LOOK, LeapAtTarget, LookAtPlayer, MOVE, @@ -124,17 +124,23 @@ pub fn set_tame(m: &mut Mob, tame: bool) { m.attrs.max_health = 8.0; } } -/// The owner (the local player) when tame. -fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> { +/// `TamableAnimal.getOwner`: the player the saved owner UUID names, when it +/// is the one this mob sees; anyone else nearby is not its owner. +fn owner_view<'a>(m: &Mob, w: &'a MobWorld) -> Option<&'a PlayerView> { if !m.extra.tame { return None; } let p = w.player.as_ref()?; + (m.extra.owner == Some(p.uuid)).then_some(p) +} +/// The owner's position, eye height and spectator flag when tame. +fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> { + let p = owner_view(m, w)?; Some((p.position, p.eye[1], p.spectator)) } /// `TamableAnimal.unableToMoveToOwner`. fn unable_to_move_to_owner(m: &Mob, w: &MobWorld) -> bool { - m.extra.sitting || w.player.as_ref().is_some_and(|p| p.spectator) + m.extra.sitting || owner_view(m, w).is_some_and(|p| p.spectator) } /// `TamableAnimal.tryToTeleportToOwner`: ten tries around the owner. fn teleport_to_owner(m: &mut Mob, w: &MobWorld) { @@ -240,7 +246,7 @@ impl Goal for SitWhenOrdered { match owner_distance_sqr(m, cx.w) { None => true, Some(d) => { - let attacked = cx.w.player.as_ref().is_some_and(|p| p.hurt_by.is_some()); + let attacked = owner_view(m, cx.w).is_some_and(|p| p.hurt_by.is_some()); !(d < 144.0 && attacked) && m.extra.sitting } } @@ -388,7 +394,7 @@ impl Goal for OwnerHurtBy { if !m.extra.tame || m.extra.sitting { return false; } - let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.hurt_by) else { + let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.hurt_by) else { return false; }; at != self.timestamp && wants_to_attack(m, cx.w, who) @@ -399,7 +405,7 @@ impl Goal for OwnerHurtBy { .is_some_and(|t| t.alive) } fn start(&mut self, m: &mut Mob, cx: &mut Cx) { - if let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.hurt_by) { + if let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.hurt_by) { m.ai.target = Some(who); self.timestamp = at; } @@ -422,7 +428,7 @@ impl Goal for OwnerHurt { if !m.extra.tame || m.extra.sitting { return false; } - let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.last_hurt) else { + let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.last_hurt) else { return false; }; at != self.timestamp && wants_to_attack(m, cx.w, who) @@ -433,7 +439,7 @@ impl Goal for OwnerHurt { .is_some_and(|t| t.alive) } fn start(&mut self, m: &mut Mob, cx: &mut Cx) { - if let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.last_hurt) { + if let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.last_hurt) { m.ai.target = Some(who); self.timestamp = at; } @@ -822,7 +828,7 @@ impl Goal for CatLieOnBlock { m.extra.flag = self.0.reached; } } -/// `CatSitOnBlockGoal`: chests, lit furnaces and beds. +/// `CatSitOnBlockGoal`: unopened chests, lit furnaces and the foot of beds. #[derive(Clone, Debug)] struct CatSitOnBlock(super::goals::MoveToBlock); fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool { @@ -833,7 +839,15 @@ fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool { match f.name.as_ref() { // The lit state is the only light source a furnace has. "minecraft:furnace" => f.emission > 0, - _ => true, + // `ChestBlockEntity.getOpenCount(level, pos) < 1`: players' openers + // and the copper golems' own count. + "minecraft:chest" => { + let key = (p[0], p[1], p[2]); + !w.lid_openers.contains_key(&key) + && w.world.chest_openers.get(&key).is_none_or(|o| o.0 < 1) + } + // A bed's foot only (`BedBlock.PART != HEAD`). + _ => w.prop(p[0], p[1], p[2], "part") != Some("head"), } } impl Goal for CatSitOnBlock { diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs index 2052eef4c..676d9b713 100644 --- a/crates/horizon-client/src/mobs/villager_brain.rs +++ b/crates/horizon-client/src/mobs/villager_brain.rs @@ -789,14 +789,7 @@ pub fn golem_detected(m: &mut Mob, now: i64) { // ---- Behaviours --------------------------------------------------------- -/// The POI types villagers use. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Poi { - /// A job site, by profession index. - Job(u8), - Home, - Meeting, -} +pub use crate::poi_sections::Poi; impl Poi { fn max_tickets(self) -> usize { match self { @@ -2918,11 +2911,18 @@ impl B { let mut bodies = Vec::new(); if let Some(t) = cx.w.target_info(target) { let (min, max) = (t.bounds.min_position(), t.bounds.max_position()); - bodies.push((t.position, max.x - min.x, max.y - min.y)); + bodies.push((partner, t.position, max.x - min.x, max.y - min.y)); } - bodies.push((m.position, f64::from(m.width()), f64::from(m.height()))); - for (feet, width, height) in bodies { + bodies.push(( + m.id, + m.position, + f64::from(m.width()), + f64::from(m.height()), + )); + for (mob, feet, width, height) in bodies { cx.events.push(MobEvent::AroundSelf { + mob, + event: 12, kind: "heart", feet: [feet.x, feet.y, feet.z], width, @@ -3605,6 +3605,8 @@ fn pois_scan_order(_m: &Mob, found: &[(Poi, [i32; 3])]) -> Vec { /// `AbstractVillager.addParticlesAroundSelf(HAPPY_VILLAGER)` on the client. fn happy_particles(m: &Mob, cx: &mut Bx) { cx.events.push(MobEvent::AroundSelf { + mob: m.id, + event: 14, kind: "happy_villager", feet: [m.position.x, m.position.y, m.position.z], width: f64::from(m.width()), diff --git a/crates/horizon-client/src/mobs/warden.rs b/crates/horizon-client/src/mobs/warden.rs index 11161ef7c..747443577 100644 --- a/crates/horizon-client/src/mobs/warden.rs +++ b/crates/horizon-client/src/mobs/warden.rs @@ -67,6 +67,29 @@ impl Pose { } } } +/// `Pose.id` of the poses a warden takes (`sync::pose_id`). +pub fn pose_id(m: &Mob) -> u8 { + match pose(m) { + Pose::Standing => 0, + Pose::Roaring => 11, + Pose::Sniffing => 12, + Pose::Emerging => 13, + Pose::Digging => 14, + } +} +/// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client. +pub(super) fn set_pose_id(m: &mut Mob, id: u8) { + set_pose( + m, + match id { + 11 => Pose::Roaring, + 12 => Pose::Sniffing, + 13 => Pose::Emerging, + 14 => Pose::Digging, + _ => Pose::Standing, + }, + ); +} /// The warden's pose (kept in `Extra.counter` so it can be read while the /// brain is being ticked). pub fn pose(m: &Mob) -> Pose { @@ -434,6 +457,11 @@ pub fn do_push(m: &mut Mob, w: &MobWorld, who: Who, events: &mut Vec) pub(super) fn do_hurt_target(m: &mut Mob, target: Who, w: &MobWorld, events: &mut Vec) { m.anim.states[ROAR].stop(); m.anim.states[ATTACK].start(m.age as f32); + events.push(MobEvent::EntityEvent { + mob: m.id, + event: 4, + at: at(m), + }); let pitch = voice_pitch(m); sound(m, "entity.warden.attack_impact", 10.0, pitch, events); warden_brain::mem(m).sonic_boom_cooldown.set_ttl((), 40); @@ -546,6 +574,11 @@ fn receive_vibration(m: &mut Mob, w: &MobWorld, info: Info, events: &mut Vec) { - let Some(st) = m.extra.warden.as_ref() else { - return; - }; - let client_anger = st.client_anger; - let delay = heart_beat_delay(client_anger); - if i64::from(m.age) % i64::from(delay) == 0 { - m.anim.v[HEART] = 10.0; + if heartbeat(m) { events.push(MobEvent::LevelEventSound { sound: "entity.warden.heartbeat", at: at(m), @@ -745,6 +772,30 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec) { spread: 0.2, }); } + animate(m, events); +} +/// The heart's beat on its clock, from the client's anger level: whether +/// this tick has one (its sound is the caller's). +fn heartbeat(m: &mut Mob) -> bool { + let Some(st) = m.extra.warden.as_ref() else { + return false; + }; + let delay = heart_beat_delay(st.client_anger); + let beat = i64::from(m.age) % i64::from(delay) == 0; + if beat { + m.anim.v[HEART] = 10.0; + } + beat +} +/// `Warden.tick` on a client that is not the server: the heart and tendril +/// animations and the keyframes that ended. Its sounds and particles come +/// from the server. +pub fn client_tick(m: &mut Mob) { + m.anim.vo = m.anim.v; + heartbeat(m); + animate(m, &mut Vec::new()); +} +fn animate(m: &mut Mob, events: &mut Vec) { // The animation values count down after the sync of the last tick. for slot in [TENDRIL, HEART] { if m.anim.v[slot] > 0.0 { diff --git a/crates/horizon-client/src/mobs/warden_brain.rs b/crates/horizon-client/src/mobs/warden_brain.rs index 8caafefc9..667bbedf0 100644 --- a/crates/horizon-client/src/mobs/warden_brain.rs +++ b/crates/horizon-client/src/mobs/warden_brain.rs @@ -937,6 +937,11 @@ impl B { mm.sonic_boom_sound_delay.set_ttl((), SONIC_SOUND_DELAY); // Entity event 62: the sonic boom keyframes start. m.anim.states[warden::SONIC_BOOM].start(m.age as f32); + cx.events.push(MobEvent::EntityEvent { + mob: m.id, + event: 62, + at: [m.position.x, m.position.y, m.position.z], + }); sound(m, "entity.warden.sonic_charge", 3.0, 1.0, cx.events); true } diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs index 6c3316ac7..2fdd16372 100644 --- a/crates/horizon-client/src/mobs/wither.rs +++ b/crates/horizon-client/src/mobs/wither.rs @@ -221,6 +221,7 @@ pub fn custom_server_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec, diff --git a/crates/horizon-client/src/motion/fluids.rs b/crates/horizon-client/src/motion/fluids.rs index 894e6d907..e3751f0c6 100644 --- a/crates/horizon-client/src/motion/fluids.rs +++ b/crates/horizon-client/src/motion/fluids.rs @@ -119,6 +119,67 @@ impl PlayerMotion { !self.fluids.first_tick && self.fluids.interaction.is_in_fluid(&FluidTags, LAVA) } } +/// `BubbleColumnBlock.entityInside` for an entity that is not the player (a mob, +/// a dropped item, an ender pearl): the bubble columns its box touches push it +/// up or drag it down, harder at the surface (`Entity.handleOnAboveBubbleColumn` +/// and `handleOnInsideBubbleColumn`). Returns whether it was inside a column +/// below the surface, which resets its fall distance. +pub fn bubble_column_push( + world: &World, + registry: &horizon_world::registry::BlockRegistry, + facts: &crate::blocks::BlockFacts, + collision: &horizon_world::block_collision::BlockCollisionRegistry<'_>, + bounds: Aabb, + velocity: &mut Vec3, +) -> bool { + let b = bounds.deflate(Vec3::new( + f64::from(1.0e-5f32), + f64::from(1.0e-5f32), + f64::from(1.0e-5f32), + )); + let (lo, hi) = (b.min_position(), b.max_position()); + let mut reset_fall = false; + for x in lo.x.floor() as i32..=(hi.x.ceil() as i32 - 1) { + for y in lo.y.floor() as i32..=(hi.y.ceil() as i32 - 1) { + for z in lo.z.floor() as i32..=(hi.z.ceil() as i32 - 1) { + let state = world.block(x, y, z); + if &*facts.get(state).name != "minecraft:bubble_column" { + continue; + } + let drag = registry + .state(state) + .and_then(|s| s.properties.get("drag")) + .is_some_and(|d| d == "true"); + let above = world.block(x, y + 1, z); + // stateAbove.getCollisionShape(level, pos): the shape is asked + // at the column's own position. + let mut scene = SceneCollisions { + world, + binding: collision, + subject: None, + }; + let context = horizon_world::collision_context::CollisionContext::empty(false); + let nothing_above = collision + .collision_shape_with_context( + &mut scene, + above, + BlockPos::new(x, y, z), + &context, + ) + .is_ok_and(|shape| shape.is_empty()) + && facts.get(above).fluid == crate::blocks::Fluid::None; + velocity.y = match (nothing_above, drag) { + (true, true) => (-0.9_f64).max(velocity.y - 0.03), + (true, false) => 1.8_f64.min(velocity.y + 0.1), + (false, true) => (-0.3_f64).max(velocity.y - 0.03), + (false, false) => 0.7_f64.min(velocity.y + 0.06), + }; + reset_fall |= !nothing_above; + } + } + } + reset_fall +} /// Which fluids `FluidTags.WATER` and `FluidTags.LAVA` hold. pub struct FluidTags; impl FluidMembership for FluidTags { diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index c4091af94..fbcf8ba98 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -4,6 +4,8 @@ //! OptionsList screens and drawn with the shared widgets. use std::time::Instant; +pub use crate::settings::Opt; + use crate::{ gamepad::{self, GlyphStyle}, hud::{HudAtlas, HudBatch, rgba}, @@ -14,98 +16,6 @@ use crate::{ ui, }; -/// One option instance. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Opt { - Fov, - RenderDistance, - SimulationDistance, - Sensitivity, - WheelSensitivity, - InvertY, - DiscreteScroll, - Volume(usize), - GuiScale, - ViewBobbing, - Gamma, - MaxFps, - Vsync, - Fullscreen, - SmoothLighting, - Clouds, - CloudRange, - Particles, - EntityDistance, - EntityShadows, - BiomeBlend, - Preset, - Mipmaps, - WeatherRadius, - ChunkFade, - Vignette, - Autosave, - CutoutLeaves, - ImprovedTransparency, - AttackIndicator, - InactivityFps, - ChunkBuilder, - MenuBlur, - ToggleCrouch, - ToggleSprint, - AutoJump, - ChatVisibility, - ChatColors, - ChatLinks, - ChatLinksPrompt, - ChatOpacity, - TextBackgroundOpacity, - ChatScale, - ChatWidth, - ChatHeightFocused, - ChatHeightUnfocused, - ChatLineSpacing, - AutoSuggestions, - HideMatchedNames, - ReducedDebugInfo, - OnlySecureChat, - SaveChatDrafts, - HighContrast, - ShowSubtitles, - MusicFrequency, - NotificationDisplayTime, - Narrator, - TextBackground, - ChatDelay, - DistortionEffects, - FovEffects, - DarknessPulsing, - DamageTilt, - GlintSpeed, - GlintStrength, - HideLightningFlashes, - MonochromeLogo, - PanoramaSpeed, - HideSplashTexts, - NarratorHotkey, - RotateWithMinecarts, - HighContrastBlockOutlines, - ForceUnicode, - JapaneseGlyphs, - /// Horizon's controller settings (`horizon-controller.txt`). - PadEnabled, - PadVibration, - PadAdaptiveTriggers, - PadLightbar, - PadLookSensitivity, - PadInvertX, - PadInvertY, - PadToggleSneak, - PadMoveDeadzone, - PadLookDeadzone, - PadGlyphs, - PadMenuNav, - PadKeyboard, -} fn tr(key: &str) -> Text { Text::translate(key, &[]) } @@ -177,8 +87,6 @@ impl Opt { | Opt::OnlySecureChat | Opt::SaveChatDrafts | Opt::DistortionEffects - | Opt::GlintSpeed - | Opt::GlintStrength | Opt::MonochromeLogo | Opt::RotateWithMinecarts | Opt::HighContrastBlockOutlines @@ -657,10 +565,12 @@ impl Opt { self.file_key().unwrap(), crate::options_file::V::Double(f64::from(v).powi(2)), ), - Opt::DamageTilt | Opt::PanoramaSpeed => s.file.set( - self.file_key().unwrap(), - crate::options_file::V::Double(f64::from(v)), - ), + Opt::DamageTilt | Opt::PanoramaSpeed | Opt::GlintSpeed | Opt::GlintStrength => { + s.file.set( + self.file_key().unwrap(), + crate::options_file::V::Double(f64::from(v)), + ) + } Opt::Fov => s.fov = step(30.0, 110.0), Opt::RenderDistance => s.render_distance = step(2.0, 64.0) as i32, Opt::SimulationDistance => s.simulation_distance = step(5.0, 32.0) as i32, diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs index 2e7930b4e..9d1c572a2 100644 --- a/crates/horizon-client/src/particles.rs +++ b/crates/horizon-client/src/particles.rs @@ -994,6 +994,8 @@ pub struct ParticleEngine { emitters: Vec<(ParticleOptions, [f64; 3], f64, f64, u32)>, /// Camera position for the 32-block spawn limiter. pub camera: [f64; 3], + /// The Particles option (`ParticleStatus`): 0 all, 1 decreased, 2 minimal. + pub particle_level: u8, /// FireworkParticles.Starter instances. starters: Vec, /// Local sounds requested by particles (dripstone drips): (event, position, volume, pitch). @@ -1024,6 +1026,7 @@ impl ParticleEngine { emitters: Vec::new(), starters: Vec::new(), camera: [0.0; 3], + particle_level: 0, sounds: Vec::new(), made: Default::default(), item_sprites: HashMap::new(), @@ -1134,30 +1137,48 @@ impl ParticleEngine { &mut self.level_random } /// `ClientLevel.addParticle`: dropped beyond 32 blocks of the camera unless - /// the type overrides the limiter. + /// the type overrides the limiter, and thinned by the Particles option. pub fn add(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) { + self.add_with(options, p, v, false, false); + } + /// `ClientLevel.addParticle(particle, overrideLimiter, alwaysShow, ...)` + /// (`doAddParticle`). `always_show` is `addAlwaysVisibleParticle`'s flag. + pub fn add_with( + &mut self, + options: &ParticleOptions, + p: [f64; 3], + v: [f64; 3], + override_limiter: bool, + always_show: bool, + ) { let c = self.camera; let d2 = (p[0] - c[0]).powi(2) + (p[1] - c[1]).powi(2) + (p[2] - c[2]).powi(2); if let Some(requested) = &mut self.requested { requested.push((options.clone(), p, v)); return; } - if !options.ty.override_limiter() && d2 > 1024.0 { - return; + let minimal = self.calculate_particle_level(always_show) == 2; + if override_limiter || options.ty.override_limiter() || (d2 <= 1024.0 && !minimal) { + self.create(options, p, v); } - self.create(options, p, v); + } + /// `ClientLevel.calculateParticleLevel`: minimal still shows one in ten + /// always-visible particles as decreased, and decreased drops a third. + fn calculate_particle_level(&mut self, always_show: bool) -> u8 { + let mut level = self.particle_level.min(2); + if always_show && level == 2 && self.level_random.next_int_bound(10).unwrap_or(0) == 0 { + level = 1; + } + if level == 1 && self.level_random.next_int_bound(3).unwrap_or(0) == 0 { + level = 2; + } + level } /// `LevelEventHandler.singleBlockTeleportationParticles` towards /// `BlockUtil.unpackDifferenceInPosition(from, data, radius)`: the dragon /// egg's event 2015 packs offsets within (16, 8, 16), a consumable's /// teleport (2017) within (127, 127, 127). - pub fn block_teleportation( - &mut self, - from: [i32; 3], - data: i32, - radius: [i32; 3], - particle_level: u8, - ) { + pub fn block_teleportation(&mut self, from: [i32; 3], data: i32, radius: [i32; 3]) { let to = [ from[0].wrapping_add(((data >> 16) & 255) - radius[0]), from[1].wrapping_add(((data >> 8) & 255) - radius[1]), @@ -1175,15 +1196,7 @@ impl ParticleEngine { to[1] + t * (from[1] - to[1]) + r.next_double() - 0.5, to[2] + t * (from[2] - to[2]) + (r.next_double() - 0.5) + 0.5, ]; - // The option roll shares the level random and precedes the distance check. - let limited = match particle_level { - 1 => r.next_int_bound(3).unwrap_or(0) == 0, - 2 => true, - _ => false, - }; - if !limited { - self.add(&options, position, velocity); - } + self.add(&options, position, velocity); } } /// `ClientPacketListener.handleExplosion` + `ClientExplosionTracker`: the @@ -1225,6 +1238,10 @@ impl ParticleEngine { block_count: usize, is_air: &dyn Fn([i32; 3]) -> bool, ) { + // ClientExplosionTracker.tick: only the All option throws the debris. + if self.particle_level != 0 { + return; + } for _ in 0..block_count.min(512) { let r = &mut self.random; let d = Vec3::new( @@ -3765,6 +3782,8 @@ impl ParticleEngine { }, color, light, + + glint_uv: [0.0, 0.0], }); } } @@ -3789,7 +3808,7 @@ mod tests { let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new()); engine.seed_randoms(0, 0, 0); // Destination offset (-15, 7, 15); the unused top byte is ignored. - engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16], 0); + engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16]); assert_eq!(engine.pending.len(), 128); assert!(engine.pending.iter().all(|p| p.ty == ParticleType::Portal)); let first = &engine.pending[0]; @@ -3816,7 +3835,7 @@ mod tests { // TeleportRandomlyConsumeEffect: BlockUtil.clampedPackDifferenceInPosition // of the move (-7, -3, 9) with radii 127, from (4, 12, -5) to (-3, 9, 4). let data = (-7 + 127) << 16 | (-3 + 127) << 8 | (9 + 127); - engine.block_teleportation([4, 12, -5], data, [127, 127, 127], 0); + engine.block_teleportation([4, 12, -5], data, [127, 127, 127]); assert_eq!(engine.pending.len(), 128); for p in &engine.pending { let [x, y, z] = p.position; @@ -3842,7 +3861,8 @@ mod tests { if distant { engine.camera = [1000.0; 3]; } - engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16], option); + engine.particle_level = option; + engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16]); assert_eq!(engine.pending.len(), if distant { 0 } else { count }); assert_eq!(engine.level_random.state(), state); } diff --git a/crates/horizon-client/src/poi_sections.rs b/crates/horizon-client/src/poi_sections.rs index 79ff0441d..a806706a1 100644 --- a/crates/horizon-client/src/poi_sections.rs +++ b/crates/horizon-client/src/poi_sections.rs @@ -79,6 +79,15 @@ impl PoiSections { } } +/// The POI types villagers use. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Poi { + /// A job site, by profession index. + Job(u8), + Home, + Meeting, +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index a325a455f..e746bf946 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -339,7 +339,7 @@ impl SaveTables { } } -pub use crate::chunk::{ChunkExtras, RolledLoot}; +pub use crate::chunk::{ChunkExtras, RolledLoot, SavedProto}; fn tick_list(ticks: &[SavedTick], name: impl Fn(u32) -> Option) -> Tag { Tag::List( @@ -591,6 +591,16 @@ pub fn encode_block_entity( entries.push(("custom_name", name.clone())); } } + // TheEndGatewayBlockEntity.saveAdditional. + BlockEntity::EndGateway(g) => { + entries.push(("Age", Tag::Long(g.age))); + if let Some(exit) = g.exit_portal { + entries.push(("exit_portal", Tag::IntArray(exit.to_vec()))); + } + if g.exact_teleport { + entries.push(("ExactTeleport", Tag::Byte(1))); + } + } BlockEntity::Spawner(s) => entries.extend(s.save()), BlockEntity::TrialSpawner(s) => entries.extend(s.save()), BlockEntity::Vault(v) => entries.extend(v.save()), @@ -650,11 +660,24 @@ fn roll_loaded_loot( biome, )) } +/// `TheEndGatewayBlockEntity.loadAdditional`. +pub fn decode_end_gateway(tag: &Tag) -> crate::containers::EndGateway { + crate::containers::EndGateway { + age: number(tag.get("Age")).unwrap_or(0), + exit_portal: tag + .get("exit_portal") + .and_then(crate::block_entity_nbt::gateway_exit), + exact_teleport: number(tag.get("ExactTeleport")).unwrap_or(0) != 0, + } +} pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers::BlockEntity)> { use crate::containers::BlockEntity; let int = |k: &str| number(tag.get(k)).map(|v| v as i32); let id = text(tag.get("id"))?; let pos = (int("x")?, int("y")?, int("z")?); + if id == "minecraft:end_gateway" { + return Some((pos, BlockEntity::EndGateway(decode_end_gateway(tag)))); + } if id == "minecraft:jukebox" { let record = tag.get("RecordItem").and_then(item_from_nbt); let ticks = number(tag.get("ticks_since_song_started")).unwrap_or(0); @@ -794,6 +817,7 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain | BlockEntity::Lectern(_) | BlockEntity::Banner(_) | BlockEntity::CreakingHeart(_) + | BlockEntity::EndGateway(_) | BlockEntity::Skull(_) | BlockEntity::DaylightDetector => {} BlockEntity::Spawner(s) => **s = crate::mobs::spawner::Spawner::load(tag), @@ -1476,21 +1500,6 @@ fn decode_column( Some(chunk) } -/// A proto chunk saved before it became final. Decoration writes into a -/// chunk's neighbours, and decorated chunks wait for theirs, so the chunks -/// past the finished ones hold writes that generating them again would lose -/// (whole structure pieces, trees, ores). Vanilla saves its proto chunks too. -pub struct SavedProto { - /// Blocks, scheduled ticks (in `saved`) and post-processing marks. - pub column: Chunk, - /// Decorated itself (`features`), not only written to by its neighbours - /// (`terrain`). - pub decorated: bool, - /// Block entity data in placement order, with `x`, `y` and `z`. - pub block_entities: Vec, - /// Entities placed by structures, with absolute `Pos`. - pub entities: Vec, -} pub fn encode_proto( proto: &SavedProto, registry: &BlockRegistry, @@ -4590,6 +4599,79 @@ mod tests { } use super::*; + #[test] + fn end_gateway_block_entity_round_trips() { + use crate::containers::{BlockEntity, EndGateway}; + let plain = BlockEntity::for_block("minecraft:end_gateway").expect("gateway"); + assert!(matches!(&plain, BlockEntity::EndGateway(g) if *g == EndGateway::default())); + for exit in [None, Some([8, 100, 0])] { + for exact in [false, true] { + let gateway = EndGateway { + age: 201, + exit_portal: exit, + exact_teleport: exact, + }; + let tag = encode_block_entity( + (702, 100, 0), + &BlockEntity::EndGateway(gateway.clone()), + "minecraft:end_gateway", + ); + assert_eq!( + text(tag.get("id")).as_deref(), + Some("minecraft:end_gateway") + ); + assert_eq!(tag.get("Age"), Some(&Tag::Long(201))); + assert_eq!( + tag.get("exit_portal"), + exit.map(|p| Tag::IntArray(p.to_vec())).as_ref() + ); + assert_eq!( + tag.get("ExactTeleport"), + exact.then_some(Tag::Byte(1)).as_ref() + ); + let (pos, back) = decode_block_entity(&tag).expect("gateway"); + assert_eq!(pos, (702, 100, 0)); + assert!(matches!(back, BlockEntity::EndGateway(g) if g == gateway)); + } + } + } + + #[test] + fn end_gateway_exit_requires_spawnable_bounds() { + for (exit, valid) in [ + (vec![-30_000_000, -20_000_000, -30_000_000], true), + (vec![29_999_999, 19_999_999, 29_999_999], true), + (vec![30_000_000, 0, 0], false), + (vec![0, 0, 30_000_000], false), + (vec![-30_000_001, 0, 0], false), + (vec![0, 0, -30_000_001], false), + (vec![0, 20_000_000, 0], false), + (vec![0, -20_000_001, 0], false), + (vec![i32::MIN, 0, 0], false), + (vec![0, 100], false), + ] { + let tag = Tag::compound([ + ("id", string("minecraft:end_gateway")), + ("x", Tag::Int(702)), + ("y", Tag::Int(100)), + ("z", Tag::Int(0)), + ("exit_portal", Tag::IntArray(exit)), + ]); + let (_, crate::containers::BlockEntity::EndGateway(g)) = + decode_block_entity(&tag).unwrap() + else { + panic!("gateway"); + }; + assert_eq!(g.exit_portal.is_some(), valid); + let canonical = crate::block_entity_nbt::canonical(&tag).expect("gateway NBT"); + assert_eq!(canonical.get("exit_portal").is_some(), valid); + } + assert_eq!( + decode_end_gateway(&Tag::Compound(Compound::new())), + crate::containers::EndGateway::default() + ); + } + #[test] fn skull_block_entity_keeps_its_profile() { // A placed `player_head` as vanilla saves it: the owning player's diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs index 09d7ae3ff..aeb366947 100644 --- a/crates/horizon-client/src/settings.rs +++ b/crates/horizon-client/src/settings.rs @@ -608,6 +608,99 @@ impl Settings { } } +/// One option instance. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Opt { + Fov, + RenderDistance, + SimulationDistance, + Sensitivity, + WheelSensitivity, + InvertY, + DiscreteScroll, + Volume(usize), + GuiScale, + ViewBobbing, + Gamma, + MaxFps, + Vsync, + Fullscreen, + SmoothLighting, + Clouds, + CloudRange, + Particles, + EntityDistance, + EntityShadows, + BiomeBlend, + Preset, + Mipmaps, + WeatherRadius, + ChunkFade, + Vignette, + Autosave, + CutoutLeaves, + ImprovedTransparency, + AttackIndicator, + InactivityFps, + ChunkBuilder, + MenuBlur, + ToggleCrouch, + ToggleSprint, + AutoJump, + ChatVisibility, + ChatColors, + ChatLinks, + ChatLinksPrompt, + ChatOpacity, + TextBackgroundOpacity, + ChatScale, + ChatWidth, + ChatHeightFocused, + ChatHeightUnfocused, + ChatLineSpacing, + AutoSuggestions, + HideMatchedNames, + ReducedDebugInfo, + OnlySecureChat, + SaveChatDrafts, + HighContrast, + ShowSubtitles, + MusicFrequency, + NotificationDisplayTime, + Narrator, + TextBackground, + ChatDelay, + DistortionEffects, + FovEffects, + DarknessPulsing, + DamageTilt, + GlintSpeed, + GlintStrength, + HideLightningFlashes, + MonochromeLogo, + PanoramaSpeed, + HideSplashTexts, + NarratorHotkey, + RotateWithMinecarts, + HighContrastBlockOutlines, + ForceUnicode, + JapaneseGlyphs, + /// Horizon's controller settings (`horizon-controller.txt`). + PadEnabled, + PadVibration, + PadAdaptiveTriggers, + PadLightbar, + PadLookSensitivity, + PadInvertX, + PadInvertY, + PadToggleSneak, + PadMoveDeadzone, + PadLookDeadzone, + PadGlyphs, + PadMenuNav, + PadKeyboard, +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/horizon-client/src/shadows.rs b/crates/horizon-client/src/shadows.rs index dece7f726..613eb0bb1 100644 --- a/crates/horizon-client/src/shadows.rs +++ b/crates/horizon-client/src/shadows.rs @@ -119,6 +119,8 @@ pub fn shadow( layer: crate::gfx::SHADOW_OVERLAY, color, light: 240 | 240 << 8, + + glint_uv: [0.0, 0.0], }); } } diff --git a/crates/horizon-client/src/signs.rs b/crates/horizon-client/src/signs.rs index 07217ed79..799210797 100644 --- a/crates/horizon-client/src/signs.rs +++ b/crates/horizon-client/src/signs.rs @@ -147,10 +147,10 @@ fn component_text(tag: &Tag) -> String { _ => s, } } - Tag::Compound(_) => match tag.get("text") { - Some(Tag::String(t)) => t.to_string_lossy(), - _ => String::new(), - }, + // Component.getString: translations and key binds resolved. + Tag::Compound(_) => { + crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(tag)).plain() + } _ => String::new(), } } diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs index c5ed5d881..14dfedb49 100644 --- a/crates/horizon-client/src/stations.rs +++ b/crates/horizon-client/src/stations.rs @@ -151,8 +151,12 @@ pub struct AnvilResult { pub repair_item_count_cost: u32, pub only_renaming: bool, } +/// `ItemStack.isDamageableItem`: durability, and not `minecraft:unbreakable`. pub fn is_damageable(items: &Items, stack: &ItemStack) -> bool { items.get(&stack.item).is_some_and(|i| i.max_damage > 0) + && stack + .data() + .is_none_or(|d| d.other("minecraft:unbreakable").is_none()) } fn max_damage(items: &Items, stack: &ItemStack) -> i32 { items.get(&stack.item).map_or(0, |i| i.max_damage as i32) diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 619a0202c..6588ac32d 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -75,11 +75,11 @@ pub trait ChunkGenerator: Send + Sync + 'static { fn light_view(&self, _proto: &Proto) -> Option { None } - fn saved_proto(&self, _proto: &Proto) -> Option { + fn saved_proto(&self, _proto: &Proto) -> Option { None } /// Put a saved proto chunk's state back onto `proto`, generated again. - fn restore_proto(&self, _proto: &mut Proto, _saved: crate::save::SavedProto) {} + fn restore_proto(&self, _proto: &mut Proto, _saved: crate::chunk::SavedProto) {} /// Save proto chunks decoration wrote to, so that they come back as they /// were: generating them again would lose those writes. fn save_protos(&self, _protos: &[&Proto]) {} diff --git a/crates/horizon-client/src/structure_blocks.rs b/crates/horizon-client/src/structure_blocks.rs index 0a4c9a88e..8183b415a 100644 --- a/crates/horizon-client/src/structure_blocks.rs +++ b/crates/horizon-client/src/structure_blocks.rs @@ -257,6 +257,23 @@ mod tests { use super::*; use horizon_world::loot::{ExplorationMap, LootStack}; + #[test] + fn generated_end_gateway_keeps_its_exit() { + let Tag::Compound(nbt) = Tag::compound([ + ("exit_portal", Tag::IntArray(vec![100, 50, 0])), + ("ExactTeleport", Tag::Byte(1)), + ]) else { + unreachable!() + }; + let Some(BlockEntity::EndGateway(g)) = + generated_block_entity("minecraft:end_gateway", &nbt) + else { + panic!("gateway"); + }; + assert_eq!(g.exit_portal, Some([100, 50, 0])); + assert!(g.exact_teleport); + } + #[test] fn placed_chest_loot_keeps_its_enchantments_and_potions() { let stack = diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs index 9984cdcdf..b2fcfe8f4 100644 --- a/crates/horizon-client/src/title.rs +++ b/crates/horizon-client/src/title.rs @@ -14,10 +14,12 @@ use std::{ }; mod create_world; +mod flat; #[cfg(test)] mod tests; pub mod world_management; pub use create_world::{DIFFICULTIES, WorldOptions}; +pub use flat::{FlatLayer, FlatSettings, State as FlatEditor}; /// SelectWorldScreen's `HeaderAndFooterLayout(8 + 9 + 8 + 20 + 4, 60)`. const LIST_TOP: f32 = 49.0; @@ -102,6 +104,16 @@ pub enum Mode { return_to: Box, }, Multiplayer(crate::multiplayer::Screen), + /// CreateFlatWorldScreen over Create New World: the fields that screen + /// keeps and the superflat editor on top of them. + CreateFlat { + name: String, + seed: String, + creative: bool, + focus: u8, + options: WorldOptions, + flat: flat::State, + }, } #[derive(Clone, Debug, PartialEq)] pub enum Action { @@ -129,6 +141,8 @@ pub struct Title { /// Direct Connection's address, synchronized with `options.txt`'s `lastServer`. pub last_server: String, pub saves: PathBuf, + /// The prepared resource root: the flat preset list and block registry. + resources: PathBuf, pub started: std::time::Instant, search: String, search_focused: bool, @@ -234,6 +248,7 @@ impl Title { mode, last_server: String::new(), saves, + resources: resources.to_owned(), started: now, search: String::new(), search_focused: false, @@ -320,6 +335,64 @@ impl Title { self.return_to_list(None); } } + /// A press on the superflat screens: their list, share box or buttons. + fn flat_click(&mut self, x: f32, y: f32, size: (f32, f32), hit: Option) { + match hit { + Some(70) => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.remove_selected(); + } + } + Some(71) => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.open_presets(); + } + } + Some(72) => self.close_flat(true), + Some(73) => self.close_flat(false), + Some(74) => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.apply_share(); + } + } + Some(75) => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.back_to_layers(); + } + } + None => { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat::click(flat, (x, y), size); + } + } + _ => {} + } + } + /// Return to Create New World, keeping (`apply`) or dropping the layers. + fn close_flat(&mut self, apply: bool) { + let mode = std::mem::replace(&mut self.mode, Mode::Main); + if let Mode::CreateFlat { + name, + seed, + creative, + focus, + mut options, + flat, + } = mode + { + if apply { + options.flat = true; + options.flat_settings = Some(flat.settings); + } + self.mode = Mode::Create { + name, + seed, + creative, + focus, + options, + }; + } + } fn matches_search(&self, world: &WorldEntry) -> bool { let filter = self.search.to_lowercase(); world.name.to_lowercase().contains(&filter) || world.folder.to_lowercase().contains(&filter) @@ -370,6 +443,10 @@ impl Title { if let Mode::Multiplayer(screen) = &mut self.mode { return screen.drag(cursor.1, size); } + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat::drag(flat, cursor, size); + return; + } if let Mode::Select { worlds, .. } = &self.mode { let (top, bottom, _, content) = self.world_list(worlds, size); let mut scroll = self.scroll.get(); @@ -385,6 +462,9 @@ impl Title { if let Mode::Multiplayer(screen) = &mut self.mode { screen.release(); } + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat::release(flat); + } self.scroll.get_mut().release(); } /// Mouse wheel over the classic world and server lists. @@ -396,6 +476,10 @@ impl Title { screen.wheel(delta, cursor, size); return; } + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat::wheel(flat, delta, cursor, size); + return; + } let Mode::Select { worlds, .. } = &self.mode else { return; }; @@ -720,6 +804,7 @@ impl Title { Mode::Create { creative, options, .. } => create_world::buttons(w, h, *creative, options), + Mode::CreateFlat { flat, .. } => flat::buttons(w, h, flat), Mode::Edit { world, name, .. } => { let x = (w / 2.0).floor() - 100.0; let top = edit_top(h); @@ -1042,6 +1127,7 @@ impl Title { options, .. } => self.draw_create(atlas, batch, cursor, name, seed, *focus, options), + Mode::CreateFlat { flat, .. } => flat::draw(self, atlas, batch, cursor, flat), Mode::Edit { name, focused, .. } => { crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false); centered( @@ -1248,6 +1334,10 @@ impl Title { .into_iter() .find(|b| b.enabled && x >= b.x && x < b.x + b.w && y >= b.y && y < b.y + 20.0) .map(|b| b.id); + if matches!(self.mode, Mode::CreateFlat { .. }) { + self.flat_click(x, y, (w, h), hit); + return (Action::None, hit.is_some()); + } let action = self.click_action(x, y, (w, h), hit); // World list selection is silent; launching its selected entry sounds. let sound = hit.is_some() || matches!(action, Action::Play { .. }); @@ -1416,6 +1506,27 @@ impl Title { *self.rules.get_mut() = Some(RulesScreen::for_creation(&options.rules)); Action::None } + ( + Mode::Create { + name, + seed, + creative, + focus, + options, + }, + Some(26), + ) => { + let flat = flat::State::new(&self.resources, options.flat_settings.clone()); + self.mode = Mode::CreateFlat { + name: name.clone(), + seed: seed.clone(), + creative: *creative, + focus: *focus, + options: options.clone(), + flat, + }; + Action::None + } ( Mode::Create { creative, options, .. @@ -1669,6 +1780,16 @@ impl Title { self.return_to_list(Some(&folder)); } Mode::Error { return_to, .. } => self.mode = *return_to.clone(), + Mode::CreateFlat { .. } => { + if matches!(&self.mode, Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets) + { + if let Mode::CreateFlat { flat, .. } = &mut self.mode { + flat.back_to_layers(); + } + } else { + self.close_flat(false); + } + } Mode::Create { .. } => self.cancel_create(), _ => self.mode = Mode::Main, } @@ -1697,6 +1818,7 @@ const SEARCH: crate::clipboard::FieldId = ("world.search", 0); const EDIT_NAME: crate::clipboard::FieldId = ("world.edit-name", 0); const WORLD_NAME: crate::clipboard::FieldId = ("world.name", 0); const WORLD_SEED: crate::clipboard::FieldId = ("world.seed", 0); +const FLAT_SHARE: crate::clipboard::FieldId = ("world.flat-share", 0); /// The focused field of the world screens and the server screens: the list's /// search, a world name or seed, or Add Server, Direct Connection and Join a /// Friend. @@ -1720,6 +1842,9 @@ fn caret_field<'a>( _ => None, }, Mode::Multiplayer(screen) => screen.focused_text(), + Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets && flat.share_focused => { + Some((FLAT_SHARE, &mut flat.share, 1230)) + } _ => None, } } diff --git a/crates/horizon-client/src/title/create_world.rs b/crates/horizon-client/src/title/create_world.rs index 65d4f60ac..c0611f0d5 100644 --- a/crates/horizon-client/src/title/create_world.rs +++ b/crates/horizon-client/src/title/create_world.rs @@ -32,6 +32,8 @@ pub struct WorldOptions { pub commands: Option, /// The Superflat world preset instead of Default. pub flat: bool, + /// CreateFlatWorldScreen's layers and biome, kept with the world type. + pub flat_settings: Option, pub structures: bool, pub bonus_chest: bool, /// `getGameRules`: the Game Rules screen's values, saved with the world. @@ -45,6 +47,7 @@ impl Default for WorldOptions { difficulty: 2, commands: None, flat: false, + flat_settings: None, structures: true, bonus_chest: false, rules: crate::gamerules::GameRules::default(), @@ -67,6 +70,10 @@ impl WorldOptions { .unwrap_or(2), commands: Some(commands), flat: generation.flat, + flat_settings: generation + .flat + .then(|| super::flat::FlatSettings::from_world(dir)) + .flatten(), structures: generation.structures, bonus_chest: generation.bonus_chest, rules: crate::gamerules::GameRules::load(dir), @@ -92,6 +99,12 @@ impl WorldOptions { bonus_chest: self.bonus_chest(), } } + /// The custom layers, as `write_world_gen_settings_with` takes them. + pub fn flat_settings(&self) -> Option { + self.flat_settings + .as_ref() + .map(super::flat::FlatSettings::to_tag) + } /// A press on one of the open tab's cycle buttons or switches. pub(super) fn press(&mut self, id: u8, creative: &mut bool) { match id { @@ -105,7 +118,13 @@ impl WorldOptions { } 23 => self.difficulty = (self.difficulty + 1) % DIFFICULTIES.len(), 24 => self.commands = Some(!self.commands(*creative)), - 25 => self.flat = !self.flat, + 25 => { + self.flat = !self.flat; + if self.flat { + // setWorldType starts the generator from the flat preset. + self.flat_settings = Some(super::flat::FlatSettings::default()); + } + } 27 => self.structures = !self.structures, 28 => self.bonus_chest = !self.bonus_chest, _ => {} @@ -247,13 +266,13 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec, + pub structure_overrides: Vec, +} +impl Default for FlatSettings { + fn default() -> Self { + // worldgen/world_preset/flat.json's overworld. + Self { + biome: "minecraft:plains".into(), + features: false, + lakes: false, + layers: vec![ + FlatLayer { + block: "minecraft:bedrock".into(), + height: 1, + }, + FlatLayer { + block: "minecraft:dirt".into(), + height: 2, + }, + FlatLayer { + block: "minecraft:grass_block".into(), + height: 1, + }, + ], + structure_overrides: vec!["minecraft:strongholds".into(), "minecraft:villages".into()], + } + } +} +impl FlatSettings { + /// A saved world's flat generator settings, for Re-Create. + pub fn from_world(dir: &Path) -> Option { + let settings = crate::save::world_gen_settings(dir)?; + let generator = settings + .get("dimensions")? + .get("minecraft:overworld")? + .get("generator")?; + if crate::save::text(generator.get("type"))?.trim_start_matches("minecraft:") != "flat" { + return None; + } + Self::from_tag(generator.get("settings")?) + } + pub fn from_tag(tag: &Tag) -> Option { + let Some(Tag::List(list)) = tag.get("layers") else { + return None; + }; + let layers: Vec = list + .iter() + .filter_map(|layer| { + Some(FlatLayer { + block: crate::save::text(layer.get("block"))?, + height: crate::save::number(layer.get("height"))?.clamp(0, Y_SIZE as i64) + as i32, + }) + }) + .collect(); + // `layers: []` is a valid void flat world; a list whose entries all + // fail to parse is not. + if layers.is_empty() && !list.is_empty() { + return None; + } + let flag = |key: &str, default: bool| { + crate::save::number(tag.get(key)).map_or(default, |value| value != 0) + }; + let structure_overrides = match tag.get("structure_overrides") { + Some(Tag::String(text)) => vec![text.to_string_lossy()], + Some(Tag::List(list)) => list + .iter() + .filter_map(|value| crate::save::text(Some(value))) + .collect(), + _ => Vec::new(), + }; + Some(Self { + biome: crate::save::text(tag.get("biome")).unwrap_or_else(|| "minecraft:plains".into()), + features: flag("features", false), + lakes: flag("lakes", false), + layers, + structure_overrides, + }) + } + /// FlatLevelGeneratorSettings.CODEC, as world_gen_settings stores it. + pub fn to_tag(&self) -> Tag { + let string = |text: &str| Tag::String(text.into()); + Tag::compound([ + ("biome", string(&self.biome)), + ("features", Tag::Byte(i8::from(self.features))), + ("lakes", Tag::Byte(i8::from(self.lakes))), + ( + "layers", + Tag::List( + self.layers + .iter() + .map(|layer| { + Tag::compound([ + ("block", string(&layer.block)), + ("height", Tag::Int(layer.height)), + ]) + }) + .collect(), + ), + ), + ( + "structure_overrides", + Tag::List( + self.structure_overrides + .iter() + .map(|id| string(id)) + .collect(), + ), + ), + ]) + } + /// `CreateFlatWorldScreen.save`: the text the preset screen shows. + pub fn to_share(&self) -> String { + let layers = self + .layers + .iter() + .map(|layer| { + if layer.height == 1 { + layer.block.clone() + } else { + format!("{}*{}", layer.height, layer.block) + } + }) + .collect::>() + .join(","); + format!("{layers};{}", self.biome) + } + /// `PresetFlatWorldScreen.fromString`: `layers;biome`, keeping the + /// decorations the screen was opened with. `None` for a malformed list, + /// as vanilla falls back to the preset's own settings. + pub fn parse( + text: &str, + blocks: &BTreeSet, + biomes: &BTreeSet, + base: &Self, + ) -> Option { + let (layer_text, biome_text) = text.split_once(';').unwrap_or((text, "")); + let mut layers = Vec::new(); + let mut total = 0; + for part in layer_text.split(',') { + let part = part.trim(); + if part.is_empty() { + continue; + } + let (height, block) = match part.split_once('*') { + Some((height, block)) => (height.trim().parse::().ok()?, block.trim()), + None => (1, part), + }; + let block = namespaced(block); + if !blocks.is_empty() && !blocks.contains(&block) { + return None; + } + let height = height.max(0).min(Y_SIZE - total); + if height == 0 { + continue; + } + total += height; + layers.push(FlatLayer { block, height }); + } + if layers.is_empty() { + return None; + } + let mut biome = namespaced(biome_text.trim()); + if biome == "minecraft:" || biome.is_empty() { + biome = "minecraft:plains".into(); + } + if !biomes.is_empty() && !biomes.contains(&biome) { + biome = "minecraft:plains".into(); + } + Some(Self { + biome, + layers, + ..base.clone() + }) + } +} +/// `Identifier.parse`: bare names get the default namespace. +fn namespaced(id: &str) -> String { + if id.is_empty() || id.contains(':') { + id.to_owned() + } else { + format!("minecraft:{id}") + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(super) enum Page { + Layers, + Presets, +} + +#[derive(Clone, Debug)] +pub struct State { + pub(super) page: Page, + pub(super) settings: FlatSettings, + /// The preset screen's share box (`createWorld.customize.presets.share`). + pub(super) share: String, + pub(super) share_focused: bool, + /// The selected layer, in the list's top-first order. + pub(super) selected: Option, + pub(super) scroll: ui::Scroll, + preset_selected: Option, + preset_scroll: ui::Scroll, + presets: Vec, + blocks: BTreeSet, + biomes: BTreeSet, +} +#[derive(Clone, Debug)] +struct Preset { + id: String, + display: String, + settings: FlatSettings, +} +impl State { + /// The layers the editor holds, for the control socket's state. + pub fn settings(&self) -> &FlatSettings { + &self.settings + } + pub(super) fn new(root: &Path, current: Option) -> Self { + let settings = current.unwrap_or_default(); + let (presets, blocks, biomes) = load(root); + Self { + page: Page::Layers, + share: settings.to_share(), + settings, + share_focused: false, + selected: None, + scroll: ui::Scroll::default(), + preset_selected: None, + preset_scroll: ui::Scroll::default(), + presets, + blocks, + biomes, + } + } + pub(super) fn open_presets(&mut self) { + self.page = Page::Presets; + self.preset_selected = None; + self.preset_scroll = ui::Scroll::default(); + self.share = self.settings.to_share(); + self.share_focused = false; + } + pub(super) fn back_to_layers(&mut self) { + self.page = Page::Layers; + self.share_focused = false; + } + pub(super) fn remove_selected(&mut self) { + let Some(row) = self.selected else { + return; + }; + let index = self.settings.layers.len().wrapping_sub(1 + row); + if index < self.settings.layers.len() { + self.settings.layers.remove(index); + } + self.selected = None; + } + /// PresetFlatWorldScreen's Select: parse the share text into the settings + /// the Create New World screen keeps. + pub(super) fn apply_share(&mut self) { + // PresetFlatWorldScreen keeps the selected preset's decorations while + // the share text supplies its layers and biome. + let base = self + .preset_selected + .and_then(|index| self.presets.get(index)) + .map(|preset| preset.settings.clone()) + .unwrap_or_else(|| self.settings.clone()); + // A malformed list falls back to FlatLevelGeneratorSettings.getDefault. + let settings = + FlatSettings::parse(&self.share, &self.blocks, &self.biomes, &base).unwrap_or_default(); + self.settings = settings; + self.share = self.settings.to_share(); + self.page = Page::Layers; + self.share_focused = false; + self.selected = None; + } + fn select_preset(&mut self, index: usize) { + let Some(preset) = self.presets.get(index) else { + return; + }; + self.preset_selected = Some(index); + self.share = preset.settings.to_share(); + self.share_focused = false; + } + fn selecting(&self) -> Option { + self.preset_selected + } +} + +/// `/data//worldgen/flat_level_generator_preset/.json`, +/// in the order of the `visible` tag, plus the block and biome ids the share +/// text is checked against. +fn load(root: &Path) -> (Vec, BTreeSet, BTreeSet) { + let mut presets = Vec::new(); + let tag_path = + root.join("data/minecraft/tags/worldgen/flat_level_generator_preset/visible.json"); + if let Ok(text) = std::fs::read_to_string(tag_path) + && let Ok(Value::Object(tag)) = serde_json::from_str(&text) + && let Some(Value::Array(ids)) = tag.get("values") + { + for id in ids.iter().filter_map(Value::as_str) { + let Some((namespace, path)) = id.split_once(':') else { + continue; + }; + let path = root.join(format!( + "data/{namespace}/worldgen/flat_level_generator_preset/{path}.json" + )); + let Ok(text) = std::fs::read_to_string(path) else { + continue; + }; + let Ok(value) = serde_json::from_str::(&text) else { + continue; + }; + let Some(settings) = preset_settings(&value) else { + continue; + }; + presets.push(Preset { + id: id.to_owned(), + display: value["display"] + .as_str() + .unwrap_or("minecraft:grass_block") + .to_owned(), + settings, + }); + } + } + let blocks = registry_ids(root, "minecraft:block"); + let biomes = json_keys(&root.join("worldgen/biomes.json")); + (presets, blocks, biomes) +} +fn preset_settings(value: &Value) -> Option { + let settings = value.get("settings")?; + let layers = settings + .get("layers")? + .as_array()? + .iter() + .filter_map(|layer| { + Some(FlatLayer { + block: layer.get("block")?.as_str()?.to_owned(), + height: layer.get("height")?.as_i64()? as i32, + }) + }) + .collect::>(); + if layers.is_empty() { + return None; + } + let structure_overrides = match settings.get("structure_overrides") { + Some(Value::String(id)) => vec![id.clone()], + Some(Value::Array(ids)) => ids + .iter() + .filter_map(Value::as_str) + .map(str::to_owned) + .collect(), + _ => Vec::new(), + }; + Some(FlatSettings { + biome: settings + .get("biome") + .and_then(Value::as_str) + .unwrap_or("minecraft:plains") + .to_owned(), + features: settings + .get("features") + .and_then(Value::as_bool) + .unwrap_or(false), + lakes: settings + .get("lakes") + .and_then(Value::as_bool) + .unwrap_or(false), + layers, + structure_overrides, + }) +} +/// The ids of a registry in the prepared `registries.json`. +fn registry_ids(root: &Path, registry: &str) -> BTreeSet { + let Ok(text) = std::fs::read_to_string(root.join("registries.json")) else { + return BTreeSet::new(); + }; + let Ok(value) = serde_json::from_str::(&text) else { + return BTreeSet::new(); + }; + value + .get(registry) + .and_then(|registry| registry.get("entries")) + .and_then(Value::as_object) + .map(|entries| entries.keys().cloned().collect()) + .unwrap_or_default() +} +fn json_keys(path: &Path) -> BTreeSet { + let Ok(text) = std::fs::read_to_string(path) else { + return BTreeSet::new(); + }; + let Ok(value) = serde_json::from_str::(&text) else { + return BTreeSet::new(); + }; + value + .as_object() + .map(|entries| entries.keys().cloned().collect()) + .unwrap_or_default() +} + +/// CreateFlatWorldScreen's list and the preset screen's list. +fn list_area(state: &State, size: (f32, f32)) -> (f32, f32, f32, f32) { + let (w, h) = (size.0.ceil(), size.1.ceil()); + let (top, bottom) = match state.page { + Page::Layers => (43.0, h - 60.0), + Page::Presets => (80.0, h - 37.0), + }; + let left = ((w - ROW_WIDTH) * 0.5).floor(); + let rows = match state.page { + Page::Layers => HEADER + state.settings.layers.len() as f32 * LAYER_ROW + 4.0, + Page::Presets => state.presets.len() as f32 * PRESET_ROW + 4.0, + }; + (top, bottom, left, rows) +} + +pub(super) fn buttons(w: f32, h: f32, state: &State) -> Vec