diff --git a/crates/horizon-client/src/banner.rs b/crates/horizon-client/src/banner.rs new file mode 100644 index 000000000..d2bc33fba --- /dev/null +++ b/crates/horizon-client/src/banner.rs @@ -0,0 +1,313 @@ +//! Banner patterns: the `banner_pattern` registry and its tags, the +//! `banner_patterns` layers carried by banner items, shields and placed +//! banners, and the loom rules of `LoomMenu` (selectable patterns, the +//! six-layer limit and the result stack). +use crate::{block_entity_render::DYES, item_data, items::ItemStack, items::Items}; +use horizon_world::nbt::Tag; +use serde_json::Value; +use std::{collections::HashMap, fs, path::Path, sync::Arc}; + +/// `BannerPatternLayers.Layer`: a pattern id and the dye name it is painted in. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct BannerLayer { + pub pattern: Arc, + pub color: Arc, +} +impl BannerLayer { + pub fn new(pattern: &str, color: &str) -> Self { + Self { + pattern: Arc::from(pattern), + color: Arc::from(color), + } + } +} + +/// Layers a loom may stack on a banner (`LoomMenu`'s `hasMaxPatterns`). +pub const MAX_LAYERS: usize = 6; + +/// One `banner_pattern` registry entry. +#[derive(Clone, Debug)] +pub struct Pattern { + pub id: Arc, + /// `asset_id` path, the texture under `entity/banner` and `entity/shield`. + pub asset: String, + pub translation_key: String, +} + +/// The pattern registry, its tags and the item components the loom reads. +#[derive(Default)] +pub struct Banners { + patterns: Vec, + /// `#minecraft:no_item_required`, in tag order. + no_item_required: Vec>, + /// Item -> `dye` component. + dyes: HashMap, Arc>, + /// Item -> `provides_banner_patterns`, in tag order. + provided: HashMap, Vec>>, +} + +fn read_tag(root: &Path, name: &str, depth: u32) -> Vec> { + if depth > 8 { + return Vec::new(); + } + let path = root.join(format!( + "data/minecraft/tags/banner_pattern/{}.json", + name.trim_start_matches("minecraft:") + )); + let Some(v) = fs::read(path) + .ok() + .and_then(|b| serde_json::from_slice::(&b).ok()) + else { + return Vec::new(); + }; + let mut out = Vec::new(); + for value in v["values"].as_array().into_iter().flatten() { + let Some(s) = value.as_str().or_else(|| value["id"].as_str()) else { + continue; + }; + match s.strip_prefix('#') { + Some(tag) => out.extend(read_tag(root, tag, depth + 1)), + None => out.push(Arc::from(s)), + } + } + out +} + +impl Banners { + pub fn load(root: &Path) -> Self { + let mut banners = Self::default(); + let mut files: Vec<_> = fs::read_dir(root.join("data/minecraft/banner_pattern")) + .into_iter() + .flatten() + .flatten() + .map(|e| e.path()) + .filter(|p| p.extension().is_some_and(|e| e == "json")) + .collect(); + files.sort(); + for path in files { + let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else { + continue; + }; + let Some(v) = fs::read(&path) + .ok() + .and_then(|b| serde_json::from_slice::(&b).ok()) + else { + continue; + }; + let asset = v["asset_id"] + .as_str() + .unwrap_or(stem) + .trim_start_matches("minecraft:") + .to_owned(); + banners.patterns.push(Pattern { + id: Arc::from(format!("minecraft:{stem}").as_str()), + asset, + translation_key: v["translation_key"].as_str().unwrap_or_default().to_owned(), + }); + } + banners.no_item_required = read_tag(root, "no_item_required", 0); + if let Some(raw) = fs::read(root.join("items.json")).ok().and_then(|b| { + serde_json::from_slice::>(&b).ok() + }) { + for (item, c) in raw { + let id: Arc = Arc::from(item.as_str()); + if let Some(dye) = c["minecraft:dye"].as_str() { + banners.dyes.insert(id.clone(), Arc::from(dye)); + } + match &c["minecraft:provides_banner_patterns"] { + Value::String(tag) if tag.starts_with('#') => { + banners.provided.insert(id, read_tag(root, &tag[1..], 0)); + } + Value::String(single) => { + banners + .provided + .insert(id, vec![Arc::from(single.as_str())]); + } + _ => {} + } + } + } + banners + } + pub fn pattern(&self, id: &str) -> Option<&Pattern> { + self.patterns.iter().find(|p| &*p.id == id) + } + /// `Sheets.getBannerSprite` texture name of a pattern. + pub fn banner_texture(&self, id: &str) -> String { + match self.pattern(id) { + Some(p) => format!("entity/banner/{}", p.asset), + None => format!("entity/banner/{}", id.trim_start_matches("minecraft:")), + } + } + /// `Sheets.getShieldSprite` texture name of a pattern. + pub fn shield_texture(&self, id: &str) -> String { + match self.pattern(id) { + Some(p) => format!("entity/shield/{}", p.asset), + None => format!("entity/shield/{}", id.trim_start_matches("minecraft:")), + } + } + /// `BannerPatternLayers.Layer.description` translation key. + pub fn layer_key(&self, layer: &BannerLayer) -> String { + let base = self.pattern(&layer.pattern).map_or_else( + || { + format!( + "block.minecraft.banner.{}", + layer.pattern.trim_start_matches("minecraft:") + ) + }, + |p| p.translation_key.clone(), + ); + format!("{base}.{}", layer.color) + } + /// `LoomMenu.isDyeItem`: the dye colour of a loom dye. + pub fn loom_dye(&self, items: &Items, stack: &ItemStack) -> Option> { + let tagged = items + .item_tags + .get("minecraft:loom_dyes") + .is_some_and(|t| t.contains(&*stack.item)); + tagged + .then(|| self.dyes.get(&stack.item).cloned()) + .flatten() + } + /// `LoomMenu.isPatternItem`. + pub fn is_pattern_item(&self, items: &Items, stack: &ItemStack) -> bool { + items + .item_tags + .get("minecraft:loom_patterns") + .is_some_and(|t| t.contains(&*stack.item)) + && self.provided.contains_key(&stack.item) + } + /// `LoomMenu.getSelectablePatterns`. + pub fn selectable(&self, pattern_item: Option<&ItemStack>) -> Vec> { + match pattern_item { + None => self.no_item_required.clone(), + Some(stack) => self.provided.get(&stack.item).cloned().unwrap_or_default(), + } + } +} + +/// `BannerItem`: a banner's dye colour from its item id. +pub fn banner_color(item: &str) -> Option<&'static str> { + let name = item.strip_prefix("minecraft:")?.strip_suffix("_banner")?; + DYES.iter().map(|d| d.0).find(|d| *d == name) +} +/// `DyeColor.getTextureDiffuseColor` (RGB) by dye name. +pub fn dye_rgb(name: &str) -> u32 { + DYES.iter().find(|d| d.0 == name).map_or(0xFFFFFF, |d| d.1) +} +/// The layers of a banner or shield stack. +pub fn layers(stack: &ItemStack) -> &[BannerLayer] { + stack.data().map_or(&[], |d| &d.banner_patterns) +} +/// `LoomMenu.setupResultSlot`: one banner with the pattern added in the dye colour. +pub fn loom_result(banner: &ItemStack, dye: &str, pattern: &str) -> ItemStack { + let mut result = ItemStack { + count: 1, + ..banner.clone() + }; + result + .data_mut() + .banner_patterns + .push(BannerLayer::new(pattern, dye)); + result +} +/// Whether the banner already carries the loom's limit. +pub fn has_max_layers(banner: &ItemStack) -> bool { + layers(banner).len() >= MAX_LAYERS +} + +/// The `banner_patterns` NBT list of layers. +pub fn layers_to_nbt(layers: &[BannerLayer]) -> Tag { + Tag::List( + layers + .iter() + .map(|l| { + Tag::compound([ + ("pattern", Tag::String((&*l.pattern).into())), + ("color", Tag::String((&*l.color).into())), + ]) + }) + .collect(), + ) +} +pub fn layers_from_nbt(tag: Option<&Tag>) -> Vec { + let Some(Tag::List(list)) = tag else { + return Vec::new(); + }; + list.iter() + .filter_map(|e| { + let text = |k: &str| match e.get(k) { + Some(Tag::String(s)) => Some(s.to_string_lossy()), + _ => None, + }; + let pattern = text("pattern")?; + let color = text("color")?; + Some(BannerLayer::new( + &if pattern.contains(':') { + pattern + } else { + format!("minecraft:{pattern}") + }, + &color, + )) + }) + .collect() +} +/// Keeps `item_data` linked: the `StackData` fields the banner code reads. +pub fn set_layers(stack: &mut ItemStack, layers: Vec) { + let data: &mut item_data::StackData = stack.data_mut(); + data.banner_patterns = layers; + stack.tidy(); +} + +#[cfg(test)] +mod tests { + use super::*; + + fn banners() -> Banners { + let mut b = Banners { + no_item_required: vec![Arc::from("minecraft:stripe_top")], + ..Default::default() + }; + b.provided.insert( + Arc::from("minecraft:flower_banner_pattern"), + vec![Arc::from("minecraft:flower")], + ); + b + } + #[test] + fn selectable_follow_the_pattern_item() { + let b = banners(); + assert_eq!(b.selectable(None).len(), 1); + let item = ItemStack::new("minecraft:flower_banner_pattern", 1); + assert_eq!(&*b.selectable(Some(&item))[0], "minecraft:flower"); + } + #[test] + fn banner_colour_comes_from_the_item() { + assert_eq!( + banner_color("minecraft:light_gray_banner"), + Some("light_gray") + ); + assert_eq!(banner_color("minecraft:white_banner"), Some("white")); + assert_eq!(banner_color("minecraft:white_wool"), None); + } + #[test] + fn loom_adds_a_layer_up_to_the_limit() { + let mut banner = ItemStack::new("minecraft:white_banner", 3); + for i in 0..MAX_LAYERS { + assert!(!has_max_layers(&banner)); + banner = loom_result(&banner, "red", "minecraft:cross"); + assert_eq!(banner.count, 1); + assert_eq!(layers(&banner).len(), i + 1); + } + assert!(has_max_layers(&banner)); + } + #[test] + fn layers_round_trip_through_nbt() { + let l = vec![ + BannerLayer::new("minecraft:flower", "red"), + BannerLayer::new("minecraft:border", "black"), + ]; + assert_eq!(layers_from_nbt(Some(&layers_to_nbt(&l))), l); + } +} diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 5869f6de0..8114542b0 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -700,6 +700,8 @@ pub struct Scene<'a> { pub lid: &'a dyn Fn([i32; 3]) -> f32, /// Sign block-entity data at a position. pub sign: &'a dyn Fn([i32; 3]) -> Option<&'a crate::signs::SignData>, + /// Banner layers at a position: pattern texture and RGB tint, bottom first. + pub banner: &'a dyn Fn([i32; 3]) -> Vec<(String, u32)>, /// Font glyph cell and advance. pub glyph: &'a dyn Fn(char) -> Option<(Rect, f32)>, } @@ -773,6 +775,13 @@ impl BlockEntityRenderer { random: LegacyRandom::new(0x5EED_B00C), } } + /// The standing banner's pole-and-bar and flag models (`BannerRenderer.submitSpecial`). + pub fn banner_models(&self) -> Option<(&ModelPart, &ModelPart)> { + Some(( + self.models.get("standing_banner")?, + self.models.get("standing_banner_flag")?, + )) + } fn kind(&self, state: u32) -> &Kind { self.kinds.get(state as usize).unwrap_or(&Kind::None) } @@ -993,10 +1002,16 @@ impl BlockEntityRenderer { draw_part(main, "root", m, &none, paint, out); draw_part(flag, "root", m, &wave, paint, out); } - // BannerRenderer.submitPatterns: the base pattern layer in the dye colour. + // BannerRenderer.submitPatterns: the base pattern layer in the dye colour, + // then up to 16 pattern layers in order. if let Some(paint) = paint("entity/banner/base", *color, packed) { draw_part(flag, "root", m, &wave, paint, out); } + for (texture, tint) in (scene.banner)(pos).iter().take(16) { + if let Some(paint) = paint(texture, *tint, packed) { + draw_part(flag, "root", m, &wave, paint, out); + } + } } Kind::Skull { kind, diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs index e1332b159..d5e65655c 100644 --- a/crates/horizon-client/src/chunk.rs +++ b/crates/horizon-client/src/chunk.rs @@ -94,6 +94,8 @@ pub struct Chunk { /// Highest non-air, light-blocking-or-fluid Y per column (MOTION_BLOCKING-like), for rain/sky. pub heights: Arc<[i16; 256]>, pub lit: bool, + /// Light read from a save with `isLightOn`: no light job is needed. + pub light_loaded: bool, /// Newly generated (not loaded from a save): eligible for generation-time spawns. pub fresh: bool, /// Block entities read from a save, moved into the world on arrival. @@ -120,6 +122,7 @@ impl Chunk { biomes: Arc::new(vec![0; 16 * (HEIGHT as usize / 4)]), heights: Arc::new([MIN_Y as i16; 256]), lit: false, + light_loaded: false, fresh: false, block_entities: Vec::new(), structure_refs: Vec::new(), diff --git a/crates/horizon-client/src/command/vanilla.rs b/crates/horizon-client/src/command/vanilla.rs index 853ed638d..f2c51d988 100644 --- a/crates/horizon-client/src/command/vanilla.rs +++ b/crates/horizon-client/src/command/vanilla.rs @@ -111,6 +111,28 @@ pub fn build() -> Dispatcher { d.executes(dur, "weather"); } + // raid start | stop | check | sound | spawnleader | setomen | glow + let raid = d.literal(root, "raid"); + d.requires(raid, 3); + let start = d.literal(raid, "start"); + let level = d.argument(start, "omenlvl", integer(0)); + d.executes(level, "raid.start"); + for (name, id) in [ + ("stop", "raid.stop"), + ("check", "raid.check"), + ("spawnleader", "raid.spawnleader"), + ("glow", "raid.glow"), + ] { + let n = d.literal(raid, name); + d.executes(n, id); + } + let sound = d.literal(raid, "sound"); + let kind = d.argument(sound, "type", ArgType::Greedy); + d.executes(kind, "raid.sound"); + let setomen = d.literal(raid, "setomen"); + let level = d.argument(setomen, "level", integer(0)); + d.executes(level, "raid.setomen"); + // kill [] let kill = d.literal(root, "kill"); d.requires(kill, GAMEMASTERS); diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index 6d999c9a8..5f8565e42 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -58,6 +58,77 @@ pub enum BlockEntity { Beacon(Box), /// `LecternBlockEntity`: the book and the open page. Lectern(Lectern), + /// `CreakingHeartBlockEntity`: its protector and the hurt emitter. + CreakingHeart(Box), + /// `BannerBlockEntity`: the pattern layers. + Banner(Banner), + /// `CrafterBlockEntity`. + Crafter(Crafter), +} +/// `CrafterBlockEntity`: nine slots that can be disabled, the powered flag +/// and the ticks left in the crafting animation. +#[derive(Clone, Debug, Default)] +pub struct Crafter { + pub items: [Option; 9], + pub disabled: [bool; 9], + pub triggered: bool, + pub crafting_ticks: i32, +} +impl Crafter { + /// `slotCanBeDisabled`: only empty slots. + pub fn slot_can_be_disabled(&self, slot: usize) -> bool { + slot < 9 && self.items[slot].is_none() + } + /// `setSlotState`. + pub fn set_slot_state(&mut self, slot: usize, enabled: bool) { + if self.slot_can_be_disabled(slot) { + self.disabled[slot] = !enabled; + } + } + /// `getRedstoneSignal`: filled or disabled slots. + pub fn redstone_signal(&self) -> i32 { + (0..9) + .filter(|&i| self.items[i].is_some() || self.disabled[i]) + .count() as i32 + } + /// `canPlaceItem`: a hopper fills the smallest stacks first. + pub fn can_place(&self, slot: usize, stack: &ItemStack, max_stack: u32) -> bool { + if slot >= 9 || self.disabled[slot] { + return false; + } + let Some(current) = &self.items[slot] else { + return true; + }; + if current.count >= max_stack { + return false; + } + !(slot + 1..9).any(|i| { + !self.disabled[i] + && match &self.items[i] { + None => true, + Some(other) => { + other.count < current.count && other.same_item_same_components(stack) + } + } + }) + } +} +#[derive(Clone, Debug, Default)] +pub struct Banner { + pub layers: Vec, + pub name: Option, +} +/// `CreakingHeartBlockEntity` (the logic is in `game/creaking.rs`). +#[derive(Clone, Debug, Default)] +pub struct CreakingHeart { + /// The protector: its entity id once resolved, and its UUID (the saved form). + pub creaking: Option<(Option, [i32; 4])>, + pub ticks_existed: i64, + pub ticker: i32, + /// Ticks left of the hurt effect (`emitter`) and where it heads. + pub emitter: i32, + pub emitter_target: Option<[f64; 3]>, + pub output_signal: i32, } #[derive(Clone, Debug, Default)] pub struct Lectern { @@ -101,9 +172,18 @@ impl BlockEntity { speed: 1.0, })); } + if name == "minecraft:creaking_heart" { + return Some(Self::CreakingHeart(Box::default())); + } if name == "minecraft:lectern" { return Some(Self::Lectern(Lectern::default())); } + if name == "minecraft:crafter" { + return Some(Self::Crafter(Crafter::default())); + } + if name.ends_with("_banner") { + return Some(Self::Banner(Banner::default())); + } if name == "minecraft:beacon" { return Some(Self::Beacon(Box::new(Beacon { last_check_y: i32::MIN / 2, @@ -135,6 +215,7 @@ impl BlockEntity { "minecraft:blast_furnace" => "minecraft:blast_furnace", "minecraft:smoker" => "minecraft:smoker", n if n.ends_with("shulker_box") => "minecraft:shulker_box", + "minecraft:crafter" => "minecraft:crafter", _ => return None, }) } @@ -155,6 +236,9 @@ impl BlockEntity { Self::Jukebox(_) => "minecraft:jukebox", Self::Beacon(_) => "minecraft:beacon", Self::Lectern(_) => "minecraft:lectern", + Self::Banner(_) => "minecraft:banner", + Self::Crafter(_) => "minecraft:crafter", + Self::CreakingHeart(_) => "minecraft:creaking_heart", } } pub fn contents(&self) -> Vec { @@ -164,8 +248,10 @@ impl BlockEntity { Self::Brewing(b) => b.items.iter().flatten().cloned().collect(), Self::Sign(_) => Vec::new(), Self::Jukebox(j) => j.record.iter().cloned().collect(), - Self::Beacon(_) => Vec::new(), + Self::Beacon(_) | Self::CreakingHeart(_) => Vec::new(), Self::Lectern(l) => l.book.iter().cloned().collect(), + Self::Banner(_) => Vec::new(), + Self::Crafter(c) => c.items.iter().flatten().cloned().collect(), } } pub fn slots(&self) -> &[Option] { @@ -173,7 +259,13 @@ impl BlockEntity { Self::Chest(items) => items, Self::Furnace(f) => &f.items, Self::Brewing(b) => &b.items, - Self::Sign(_) | Self::Jukebox(_) | Self::Beacon(_) | Self::Lectern(_) => &[], + Self::Sign(_) + | Self::Jukebox(_) + | Self::Beacon(_) + | Self::Lectern(_) + | Self::Banner(_) => &[], + Self::Crafter(c) => &c.items, + Self::CreakingHeart(_) => &[], } } pub fn slots_mut(&mut self) -> &mut [Option] { @@ -181,7 +273,13 @@ impl BlockEntity { Self::Chest(items) => items, Self::Furnace(f) => &mut f.items, Self::Brewing(b) => &mut b.items, - Self::Sign(_) | Self::Jukebox(_) | Self::Beacon(_) | Self::Lectern(_) => &mut [], + Self::Sign(_) + | Self::Jukebox(_) + | Self::Beacon(_) + | Self::Lectern(_) + | Self::Banner(_) => &mut [], + Self::Crafter(c) => &mut c.items, + Self::CreakingHeart(_) => &mut [], } } } diff --git a/crates/horizon-client/src/crafting.rs b/crates/horizon-client/src/crafting.rs index ecf8f9bd6..aa434a556 100644 --- a/crates/horizon-client/src/crafting.rs +++ b/crates/horizon-client/src/crafting.rs @@ -53,9 +53,104 @@ pub enum Recipe { ingredients: Vec, result: ItemStack, }, + /// `BannerDuplicateRecipe` and `ShieldDecorationRecipe`. + Special(Special), +} +/// The banner-copying custom recipes. +#[derive(Clone, Debug)] +pub enum Special { + /// A patterned banner and a blank one of the same colour copy the patterns. + BannerDuplicate { banner: Ingredient, result: String }, + /// A banner decorates an undecorated shield. + ShieldDecoration { + banner: Ingredient, + target: Ingredient, + result: String, + }, +} +impl Special { + /// `matches` + `assemble` over the non-empty stacks of the grid. + fn assemble(&self, stacks: &[&ItemStack]) -> Option { + use crate::banner; + if stacks.len() != 2 { + return None; + } + match self { + Self::BannerDuplicate { + banner: ing, + result, + } => { + let color = banner::banner_color(&stacks[0].item)?; + let mut source = None; + let mut target = false; + for s in stacks { + if !ing.test(s) || banner::banner_color(&s.item)? != color { + return None; + } + let layers = banner::layers(s).len(); + if layers > banner::MAX_LAYERS { + return None; + } + if layers > 0 { + if source.is_some() { + return None; + } + source = Some(*s); + } else { + if target { + return None; + } + target = true; + } + } + let source = source.filter(|_| target)?; + // TransmuteRecipe.createWithOriginalComponents: the source's components. + Some(ItemStack { + item: Arc::from(result.as_str()), + count: 1, + ..(*source).clone() + }) + } + Self::ShieldDecoration { + banner: ing, + target: tgt, + result, + } => { + let (mut patterned, mut clear) = (None, None); + for s in stacks { + if ing.test(s) && banner::banner_color(&s.item).is_some() { + if patterned.is_some() { + return None; + } + patterned = Some(*s); + } else { + if !tgt.test(s) || clear.is_some() || !banner::layers(s).is_empty() { + return None; + } + clear = Some(*s); + } + } + let (banner_stack, shield) = (patterned?, clear?); + let mut out = ItemStack { + item: Arc::from(result.as_str()), + count: 1, + ..shield.clone() + }; + let data = out.data_mut(); + data.banner_patterns = banner::layers(banner_stack).to_vec(); + data.base_color = banner::banner_color(&banner_stack.item).map(Arc::from); + Some(out) + } + } + } } #[derive(Clone, Debug)] pub struct Cooking { + /// The recipe's file name (its id without namespace). + pub id: String, + /// `category` (`food`, `blocks`, `misc`) and `group` of the recipe book. + pub category: String, + pub group: String, pub kind: String, pub ingredient: Ingredient, pub result: ItemStack, @@ -65,6 +160,8 @@ pub struct Cooking { pub struct Recipes { pub crafting: Vec<(String, Recipe)>, pub cooking: Vec, + /// `category` and `group` of each crafting recipe, by file name. + pub meta: std::collections::HashMap, } fn result(v: &Value) -> Option { Some(ItemStack { @@ -78,6 +175,7 @@ impl Recipes { pub fn load(root: &Path, items: &Items) -> Result { let mut crafting = Vec::new(); let mut cooking = Vec::new(); + let mut meta = std::collections::HashMap::new(); let mut files: Vec<_> = fs::read_dir(root.join("data/minecraft/recipe"))? .flatten() .map(|e| e.path()) @@ -91,6 +189,8 @@ impl Recipes { .unwrap_or("") .to_owned(); let v: Value = serde_json::from_slice(&fs::read(&path)?)?; + let text = |k: &str| v[k].as_str().unwrap_or("").to_owned(); + meta.insert(name.clone(), (text("category"), text("group"))); match v["type"].as_str().unwrap_or("") { "minecraft:crafting_shaped" => { let pattern: Vec> = v["pattern"] @@ -145,6 +245,36 @@ impl Recipes { )); } } + "minecraft:crafting_special_bannerduplicate" => { + if let (Some(banner), Some(id)) = ( + Ingredient::parse(&v["banner"], items), + v["result"]["id"].as_str(), + ) { + crafting.push(( + name, + Recipe::Special(Special::BannerDuplicate { + banner, + result: id.to_owned(), + }), + )); + } + } + "minecraft:crafting_special_shielddecoration" => { + if let (Some(banner), Some(target), Some(id)) = ( + Ingredient::parse(&v["banner"], items), + Ingredient::parse(&v["target"], items), + v["result"]["id"].as_str(), + ) { + crafting.push(( + name, + Recipe::Special(Special::ShieldDecoration { + banner, + target, + result: id.to_owned(), + }), + )); + } + } kind @ ("minecraft:smelting" | "minecraft:blasting" | "minecraft:smoking" @@ -154,6 +284,9 @@ impl Recipes { result(&v["result"]), ) { cooking.push(Cooking { + id: name, + category: text("category"), + group: text("group"), kind: kind.to_owned(), ingredient, result, @@ -165,10 +298,18 @@ impl Recipes { _ => {} } } - Ok(Self { crafting, cooking }) + Ok(Self { + crafting, + cooking, + meta, + }) } /// Match a `size`x`size` grid (row-major) against the crafting recipes. pub fn craft(&self, grid: &[Option], size: usize) -> Option { + self.find(grid, size).map(|(_, result)| result) + } + /// `craft` with the matched recipe's id (the file name without namespace). + pub fn find(&self, grid: &[Option], size: usize) -> Option<(&str, ItemStack)> { // Trim to the occupied bounding box. let occupied: Vec<(usize, usize)> = (0..size * size) .filter(|&i| grid[i].is_some()) @@ -187,8 +328,14 @@ impl Recipes { ); let (w, h) = (x1 - x0 + 1, y1 - y0 + 1); let cell = |x: usize, y: usize| grid[(y0 + y) * size + x0 + x].as_ref(); - for (_, recipe) in &self.crafting { + for (name, recipe) in &self.crafting { match recipe { + Recipe::Special(special) => { + let stacks: Vec<&ItemStack> = grid.iter().flatten().collect(); + if let Some(result) = special.assemble(&stacks) { + return Some((name, result)); + } + } Recipe::Shaped { width, height, @@ -211,7 +358,7 @@ impl Recipes { }) }; if matches(false) || matches(true) { - return Some(result.clone()); + return Some((name, result.clone())); } } Recipe::Shapeless { @@ -235,16 +382,87 @@ impl Recipes { } }); if ok { - return Some(result.clone()); + return Some((name, result.clone())); } } } } None } + /// `Recipe.getRemainingItems` per grid cell: an item's crafting remainder + /// (buckets, bottles), and the patterned banner a duplicate keeps. + pub fn remainders( + &self, + items: &Items, + grid: &[Option], + result: &ItemStack, + ) -> Vec> { + grid.iter() + .map(|cell| { + let s = cell.as_ref()?; + if let Some(rem) = items.get(&s.item).and_then(|i| i.remainder.as_deref()) { + return Some(ItemStack::new(rem, 1)); + } + (result.item.ends_with("_banner") && !crate::banner::layers(s).is_empty()).then( + || ItemStack { + count: 1, + ..s.clone() + }, + ) + }) + .collect() + } pub fn cook(&self, kind: &str, input: &ItemStack) -> Option<&Cooking> { self.cooking .iter() .find(|c| c.kind == kind && c.ingredient.test(input)) } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::banner::BannerLayer; + + fn ingredient(items: &[&str]) -> Ingredient { + Ingredient(items.iter().map(|s| (*s).to_owned()).collect()) + } + fn patterned(item: &str) -> ItemStack { + let mut s = ItemStack::new(item, 1); + s.data_mut().banner_patterns = vec![BannerLayer::new("minecraft:cross", "red")]; + s + } + #[test] + fn banner_duplicate_copies_the_patterns_of_the_same_colour() { + let recipe = Special::BannerDuplicate { + banner: ingredient(&["minecraft:white_banner"]), + result: "minecraft:white_banner".into(), + }; + let source = patterned("minecraft:white_banner"); + let blank = ItemStack::new("minecraft:white_banner", 1); + let out = recipe.assemble(&[&source, &blank]).expect("copy"); + assert_eq!(out.data().unwrap().banner_patterns.len(), 1); + // Two blanks, or two patterned banners, do not match. + assert!(recipe.assemble(&[&blank, &blank]).is_none()); + assert!(recipe.assemble(&[&source, &source]).is_none()); + // Another colour is not in the recipe's ingredient. + let other = ItemStack::new("minecraft:red_banner", 1); + assert!(recipe.assemble(&[&source, &other]).is_none()); + } + #[test] + fn shield_decoration_needs_a_bare_shield() { + let recipe = Special::ShieldDecoration { + banner: ingredient(&["minecraft:red_banner"]), + target: ingredient(&["minecraft:shield"]), + result: "minecraft:shield".into(), + }; + let banner = patterned("minecraft:red_banner"); + let shield = ItemStack::new("minecraft:shield", 1); + let out = recipe.assemble(&[&banner, &shield]).expect("decorated"); + let data = out.data().unwrap(); + assert_eq!(data.base_color.as_deref(), Some("red")); + assert_eq!(data.banner_patterns.len(), 1); + // A shield that already has patterns cannot be decorated again. + assert!(recipe.assemble(&[&banner, &out]).is_none()); + } +} diff --git a/crates/horizon-client/src/enchant.rs b/crates/horizon-client/src/enchant.rs index 42d237c50..6e806712a 100644 --- a/crates/horizon-client/src/enchant.rs +++ b/crates/horizon-client/src/enchant.rs @@ -194,7 +194,11 @@ impl Enchantments { || k.starts_with("potion.") || k.starts_with("container.") || k.starts_with("merchant.") - || k.starts_with("entity.minecraft.villager") + || k.starts_with("entity.minecraft.") + || k.starts_with("gui.recipebook.") + || k.starts_with("gui.togglable_slot") + || k.starts_with("block.minecraft.banner.") + || k.starts_with("recipe.toast.") }) .collect(); let mut list = Vec::new(); diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index cd7ec701c..476b0a243 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -135,7 +135,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { for (key, value) in [ ("AbsorptionAmount", Tag::Float(0)), ("FallFlying", Tag::Byte(0)), - ("CanPickUpLoot", Tag::Byte(0)), + ("CanPickUpLoot", Tag::Byte(i8::from(m.extra.pick_up_loot))), ("LeftHanded", Tag::Byte(0)), ( "Brain", @@ -216,6 +216,11 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.insert("Variant".into(), Tag::Int(v)); } map.insert("ChestedHorse".into(), Tag::Byte(i8::from(m.extra.chested))); + if m.extra.chested && !m.extra.items.is_empty() { + map.insert("Items".into(), crate::save::encode_items(&m.extra.items)); + } else { + map.remove(&"Items".into()); + } let mut equipment = Vec::new(); if m.extra.saddled { equipment.push(( @@ -257,6 +262,14 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { } map.insert("equipment".into(), Tag::Compound(equipment)); } + "minecraft:creaking" => { + // home_pos: the heart it is bound to. + if let Some(home) = m.extra.home { + map.insert("home_pos".into(), Tag::IntArray(home.to_vec())); + } else { + map.remove(&"home_pos".into()); + } + } "minecraft:villager" => { use crate::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; let data = Tag::compound([ @@ -283,6 +296,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.insert("RestocksToday".into(), Tag::Int(t.restocks_today)); put_offers(map, m); put_memories(map, m); + crate::mobs::villager::write_nbt(m, map); } "minecraft:wandering_trader" => put_offers(map, m), "minecraft:allay" => { @@ -374,6 +388,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { } _ => {} } + crate::mobs::raider::write_nbt(m, map); // LivingEntity equipment: what the mob holds now. if !crate::mobs::equine::is_equine(m.species()) { let mut equipment = match map.get(&"equipment".into()) { @@ -394,7 +409,22 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { equipment.get(&slot.into()).and_then(|e| e.get("id")), Some(Tag::String(s)) if s.to_string_lossy() == **id ); - if !keep { + if slot == "head" + && &**id == crate::mobs::raider::BANNER + && crate::mobs::raider::is_raider(m.species()) + { + // The captain's ominous banner keeps its patterns. + let has_patterns = equipment + .get(&slot.into()) + .and_then(|e| e.get("components")) + .is_some(); + if !has_patterns { + equipment.insert( + slot.into(), + crate::save::item_to_nbt(&crate::mobs::raider::ominous_banner()), + ); + } + } else if !keep { equipment.insert( slot.into(), Tag::compound([ @@ -457,6 +487,7 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - } m.death_time = number(tag.get("DeathTime")).unwrap_or(0) as i32; m.persistent = flag(tag, "PersistenceRequired"); + m.extra.pick_up_loot = flag(tag, "CanPickUpLoot"); m.custom_name = custom_name(tag); if m.kind.category == "creature" { m.extra.age = number(tag.get("Age")).unwrap_or(0) as i32; @@ -494,6 +525,9 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.extra.variant = (v & 0xFF).clamp(0, 6) as u8; m.extra.variant2 = ((v >> 8) & 0xFF).clamp(0, 4) as u8; m.extra.chested = flag(tag, "ChestedHorse"); + if m.extra.chested { + m.extra.items = crate::save::decode_items(tag.get("Items"), 15); + } let eq = tag.get("equipment"); m.extra.saddled = eq.and_then(|e| e.get("saddle")).is_some(); m.extra.head = eq @@ -577,6 +611,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.extra.egg_time = -1 - 400; } } + if m.species() == crate::mobs::Species::Creaking + && let Some(Tag::IntArray(home)) = tag.get("home_pos") + && home.len() == 3 + { + crate::mobs::creaking::set_transient(&mut m, [home[0], home[1], home[2]]); + } if m.species() == crate::mobs::Species::Wither { m.extra.counter = number(tag.get("Invul")).unwrap_or(0) as i32; } @@ -616,6 +656,7 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.health = health; m.extra.flag2 = flag(tag, "wasOnGround"); } + crate::mobs::raider::read_nbt(&mut m, tag); // A mob saved mid-death finishes dying; one saved dead is dropped. if m.health <= 0.0 && m.death_time == 0 { return None; @@ -1029,7 +1070,7 @@ fn put_offers(map: &mut Compound, m: &Mob) { } /// The villager brain's `job_site`, `home` and `meeting_point` memories. fn put_memories(map: &mut Compound, m: &Mob) { - let memories: Vec<(&str, Tag)> = [ + let mut memories: Vec<(&str, Tag)> = [ ("minecraft:job_site", m.extra.home), ("minecraft:home", m.extra.bed), ("minecraft:meeting_point", m.extra.meeting), @@ -1043,6 +1084,7 @@ fn put_memories(map: &mut Compound, m: &Mob) { Some((key, Tag::compound([("value", pos)]))) }) .collect(); + crate::mobs::villager::write_memories(m, &mut memories); map.insert( "Brain".into(), Tag::compound([("memories", Tag::compound(memories))]), @@ -1076,6 +1118,9 @@ fn read_villager(m: &mut Mob, tag: &Tag) { m.extra.home = memory("minecraft:job_site"); m.extra.bed = memory("minecraft:home"); m.extra.meeting = memory("minecraft:meeting_point"); + if m.species() == crate::mobs::Species::Villager { + crate::mobs::villager::read_nbt(m, tag); + } let Some(Tag::List(recipes)) = tag.get("Offers").and_then(|o| o.get("Recipes")) else { return; }; diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 82f369411..c86c68d1a 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4,6 +4,7 @@ mod advancements; mod advancements_screen; mod allays; mod armor_stands; +mod banners; mod beacon; mod blockctl; mod boats; @@ -14,8 +15,10 @@ mod chat; mod combat; mod commands; mod control; +mod creaking; mod creatures; mod crossbow; +mod dispenser; mod dragon; mod enchant_effects; mod end; @@ -27,12 +30,15 @@ mod fov; mod frames; mod functions; mod game_mode; +mod golems; mod growth; mod jukebox; mod lightning; +mod loom; mod machines; mod maps; mod minecarts; +mod mount_menu; mod mounts; mod music; mod names; @@ -44,6 +50,8 @@ mod perspective; mod piglins; mod postprocess; mod potions; +mod raids; +mod recipe_book; mod remote; mod render_control; mod render_tick; @@ -63,6 +71,7 @@ mod tnt; mod totem; mod trading; mod trident; +mod villagers; mod wither; use horizon_client::{ Result, @@ -309,6 +318,17 @@ impl LevelAccess for GameLevel<'_> { if let Some((_, comparator)) = jukebox::jukebox_signals(self.world, self.items, pos) { return comparator; } + if let Some(signal) = creaking::heart_signal(self.world, pos) { + return if self.registry.state(_state).is_some_and(|s| { + s.properties + .get("creaking_heart_state") + .is_some_and(|v| v == "uprooted") + }) { + 0 + } else { + signal + }; + } if let Some(signal) = books::lectern_signal(self.world, pos) { return signal; } @@ -521,6 +541,7 @@ struct Game<'a> { mobs: Vec, arrows: Vec, creatures: creatures::Creatures, + raiding: raids::Raiding, attack_ticks: u32, last_hurt_by_player: HashSet, chest_open: HashMap<(i32, i32, i32), (f32, f32)>, @@ -611,10 +632,17 @@ struct Game<'a> { ender_open: Option<(i32, i32, i32)>, /// Contents of broken shulker boxes waiting for their dropped item. pending_shulker: HashMap<[i32; 3], Vec<(u8, ItemStack)>>, + /// Layers of broken banners waiting for their dropped item. + pending_banner: HashMap<[i32; 3], horizon_client::containers::Banner>, + /// The recipe book of the open screen (game/recipe_book.rs). + recipe_ui: recipe_book::RecipeUi, + /// The horse inventory (game/mount_menu.rs). + mount_menu: mount_menu::MountMenu, /// The player's fishing hook. hook: Option, tridents: Vec, rockets: Vec, + creaking: creaking::CreakingState, trident_model: Option, tnts: Vec, hoppers: HashMap<(i32, i32, i32), machines::HopperState>, @@ -988,6 +1016,7 @@ impl Game<'_> { /// Block.popResource fn pop_resource(&mut self, pos: [i32; 3], mut stack: ItemStack) { self.attach_shulker_contents(pos, &mut stack); + self.attach_banner_layers(pos, &mut stack); let r = &mut self.world.random; let mut offset = || f64::from(r.next_float()) * 0.5 - 0.25; let p = [ @@ -1618,6 +1647,7 @@ impl Game<'_> { None } .unwrap_or(self.world.air); + self.creaking_heart_broken(pos); if let Some(entity) = self.world.block_entities.remove(&(pos[0], pos[1], pos[2])) { // Containers.dropContents (shulker boxes keep theirs). let name = facts.name.clone(); @@ -1819,6 +1849,7 @@ impl Game<'_> { .block_entities .insert((target[0], target[1], target[2]), entity); self.fill_placed_box(target, &stack); + self.fill_placed_banner(target, &stack); if sign { self.open_sign_editor((target[0], target[1], target[2]), true); } @@ -1841,6 +1872,7 @@ impl Game<'_> { self.stats.add("used", &stack.item, 1); self.trigger_block("minecraft:placed_block", target, &stack); self.check_wither_spawn(target)?; + self.check_golem_spawn(target)?; self.consume_held(); Ok(()) } @@ -2441,6 +2473,7 @@ impl Game<'_> { self.screen = Screen::Dead; self.capture(false); } + self.tick_omens(); self.tick_effects(); self.tick_burning(); self.tick_using(); @@ -2683,13 +2716,18 @@ impl Game<'_> { .map(|t| Icon::Flat(t.trim_start_matches("minecraft:").to_owned())) } fn draw_item(&mut self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) { - if &*stack.item == "minecraft:shield" { - shield::draw_shield_icon(batch, &self.res.atlas, x, y); - return; - } - let icon = self.icon(&stack.item); + // Special-model items: the shield and banners draw their own 3D icon. + let banner = if &*stack.item == "minecraft:shield" { + let passes = shield::shield_passes(&self.res.stations.banners, stack); + shield::draw_shield_icon(batch, &self.res.atlas, x, y, &passes); + true + } else { + self.draw_banner_icon(batch, stack, x, y) + }; + let icon = if banner { None } else { self.icon(&stack.item) }; let atlas = &self.res.atlas; match icon { + None if banner => {} Some(Icon::Flat(name)) => batch.sprite_scaled(atlas, &name, x, y, 16.0, 16.0, u32::MAX), Some(Icon::Cube { top, @@ -3050,7 +3088,7 @@ impl Game<'_> { } fn inventory_origin(&self, batch: &HudBatch) -> (f32, f32) { ( - (batch.width - 176.0) / 2.0, + (batch.width - 176.0) / 2.0 + self.recipe_book_shift(batch.width), (batch.height - self.screen_height()) / 2.0, ) } @@ -3061,19 +3099,22 @@ impl Game<'_> { } /// 300.. are the open container's slots. fn slots(&self) -> Vec { - if let Some(v) = self.station_slots() { + if let Some(v) = self.station_slots().or_else(|| self.mount_slots()) { return v; } let mut v: Vec = (0..36).collect(); match self.container_kind() { - Some(BlockEntity::Chest(items)) => v.extend((0..items.len()).map(|i| 300 + i)), + Some(BlockEntity::Chest(_)) => v.extend((0..self.container_size()).map(|i| 300 + i)), Some(BlockEntity::Furnace(_)) => v.extend(300..303), Some(BlockEntity::Brewing(_)) => v.extend(300..305), + Some(BlockEntity::Crafter(_)) => v.extend(300..310), Some( BlockEntity::Sign(_) | BlockEntity::Jukebox(_) | BlockEntity::Beacon(_) - | BlockEntity::Lectern(_), + | BlockEntity::Lectern(_) + | BlockEntity::Banner(_) + | BlockEntity::CreakingHeart(_), ) => {} None => { v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i)); @@ -3090,15 +3131,18 @@ impl Game<'_> { if let Some(p) = self .station_slot_position(i) .or_else(|| self.machine_slot_position(i)) + .or_else(|| self.crafter_slot_position(i)) + .or_else(|| self.mount_slot_position(i)) { return p; } let table = self.craft_size == 3; // ContainerScreen (3 rows) shifts the player inventory down by one pixel. - let shift = if matches!(self.container_kind(), Some(BlockEntity::Chest(_))) { - 1.0 - } else { - 0.0 + // ChestMenu: the inventory sits `18 * (rows - 3) + 1` lower than the + // 3-row layout of the other menus. + let shift = match self.chest_rows() { + Some(rows) => 1.0 + (rows as f32 - 3.0) * 18.0, + None => 0.0, }; match i { 0..9 => (8.0 + i as f32 * 18.0, 142.0 + shift), @@ -3144,6 +3188,9 @@ impl Game<'_> { }) } fn slot_mut(&mut self, i: usize) -> &mut Option { + if i >= mount_menu::SADDLE { + return self.mount_slot_mut(i); + } if i >= stations::INPUT { return self.station_slot_mut(i); } @@ -3154,14 +3201,7 @@ impl Game<'_> { return &mut self.offhand; } if i >= 300 { - let key = self.container; - return match key.and_then(|k| self.world.block_entities.get_mut(&k)) { - Some(e) => e - .slots_mut() - .get_mut(i - 300) - .unwrap_or(&mut self.scratch_slot), - None => &mut self.scratch_slot, - }; + return self.container_slot_mut(i - 300); } if (100..109).contains(&i) { &mut self.craft_grid[i - 100] @@ -3169,6 +3209,14 @@ impl Game<'_> { &mut self.inventory[i] } } + /// What a slot shows: the crafting result slots are computed. + fn slot_view(&mut self, i: usize) -> Option { + match i { + 200 => self.craft_result(), + 309 => self.crafter_result(), + _ => self.slot_mut(i).clone(), + } + } fn craft_result(&self) -> Option { let n = self.craft_size; let grid: Vec> = (0..n * n).map(|i| self.craft_grid[i].clone()).collect(); @@ -3212,42 +3260,7 @@ impl Game<'_> { .and_then(|k| self.world.block_entities.get(&k)) { Some(BlockEntity::Chest(_)) if self.draw_machine_screen(batch, ox, oy) => {} - Some(BlockEntity::Chest(_)) => { - // ContainerScreen with 3 rows: top 71px, then the player inventory from v=126. - part( - batch, - "gui/container/generic_54", - 0.0, - 0.0, - 176.0, - 71.0, - ox, - oy, - ); - part( - batch, - "gui/container/generic_54", - 0.0, - 126.0, - 176.0, - 96.0, - ox, - oy + 71.0, - ); - let name = self - .container - .map(|k| self.world.block(k.0, k.1, k.2)) - .map(|s| self.res.facts.get(s).name.clone()); - let title = if self.open_cart_kind().is_some() { - "Minecart with Chest" - } else if name.as_deref() == Some("minecraft:barrel") { - "Barrel" - } else { - "Chest" - }; - batch.text(atlas, title, ox + 8.0, oy + 6.0, grey, false); - batch.text(atlas, "Inventory", ox + 8.0, oy + 73.0, grey, false); - } + Some(BlockEntity::Chest(_)) => self.draw_chest_screen(batch, ox, oy), Some(BlockEntity::Furnace(f)) => { let (tex, title) = match f.kind { horizon_client::containers::FurnaceKind::Furnace => { @@ -3294,12 +3307,16 @@ impl Game<'_> { } } Some(BlockEntity::Brewing(_)) => {} + Some(BlockEntity::Crafter(_)) => self.draw_crafter_screen(batch, ox, oy), Some( BlockEntity::Sign(_) | BlockEntity::Jukebox(_) | BlockEntity::Beacon(_) - | BlockEntity::Lectern(_), + | BlockEntity::Lectern(_) + | BlockEntity::Banner(_) + | BlockEntity::CreakingHeart(_), ) => {} + None if self.mount_active() => self.draw_mount_background(batch, ox, oy), None => { let texture = if self.craft_size == 3 { "gui/container/crafting_table" @@ -3326,7 +3343,7 @@ impl Game<'_> { } } } - if self.container.is_none() && self.craft_size != 3 { + if self.container.is_none() && self.craft_size != 3 && !self.mount_active() { self.draw_inventory_player(batch, ox, oy); } for i in self.slots() { @@ -3348,15 +3365,12 @@ impl Game<'_> { oy + sy, ); } - let stack = if i == 200 { - self.craft_result() - } else { - self.slot_mut(i).clone() - }; + let stack = self.slot_view(i); if let Some(stack) = stack { self.draw_item(batch, &stack, ox + sx, oy + sy); } } + self.draw_recipe_book(batch); if let Some(slot) = self.slot_at(batch, self.cursor.0, self.cursor.1) { let (sx, sy) = self.slot_position(slot); batch.fill( @@ -3375,6 +3389,8 @@ impl Game<'_> { } pub(super) fn close_container(&mut self) { self.close_station(); + self.mount_closed(); + self.recipe_ui.reset_screen(); if self.remote.is_some() { return self.remote_close_container(); } @@ -3424,6 +3440,12 @@ impl Game<'_> { self.close_cart_container(); } fn click_inventory(&mut self, right: bool) { + if self.mount_click(right) { + return; + } + if self.recipe_book_click(right) { + return; + } if self.station_click(right) { return; } @@ -3441,6 +3463,17 @@ impl Game<'_> { let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else { return; }; + let held_shift = + self.keys.contains(&KeyCode::ShiftLeft) || self.keys.contains(&KeyCode::ShiftRight); + if self.crafter_click(slot, held_shift) { + return; + } + if held_shift && self.container.is_some() && self.container_quick_move(slot) { + if let Some(key) = self.container { + self.world.modified.insert((key.0 >> 4, key.2 >> 4)); + } + return; + } if let Some(c) = &self.carried && self.refuses(slot, c) { @@ -3486,6 +3519,12 @@ impl Game<'_> { let mut crafted = 0; while let Some(result) = self.craft_result() { let made = (result.item.clone(), result.count); + let cells = self.craft_size * self.craft_size; + let remainders = self.res.recipes.remainders( + &self.res.items, + &self.craft_grid[..cells], + &result, + ); if shift { if self.give(result).is_some() { break; @@ -3510,6 +3549,14 @@ impl Game<'_> { } } } + for (i, rest) in remainders.into_iter().enumerate() { + let Some(rest) = rest else { continue }; + match &mut self.craft_grid[i] { + cell @ None => *cell = Some(rest), + Some(c) if c.same_item_same_components(&rest) => c.count += rest.count, + _ => self.give_or_drop(rest), + } + } crafted += 1; self.stats.add("crafted", &made.0, made.1 as i32); if !shift || crafted >= 64 { @@ -3900,6 +3947,7 @@ impl Game<'_> { Some(BlockEntity::Sign(sign)) => Some(sign), _ => None, }, + banner: &|p| self.banner_layers_at(p), glyph: &|c| self.res.atlas.glyph(c), }; self.res @@ -4340,8 +4388,11 @@ impl Game<'_> { } fn tick_block_entities(&mut self) -> Result<()> { self.tick_hoppers()?; + self.tick_crafters(); + self.tick_mount_menu(); self.tick_jukeboxes(); self.tick_beacons(); + self.tick_creaking_hearts()?; // ChestLidController: 0.1 per tick towards open/closed. if let Some(key) = self.container { self.chest_open.entry(key).or_insert((0.0, 0.0)); @@ -5803,6 +5854,10 @@ impl Game<'_> { } first(&d["model"]) }); + if item.ends_with("_banner") { + // The banner item model is a special renderer over this base model. + current = Some("minecraft:item/template_banner".to_owned()); + } for _ in 0..16 { let Some(m) = current.take() else { break }; let path = m.trim_start_matches("minecraft:").to_owned(); @@ -5949,6 +6004,9 @@ impl Game<'_> { * glam::Mat4::from_quat(glam::Quat::from_euler(glam::EulerRot::XYZ, deg(rot[0]), deg(rot[1]), deg(rot[2]))) * glam::Mat4::from_scale(glam::Vec3::from(scale)) * glam::Mat4::from_translation(glam::Vec3::splat(-0.5)); + if self.held_banner_geometry(m, &stack, packed, &mut out) { + return out; + } let atlas = &self.res.atlas; let quad = |corners: [glam::Vec3; 4], name: &str, @@ -6589,6 +6647,7 @@ impl Game<'_> { self.ender_items = items.clone(); } level.ender_items = self.ender_items.clone(); + level.recipe_book.recipes = self.adv.recipes.iter().cloned().collect(); level.active_effects = self .potions .effects @@ -6619,6 +6678,7 @@ impl Game<'_> { .save(&chunks, self.res.assets.registry, &self.res.biomes)?; self.save_entities()?; self.save_maps(); + self.save_raids(); self.save_fight(); self.save_stats(); self.save_advancements(); @@ -6845,6 +6905,7 @@ impl Game<'_> { Screen::Advancements => self.close_advancements(), Screen::Chat => self.close_chat(), }, + KeyCode::KeyT if self.screen == Screen::Inventory => self.recipe_focus_search(), KeyCode::KeyT if self.screen == Screen::Playing => self.open_chat(""), // key.advancements. KeyCode::KeyL if self.screen == Screen::Playing => self.open_advancements(false), @@ -6859,12 +6920,15 @@ impl Game<'_> { KeyCode::KeyE => match self.screen { Screen::Playing if self.spectator() => {} Screen::Playing => { - self.screen = if self.creative { - Screen::Creative - } else { - Screen::Inventory - }; - self.capture(false); + // key.inventory while riding a tamed mount opens its inventory. + if !self.open_ridden_mount_menu() { + self.screen = if self.creative { + Screen::Creative + } else { + Screen::Inventory + }; + self.capture(false); + } } Screen::Creative => { if let Some(c) = self.carried.take() { @@ -7083,6 +7147,9 @@ impl ApplicationHandler for Game<'_> { if self.screen == Screen::Advancements { self.advancements_drag(); } + if self.screen == Screen::Inventory { + self.loom_drag(); + } if self.dragging && self.screen == Screen::Options { let _ = b; self.options_drag()?; @@ -7214,6 +7281,7 @@ impl ApplicationHandler for Game<'_> { self.container_changed(key); } } + Screen::Inventory => self.loom_release(), Screen::Chat if pressed && button == MouseButton::Left => self.chat_click(), Screen::Creative if pressed => { self.click_creative(button == MouseButton::Right); @@ -7275,6 +7343,14 @@ impl ApplicationHandler for Game<'_> { } self.creative_screen.scroll = 0.0; } + WindowEvent::KeyboardInput { event, .. } + if self.recipe_search_focused() + && event.state == ElementState::Pressed + && !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) => + { + // The recipe book's search box takes every key but Escape. + self.recipe_key(&event); + } WindowEvent::KeyboardInput { event, .. } if self.station_typing() && event.state == ElementState::Pressed @@ -7649,6 +7725,7 @@ pub fn run() -> Result<()> { mobs: Vec::new(), arrows: Vec::new(), creatures: Default::default(), + raiding: Default::default(), attack_ticks: 100, last_hurt_by_player: HashSet::new(), chest_open: HashMap::new(), @@ -7717,9 +7794,13 @@ pub fn run() -> Result<()> { ender_items: vec![None; 27], ender_open: None, pending_shulker: HashMap::new(), + pending_banner: HashMap::new(), + recipe_ui: Default::default(), + mount_menu: Default::default(), hook: None, tridents: Vec::new(), rockets: Vec::new(), + creaking: Default::default(), trident_model: horizon_client::mobs::load_model(&root, "minecraft:trident#main"), tnts: Vec::new(), hoppers: HashMap::new(), diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 26606e39f..6742e7043 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -20,6 +20,26 @@ pub(super) struct Toast { frame: Frame, title: Text, shown: Option, + /// A `RecipeToast`: the icon is a recipe result. + recipe: bool, +} +impl Toast { + pub(super) fn is_recipe(&self) -> bool { + self.recipe + } + pub(super) fn was_shown(&self) -> bool { + self.shown.is_some() + } + /// `RecipeToast`: "New Recipe(s) Unlocked!" with the recipe's result. + pub(super) fn recipe(icon: &str) -> Self { + Self { + icon: icon.to_owned(), + frame: Frame::Task, + title: Text::literal(""), + shown: None, + recipe: true, + } + } } #[derive(Default)] pub(super) struct AdvState { @@ -27,7 +47,7 @@ pub(super) struct AdvState { pub(super) progress: Progress, loaded: bool, pub(super) recipes: BTreeSet, - toasts: VecDeque, + pub(super) toasts: VecDeque, /// Awards skip the toast (`/advancement grant ... everything`). pub(super) quiet: bool, /// The inventory last seen by `inventory_changed`. @@ -297,12 +317,26 @@ impl Game<'_> { } } pub(super) fn mob_entity(&self, m: &horizon_client::mobs::Mob) -> EntityView { + // mainhand, offhand, head, chest, legs, feet. + let slot = |i: &Option>| { + i.as_ref().map(|id| item_view(&ItemStack::new(id, 1))) + }; + let mut equipment: [Option; 7] = Default::default(); + if !horizon_client::mobs::equine::is_equine(m.species()) { + equipment[0] = slot(&m.extra.main_hand); + equipment[1] = slot(&m.extra.off_hand); + equipment[2] = slot(&m.extra.head); + equipment[3] = slot(&m.extra.chest); + equipment[4] = slot(&m.extra.legs); + equipment[5] = slot(&m.extra.feet); + } EntityView { kind: m.kind.id.clone(), position: [m.position.x, m.position.y, m.position.z], on_fire: m.fire_ticks > 0, baby: m.is_baby(), on_ground: m.on_ground, + equipment, ..Default::default() } } @@ -375,6 +409,7 @@ impl Game<'_> { frame: d.frame, title: text_of(&d.title), shown: None, + recipe: false, }); } if d.announce && self.ui.rules.bool("show_advancement_messages") { @@ -390,6 +425,7 @@ impl Game<'_> { )); } } + self.recipe_toast(&unlocked); for r in unlocked { self.trigger("minecraft:recipe_unlocked", |c, _| { c["recipes"].as_str() == Some(r.as_str()) @@ -612,7 +648,20 @@ impl Game<'_> { } else { 1.0 }; - let (title, frame, icon) = (t.title.clone(), t.frame, t.icon.clone()); + let (title, frame, icon, recipe) = (t.title.clone(), t.frame, t.icon.clone(), t.recipe); + if recipe { + // RecipeToast: black description under a purple title. + let atlas = &self.res.atlas; + let x = batch.width - 160.0 * slide; + batch.sprite(atlas, "gui/sprites/toast/recipe", x, 0.0); + let title = self.translate("recipe.toast.title", "New Recipe(s) Unlocked!"); + let description = self.translate("recipe.toast.description", "Check your recipe book"); + let atlas = &self.res.atlas; + batch.text(atlas, &title, x + 30.0, 7.0, 0xFF50_0050, false); + batch.text(atlas, &description, x + 30.0, 18.0, 0xFF00_0000, false); + self.draw_item(batch, &ItemStack::new(&icon, 1), x + 8.0, 8.0); + return; + } if frame == Frame::Challenge && ms < 50.0 { self.audio .play("minecraft:ui.toast.challenge_complete", None, 1.0, 1.0); diff --git a/crates/horizon-client/src/game/banners.rs b/crates/horizon-client/src/game/banners.rs new file mode 100644 index 000000000..b9f701a0c --- /dev/null +++ b/crates/horizon-client/src/game/banners.rs @@ -0,0 +1,222 @@ +//! Placed banners (`BannerBlockEntity`): the pattern layers move from the +//! banner item to the block when placed and back to the dropped item when +//! broken (`copy_components` in the banner loot tables). +use super::Game; +use glam::{EulerRot, Mat4, Quat, Vec3}; +use horizon_client::{ + banner::{self, BannerLayer}, + block_entity_render::{Paint, draw_part}, + containers::{Banner, BlockEntity}, + hud::{HudBatch, rgba}, + items::ItemStack, + mesher::Vertex, +}; + +impl Game<'_> { + /// The pattern textures and tints of the banner at `pos`, bottom first. + pub(super) fn banner_layers_at(&self, pos: [i32; 3]) -> Vec<(String, u32)> { + let Some(BlockEntity::Banner(b)) = self.world.block_entities.get(&(pos[0], pos[1], pos[2])) + else { + return Vec::new(); + }; + layer_textures(&self.res.stations.banners, &b.layers) + } + /// A placed banner takes the item's layers and name. + pub(super) fn fill_placed_banner(&mut self, pos: [i32; 3], stack: &ItemStack) { + self.pending_banner.remove(&pos); + if !stack.item.ends_with("_banner") { + return; + } + if let Some(BlockEntity::Banner(b)) = + self.world.block_entities.get_mut(&(pos[0], pos[1], pos[2])) + { + b.layers = banner::layers(stack).to_vec(); + b.name = stack.custom_name().map(str::to_owned); + } + } + /// A banner in a slot: `item/template_banner`'s `gui` transform on the + /// banner model (pole, bar and flag with every layer), flat-lit and + /// depth-sorted. False when the stack is not a banner. + pub(super) fn draw_banner_icon( + &self, + batch: &mut HudBatch, + stack: &ItemStack, + x: f32, + y: f32, + ) -> bool { + let Some(base) = banner::banner_color(&stack.item) else { + return false; + }; + let Some((main, flag)) = self.res.block_entity_render.banner_models() else { + return true; + }; + let banners = &self.res.stations.banners; + let sprites = &self.res.atlas.sprites; + // display.gui, then the item's special transformation (a banner is + // modelled upside down and 2/3 size around the block centre). + let m = Mat4::from_translation(Vec3::new(0.0, -3.25 / 16.0, 0.0)) + * Mat4::from_quat(Quat::from_euler( + EulerRot::XYZ, + 30f32.to_radians(), + 20f32.to_radians(), + 0.0, + )) + * Mat4::from_scale(Vec3::splat(0.5325)) + * Mat4::from_translation(Vec3::new(0.0, -0.5, 0.0)) + * Mat4::from_scale(Vec3::new(2.0 / 3.0, -2.0 / 3.0, -2.0 / 3.0)); + let wave = |name: &str, p: &mut [f32; 9]| { + if name == "flag" { + p[3] = (-0.0125 + 0.01) * std::f32::consts::PI; + } + }; + let none = |_: &str, _: &mut [f32; 9]| {}; + let mut passes: Vec<(&str, u32, bool, String)> = vec![ + ("entity/banner/banner_base", 0xFFFFFF, true, String::new()), + ( + "entity/banner/base", + banner::dye_rgb(base), + false, + String::new(), + ), + ]; + for layer in banner::layers(stack).iter().take(16) { + passes.push(( + "", + banner::dye_rgb(&layer.color), + false, + banners.banner_texture(&layer.pattern), + )); + } + // (depth, pass, screen corners, uv, colour) + let mut faces: Vec<(f32, usize, [[f32; 2]; 4], [[f32; 2]; 4], u32)> = Vec::new(); + for (index, (fixed, tint, with_pole, dynamic)) in passes.iter().enumerate() { + let name = if fixed.is_empty() { + dynamic.as_str() + } else { + fixed + }; + let Some(sprite) = sprites.get(name).copied() else { + continue; + }; + let paint = Paint { + sprite, + tint: 0xFFFFFF, + light: 0, + lights: (Vec3::ZERO, Vec3::ZERO), + }; + let mut verts: Vec = Vec::new(); + if *with_pole { + draw_part(main, "root", m, &none, paint, &mut verts); + } + draw_part(flag, "root", m, &wave, paint, &mut verts); + for quad in verts.as_chunks::<4>().0 { + let p = |i: usize| Vec3::from(quad[i].pos); + let normal = (p(1) - p(0)).cross(p(2) - p(0)).normalize_or_zero(); + // Faces turned away from the viewer are culled. + if normal.z <= 0.0 { + continue; + } + let depth = (0..4).map(|i| p(i).z).sum::() / 4.0; + let shade = (0.6 + 0.4 * normal.z).min(1.0); + let c = |s: u32| (((tint >> s) & 255) as f32 * shade) as u8; + faces.push(( + depth, + index, + std::array::from_fn(|i| { + [ + x + 8.0 + quad[i].pos[0] * 16.0, + y + 8.0 - quad[i].pos[1] * 16.0, + ] + }), + std::array::from_fn(|i| quad[i].uv), + rgba(c(16), c(8), c(0), 255), + )); + } + } + faces.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.1.cmp(&b.1))); + for (_, _, corners, uv, color) in faces { + batch.quad(corners, uv, color); + } + true + } + /// A banner in the first-person hand: the standing banner model under the + /// item's `firstperson_righthand` transform (`m`) and its special + /// transformation. False when the stack is not a banner. + pub(super) fn held_banner_geometry( + &self, + m: Mat4, + stack: &ItemStack, + packed: u32, + out: &mut Vec, + ) -> bool { + let Some(base) = banner::banner_color(&stack.item) else { + return false; + }; + let Some((main, flag)) = self.res.block_entity_render.banner_models() else { + return true; + }; + let m = m + * Mat4::from_translation(Vec3::new(0.5, 0.0, 0.5)) + * Mat4::from_scale(Vec3::new(2.0 / 3.0, -2.0 / 3.0, -2.0 / 3.0)); + let wave = |name: &str, p: &mut [f32; 9]| { + if name == "flag" { + p[3] = (-0.0125 + 0.01) * std::f32::consts::PI; + } + }; + let none = |_: &str, _: &mut [f32; 9]| {}; + let lights = horizon_client::block_entity_render::diffuse_lights(false); + let sprites = &self.res.atlas.sprites; + let paint = |name: &str, tint: u32| { + sprites.get(name).map(|&sprite| Paint { + sprite, + tint, + light: packed, + lights, + }) + }; + if let Some(p) = paint("entity/banner/banner_base", 0xFFFFFF) { + draw_part(main, "root", m, &none, p, out); + draw_part(flag, "root", m, &wave, p, out); + } + if let Some(p) = paint("entity/banner/base", banner::dye_rgb(base)) { + draw_part(flag, "root", m, &wave, p, out); + } + for layer in banner::layers(stack).iter().take(16) { + let texture = self.res.stations.banners.banner_texture(&layer.pattern); + if let Some(p) = paint(&texture, banner::dye_rgb(&layer.color)) { + draw_part(flag, "root", m, &wave, p, out); + } + } + true + } + /// The layers a banner dropped at `pos` carries. + pub(super) fn attach_banner_layers(&mut self, pos: [i32; 3], stack: &mut ItemStack) { + if !stack.item.ends_with("_banner") { + return; + } + if let Some(Banner { layers, name }) = self.pending_banner.remove(&pos) { + let data = stack.data_mut(); + data.banner_patterns = layers; + if name.is_some() { + data.custom_name = name; + } + stack.tidy(); + } + } +} + +/// Texture names and tints of banner layers (`Sheets.getBannerSprite`). +pub(super) fn layer_textures( + banners: &banner::Banners, + layers: &[BannerLayer], +) -> Vec<(String, u32)> { + layers + .iter() + .map(|l| { + ( + banners.banner_texture(&l.pattern), + banner::dye_rgb(&l.color), + ) + }) + .collect() +} diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 1984572f4..89cd02999 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -6,6 +6,7 @@ pub(super) mod execute; mod items; mod misc; mod place; +mod raid; mod terrain_cmds; mod text_commands; mod world_cmds; @@ -496,6 +497,7 @@ impl Game<'_> { | "teleport.targets.location" | "teleport.targets.destination" => self.cmd_teleport(id, ctx), id if id.starts_with("time.") => self.cmd_time(id, ctx), + id if id.starts_with("raid.") => self.cmd_raid(id, ctx), "weather" => self.cmd_weather(ctx), "kill" => self.cmd_kill(ctx), "summon" => self.cmd_summon(ctx), diff --git a/crates/horizon-client/src/game/commands/raid.rs b/crates/horizon-client/src/game/commands/raid.rs new file mode 100644 index 000000000..762ae7e90 --- /dev/null +++ b/crates/horizon-client/src/game/commands/raid.rs @@ -0,0 +1,108 @@ +//! `RaidCommand`: `/raid start|stop|check|spawnleader|setomen|glow|sound`. +use super::{Game, R, Text, err}; +use horizon_client::{command::Context, mobs::raider}; + +impl Game<'_> { + pub(in crate::game) fn cmd_raid(&mut self, id: &str, ctx: &Context) -> R { + let Some(player) = self.player.as_ref().map(|p| p.position) else { + return Ok(0); + }; + let at = [ + player.x.floor() as i32, + player.y.floor() as i32, + player.z.floor() as i32, + ]; + let fail = |game: &mut Self, message: &str| { + game.command_failure(Text::literal(message)); + }; + match id { + "raid.start" => { + if self.raiding_nearby(at).is_some() { + fail(self, "Raid already started close by"); + return Ok(-1); + } + let level = Self::int(ctx, "omenlvl").unwrap_or(0); + match self.raid_command_create(at, level) { + true => self.feedback(Text::literal("Created a raid in your local village")), + false => fail(self, "Failed to create a raid in your local village"), + } + Ok(1) + } + "raid.stop" => match self.raiding_nearby(at) { + Some(raid) => { + self.raid_command_stop(raid); + self.feedback(Text::literal("Stopped raid")); + Ok(1) + } + None => { + fail(self, "No raid here"); + Ok(-1) + } + }, + "raid.check" => match self.raiding_nearby(at).filter(|id| self.raid_started(*id)) { + Some(raid) => { + self.feedback(Text::literal("Found a started raid!")); + let status = self.raid_status_text(raid); + self.feedback(Text::literal(&status)); + Ok(1) + } + None => { + fail(self, "Found no started raids"); + Ok(0) + } + }, + "raid.spawnleader" => { + let kind = "minecraft:pillager"; + match self.spawn_mob_for(kind, [player.x, player.y, player.z], true, true) { + Some(id) => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + raider::set_patrol_leader(m, true); + raider::finalize(m, raider::Reason::Other); + } + self.feedback(Text::literal("Spawned a raid captain")); + Ok(1) + } + None => { + fail(self, "Pillager failed to spawn"); + Ok(0) + } + } + } + "raid.setomen" => { + let level = Self::int(ctx, "level").unwrap_or(0); + let Some(raid) = self.raiding_nearby(at) else { + fail(self, "No raid found here"); + return Ok(1); + }; + if level > horizon_client::raid::MAX_OMEN_LEVEL { + fail( + self, + &format!( + "Sorry, the max raid omen level you can set is {}", + horizon_client::raid::MAX_OMEN_LEVEL + ), + ); + } else { + let before = self.raid_set_omen(raid, level); + self.feedback(Text::literal(format!( + "Changed village's raid omen level from {before} to {level}" + ))); + } + Ok(1) + } + "raid.glow" => { + if let Some(raid) = self.raiding_nearby(at) { + self.raid_glow(raid); + } + Ok(1) + } + "raid.sound" => { + let at = [player.x + 5.0, player.y, player.z]; + self.audio + .play("minecraft:event.raid.horn", Some(at), 1.0, 1.0); + Ok(1) + } + _ => Err(err("commands.help.failed", &[])), + } + } +} diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index 7c07af665..18d0e6b64 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -293,6 +293,9 @@ impl Game<'_> { match self.screen { Screen::Chat => self.chat_type(text), Screen::Options => self.ui.options.type_text(text), + Screen::Inventory if self.recipe_search_focused() => { + self.recipe_text(Some(text), false) + } _ => { return Err( "type needs the chat screen (key t tap) or the language search".into(), diff --git a/crates/horizon-client/src/game/creaking.rs b/crates/horizon-client/src/game/creaking.rs new file mode 100644 index 000000000..98727ba8b --- /dev/null +++ b/crates/horizon-client/src/game/creaking.rs @@ -0,0 +1,663 @@ +//! The creaking heart block entity (`CreakingHeartBlockEntity`): at night an +//! awake heart in a pale oak trunk spawns a creaking that protects it, +//! hurting the creaking makes the heart emit trails and spread resin over +//! the logs, and breaking the heart tears the creaking down. +use super::Game; +use horizon_client::{ + Result, + containers::{BlockEntity, CreakingHeart}, + mobs::creaking, + particles::{ParticleOptions, ParticleType}, +}; +use horizon_core::{geometry::Aabb, position::BlockPos, random::RandomSource}; +use horizon_world::registry::BlockStateId; +use std::collections::{HashSet, VecDeque}; + +type Pos = (i32, i32, i32); + +/// `Creaking.CREAKING_ORANGE` and `CREAKING_GRAY`. +const ORANGE: u32 = 16_545_810; +const GRAY: u32 = 6_250_335; +/// `CreakingHeartBlockEntity.DISTANCE_CREAKING_TOO_FAR`. +const TOO_FAR: f64 = 34.0; + +/// `Direction.values()`: down, up, north, south, west, east. +const DIRECTIONS: [[i32; 3]; 6] = [ + [0, -1, 0], + [0, 1, 0], + [0, 0, -1], + [0, 0, 1], + [-1, 0, 0], + [1, 0, 0], +]; +const FACE_NAMES: [&str; 6] = ["down", "up", "north", "south", "west", "east"]; + +/// Comparator input of a heart (`getAnalogOutputSignal`). +pub(super) fn heart_signal(world: &horizon_client::world::World, pos: BlockPos) -> Option { + match world.block_entities.get(&(pos.x, pos.y, pos.z))? { + BlockEntity::CreakingHeart(h) => Some(h.output_signal), + _ => None, + } +} + +impl Game<'_> { + fn heart_state_name(&self, state: BlockStateId) -> String { + self.res + .assets + .registry + .state(state) + .and_then(|s| s.properties.get("creaking_heart_state").cloned()) + .unwrap_or_default() + } + /// `Util.shuffledCopy(Direction.values(), random)`. + fn shuffled_directions(&mut self) -> [usize; 6] { + let mut order = [0, 1, 2, 3, 4, 5]; + for i in (2..=6).rev() { + let j = self.world.random.next_int_bound(i as i32).unwrap_or(0) as usize; + order.swap(i - 1, j); + } + order + } + fn is_pale_oak_log(&self, p: Pos) -> bool { + let name = &self.res.facts.get(self.world.block(p.0, p.1, p.2)).name; + self.res + .items + .block_tags + .get("minecraft:pale_oak_logs") + .is_some_and(|s| s.contains(&**name)) + } + fn mob_center(&self, id: u32) -> Option<([f64; 3], Aabb)> { + let m = self.mobs.iter().find(|m| m.id == id && !m.removed)?; + Some((m.center(), m.bounds())) + } + /// The protector's entity, resolving a UUID read from a save. + fn heart_protector(&mut self, heart: &mut CreakingHeart) -> Option { + let (id, uuid) = heart.creaking?; + if let Some(id) = id { + if self.mobs.iter().any(|m| m.id == id && !m.removed) { + return Some(id); + } + // The entity is gone: remember it by UUID until it reappears. + heart.creaking = Some((None, uuid)); + } + if let Some(id) = self.mob_id_for_uuid(uuid) { + heart.creaking = Some((Some(id), uuid)); + return Some(id); + } + if heart.ticks_existed >= 30 { + heart.creaking = None; + } + None + } + /// `CreakingHeartBlockEntity.removeProtector`: the creaking falls apart. + fn heart_remove_protector(&mut self, heart: &mut CreakingHeart, by_player: bool) { + let Some(id) = self.heart_protector(heart) else { + return; + }; + if by_player { + // creakingDeathEffects: a twitching death. + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + creaking::set_tearing_down(m); + m.health = 0.0; + m.death_time = m.death_time.max(0); + let at = m.center(); + self.audio + .play("minecraft:entity.creaking.twitch", Some(at), 1.0, 1.0); + } + } else if let Some(i) = self.mobs.iter().position(|m| m.id == id) { + let mut events = Vec::new(); + creaking::tear_down(&mut self.mobs[i], &mut events); + let _ = self.handle_mob_events(events); + } + heart.creaking = None; + } + fn heart_distance_to_creaking(&self, id: u32, pos: Pos) -> f64 { + self.mob_center(id).map_or(0.0, |_| { + let m = self.mobs.iter().find(|m| m.id == id).unwrap(); + let at = ( + f64::from(pos.0) + 0.5, + f64::from(pos.1), + f64::from(pos.2) + 0.5, + ); + ((m.position.x - at.0).powi(2) + + (m.position.y - at.1).powi(2) + + (m.position.z - at.2).powi(2)) + .sqrt() + }) + } + /// `emitParticles`: trails between the creaking and the heart. + fn heart_emit(&mut self, heart: &mut CreakingHeart, pos: Pos, count: i32, towards: bool) { + let Some(id) = self.heart_protector(heart) else { + return; + }; + let Some((_, b)) = self.mob_center(id) else { + return; + }; + let (lo, hi) = (b.min_position(), b.max_position()); + for _ in 0..count { + let r = &mut self.world.random; + let mut source = [ + lo.x + r.next_double() * (hi.x - lo.x), + lo.y + r.next_double() * (hi.y - lo.y), + lo.z + r.next_double() * (hi.z - lo.z), + ]; + let mut destination = [ + f64::from(pos.0) + r.next_double(), + f64::from(pos.1) + r.next_double(), + f64::from(pos.2) + r.next_double(), + ]; + if towards { + std::mem::swap(&mut source, &mut destination); + } + let duration = r.next_int_bound(40).unwrap_or(0) + 10; + let color = if towards { ORANGE } else { GRAY }; + self.particles.add( + &ParticleOptions::trail(destination, color, duration), + source, + [0.0; 3], + ); + } + } + /// `CreakingHeartBlockEntity.spreadResin`: a resin clump on the first log + /// face found within two steps of pale oak logs. + fn heart_spread_resin(&mut self, pos: Pos) -> Option { + let mut visited: HashSet = HashSet::new(); + let mut queue: VecDeque<(Pos, i32)> = VecDeque::new(); + queue.push_back((pos, 0)); + let mut count = 0; + while let Some((current, depth)) = queue.pop_front() { + if !visited.insert(current) { + continue; + } + // The node processor. + if self.is_pale_oak_log(current) { + for d in self.shuffled_directions() { + let n = ( + current.0 + DIRECTIONS[d][0], + current.1 + DIRECTIONS[d][1], + current.2 + DIRECTIONS[d][2], + ); + let neighbour = self.world.block(n.0, n.1, n.2); + let opposite = d ^ 1; + let clump = self.resin_clump_for(neighbour); + let Some(clump) = clump else { continue }; + if self.prop_is(clump, FACE_NAMES[opposite]) { + continue; + } + let Some(placed) = self.with_face(clump, FACE_NAMES[opposite]) else { + continue; + }; + let _ = self.level_set([n.0, n.1, n.2], placed); + return Some(n); + } + } + count += 1; + if count >= 64 { + return None; + } + if depth < 2 { + // The neighbour provider: adjacent pale oak logs. + for d in self.shuffled_directions() { + let n = ( + current.0 + DIRECTIONS[d][0], + current.1 + DIRECTIONS[d][1], + current.2 + DIRECTIONS[d][2], + ); + if self.is_pale_oak_log(n) { + queue.push_back((n, depth + 1)); + } + } + } + } + None + } + /// The state a face of resin can be added to: air, a source of water, or + /// a clump already there. + fn resin_clump_for(&self, neighbour: BlockStateId) -> Option { + let registry = self.res.assets.registry; + let clump = registry.default_state("minecraft:resin_clump")?; + let facts = self.res.facts.get(neighbour); + if self.res.facts.is_air(neighbour) { + Some(clump) + } else if &*facts.name == "minecraft:water" + && facts.fluid_level == 8 + && !facts.fluid_falling + { + let mut s = registry.state(clump)?.clone(); + s.properties.insert("waterlogged".into(), "true".into()); + registry.resolve(&s).ok() + } else if &*facts.name == "minecraft:resin_clump" { + Some(neighbour) + } else { + None + } + } + fn prop_is(&self, state: BlockStateId, key: &str) -> bool { + self.res + .assets + .registry + .state(state) + .and_then(|s| s.properties.get(key)) + .is_some_and(|v| v == "true") + } + fn with_face(&self, state: BlockStateId, face: &str) -> Option { + let mut s = self.res.assets.registry.state(state)?.clone(); + s.properties.insert(face.to_owned(), "true".to_owned()); + self.res.assets.registry.resolve(&s).ok() + } + /// A creaking bound to the heart at `home` was hurt (`creakingHurt`). + pub(super) fn creaking_hurt(&mut self, home: [i32; 3], id: u32, by_player: bool) { + if !by_player { + return; + } + let key = (home[0], home[1], home[2]); + let Some(BlockEntity::CreakingHeart(mut heart)) = self.world.block_entities.remove(&key) + else { + return; + }; + if self.heart_protector(&mut heart) == Some(id) && heart.emitter <= 0 { + self.heart_emit(&mut heart, key, 20, false); + let state = self.world.block(key.0, key.1, key.2); + if self.heart_state_name(state) == "awake" { + let clumps = 2 + self.world.random.next_int_bound(2).unwrap_or(0); + for _ in 0..clumps { + if let Some(at) = self.heart_spread_resin(key) { + self.audio.play( + "minecraft:block.resin.place", + Some([ + f64::from(at.0) + 0.5, + f64::from(at.1) + 0.5, + f64::from(at.2) + 0.5, + ]), + 1.0, + 1.0, + ); + } + } + } + heart.emitter = 100; + heart.emitter_target = self.mob_center(id).map(|(c, _)| c); + } + self.world + .block_entities + .insert(key, BlockEntity::CreakingHeart(heart)); + } + /// `Creaking.tearDown`: the crumble particles. + pub(super) fn creaking_tear_down(&mut self, center: [f64; 3], spread: [f64; 3]) { + let registry = self.res.assets.registry; + let crumble = |this: &mut Self, name: &str, props: &[(&str, &str)], count: i32| { + let Some(mut state) = registry + .default_state(name) + .and_then(|s| registry.state(s).cloned()) + else { + return; + }; + for (k, v) in props { + state.properties.insert((*k).to_owned(), (*v).to_owned()); + } + let Ok(id) = registry.resolve(&state) else { + return; + }; + let Some((sprite, tint)) = this.particle_sprite(id) else { + return; + }; + for _ in 0..count { + let r = &mut this.world.random; + let p = [ + center[0] + r.next_gaussian() * spread[0], + center[1] + r.next_gaussian() * spread[1], + center[2] + r.next_gaussian() * spread[2], + ]; + this.particles.add( + &ParticleOptions::block(ParticleType::BlockCrumble, sprite.clone(), tint), + p, + [0.0; 3], + ); + } + }; + crumble(self, "minecraft:pale_oak_wood", &[], 100); + crumble( + self, + "minecraft:creaking_heart", + &[("creaking_heart_state", "awake")], + 10, + ); + } + /// `CreakingHeartBlock.playerWillDestroy`: the heart's creaking twitches to + /// death and a natural heart drops experience. + pub(super) fn creaking_heart_broken(&mut self, pos: [i32; 3]) { + let key = (pos[0], pos[1], pos[2]); + let Some(BlockEntity::CreakingHeart(mut heart)) = self.world.block_entities.remove(&key) + else { + return; + }; + self.heart_remove_protector(&mut heart, true); + let state = self.world.block(key.0, key.1, key.2); + if self.prop_is(state, "natural") && !self.creative && !self.spectator() { + let xp = 20 + self.world.random.next_int_bound(5).unwrap_or(0) as u32; + self.spawn_orbs( + [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]) + 0.5, + f64::from(pos[2]) + 0.5, + ], + xp, + ); + } + self.world + .block_entities + .insert(key, BlockEntity::CreakingHeart(heart)); + } + /// `SpawnUtil.trySpawnMob(CREAKING, .., 5, 16, 8, ON_TOP_OF_COLLIDER_NO_LEAVES, true)`. + fn spawn_protector(&mut self, pos: Pos) -> Option { + let t = self.res.mob_types.get("minecraft:creaking").cloned()?; + for _ in 0..5 { + let r = &mut self.world.random; + let dx = r.next_int_bound(33).unwrap_or(16) - 16; + let dz = r.next_int_bound(33).unwrap_or(16) - 16; + let mut at = (pos.0 + dx, pos.1 + 8, pos.2 + dz); + if !self.world.loaded(at.0, at.2) { + continue; + } + // moveToPossibleSpawnPosition: scan down for a collider with room above. + let mut above = self.world.block(at.0, at.1, at.2); + let mut found = false; + for _ in 0..=16 { + at.1 -= 1; + let current = self.world.block(at.0, at.1, at.2); + let facts = self.res.facts.get(current); + let leaves = self + .res + .items + .block_tags + .get("minecraft:leaves") + .is_some_and(|s| s.contains(&*facts.name)); + let clear_above = self + .res + .behaviours + .collision_shape(above) + .map_or(!self.res.facts.get(above).full_collision, |s| s.is_empty()); + if clear_above && !leaves && facts.sturdy_full & (1 << 1) != 0 { + at.1 += 1; + found = true; + break; + } + above = current; + } + if !found { + continue; + } + // noCollision(spawn box) and no liquid. + let w = t.width / 2.0; + let bounds = Aabb::new( + horizon_core::geometry::Vec3::new( + f64::from(at.0) + 0.5 - w, + f64::from(at.1), + f64::from(at.2) + 0.5 - w, + ), + horizon_core::geometry::Vec3::new( + f64::from(at.0) + 0.5 + w, + f64::from(at.1) + t.height, + f64::from(at.2) + 0.5 + w, + ), + ); + let mut scene = horizon_client::collisions::SceneCollisions { + world: &self.world, + binding: self.collision, + }; + let free = scene.unobstructed(bounds).unwrap_or(false); + let wet = self.res.facts.get(self.world.block(at.0, at.1, at.2)).fluid + != horizon_client::blocks::Fluid::None; + if !free || wet { + continue; + } + let id = self.spawn_mob( + "minecraft:creaking", + [ + f64::from(at.0) + 0.5, + f64::from(at.1), + f64::from(at.2) + 0.5, + ], + false, + )?; + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + creaking::set_transient(m, [pos.0, pos.1, pos.2]); + } + return Some(id); + } + None + } + /// `CreakingHeartBlockEntity.computeAnalogOutputSignal`. + fn heart_output(&mut self, heart: &mut CreakingHeart, pos: Pos) -> i32 { + if heart.creaking.is_none() { + return 0; + } + let Some(id) = self.heart_protector(heart) else { + return 0; + }; + let distance = self.heart_distance_to_creaking(id, pos).clamp(0.0, 32.0) / 32.0; + 15 - (distance * 15.0).floor() as i32 + } + /// `CreakingHeartBlockEntity.serverTick` for every heart. + pub(super) fn tick_creaking_hearts(&mut self) -> Result<()> { + let keys: Vec = self + .world + .block_entities + .iter() + .filter(|(_, e)| matches!(e, BlockEntity::CreakingHeart(_))) + .map(|(k, _)| *k) + .collect(); + for key in keys { + let Some(BlockEntity::CreakingHeart(mut heart)) = + self.world.block_entities.remove(&key) + else { + continue; + }; + let state = self.world.block(key.0, key.1, key.2); + if &*self.res.facts.get(state).name != "minecraft:creaking_heart" { + // The block is gone: preRemoveSideEffects. + self.heart_remove_protector(&mut heart, false); + continue; + } + if self.heart_state_name(state) != "uprooted" { + self.heart_tick(&mut heart, key, state)?; + } + self.world + .block_entities + .insert(key, BlockEntity::CreakingHeart(heart)); + } + self.scan_for_hearts(); + Ok(()) + } + fn heart_tick( + &mut self, + heart: &mut CreakingHeart, + key: Pos, + state: BlockStateId, + ) -> Result<()> { + heart.ticks_existed += 1; + let output = self.heart_output(heart, key); + if output != heart.output_signal { + heart.output_signal = output; + self.container_changed(key); + } + if heart.emitter > 0 { + if heart.emitter > 50 { + self.heart_emit(heart, key, 1, true); + self.heart_emit(heart, key, 1, false); + } + if heart.emitter % 10 == 0 && heart.emitter_target.is_some() { + if let Some(id) = self.heart_protector(heart) + && let Some((c, _)) = self.mob_center(id) + { + heart.emitter_target = Some(c); + } + if let Some(target) = heart.emitter_target { + let center = [ + f64::from(key.0) + 0.5, + f64::from(key.1) + 0.5, + f64::from(key.2) + 0.5, + ]; + let progress = 0.2 + 0.8 * f64::from(100 - heart.emitter) / 100.0; + let at = [ + (center[0] - target[0]) * progress + target[0], + (center[1] - target[1]) * progress + target[1], + (center[2] - target[2]) * progress + target[2], + ]; + let volume = heart.emitter as f32 / 2.0 / 100.0 + 0.5; + self.audio + .play("minecraft:block.creaking_heart.hurt", Some(at), volume, 1.0); + } + } + heart.emitter -= 1; + } + let ticker = heart.ticker; + heart.ticker -= 1; + if ticker >= 0 { + return Ok(()); + } + heart.ticker = self.world.random.next_int_bound(5).unwrap_or(0) + 20; + // updateCreakingState: logs gone and no creaking means uprooted. + let active = self.creaking_active(); + let has_logs = self.with_level(|b, level, ticks| { + b.creaking_heart_has_logs(level, ticks, BlockPos::new(key.0, key.1, key.2), state) + }); + let wanted = if !has_logs && heart.creaking.is_none() { + "uprooted" + } else if active { + "awake" + } else { + "dormant" + }; + let mut current = self.heart_state_name(state); + if wanted != current + && let Some(next) = self.heart_with_state(state, wanted) + { + self.level_set([key.0, key.1, key.2], next)?; + current = wanted.to_owned(); + if wanted == "uprooted" { + return Ok(()); + } + } + if heart.creaking.is_none() { + if current == "awake" && self.spawning_monsters() { + let near = self.player.as_ref().is_some_and(|p| { + let (dx, dy, dz) = ( + p.position.x - (f64::from(key.0) + 0.5), + p.position.y - (f64::from(key.1) + 0.5), + p.position.z - (f64::from(key.2) + 0.5), + ); + dx * dx + dy * dy + dz * dz < 32.0 * 32.0 + }) && !self.spectator(); + if near && let Some(id) = self.spawn_protector(key) { + let uuid = self.uuid_for(id); + heart.creaking = Some((Some(id), uuid)); + heart.ticks_existed = 0; + let at = self.mob_center(id).map(|(c, _)| c); + self.audio + .play("minecraft:entity.creaking.spawn", at, 1.0, 1.0); + self.audio.play( + "minecraft:block.creaking_heart.spawn", + Some([ + f64::from(key.0) + 0.5, + f64::from(key.1) + 0.5, + f64::from(key.2) + 0.5, + ]), + 1.0, + 1.0, + ); + } + } + } else if let Some(id) = self.heart_protector(heart) { + let persistent = self + .mobs + .iter() + .find(|m| m.id == id) + .is_some_and(|m| m.persistent); + let eye = self.player_view().map(|v| v.eye); + let stuck = self + .mobs + .iter_mut() + .find(|m| m.id == id) + .is_some_and(|m| creaking::player_is_stuck(m, eye)); + if (!active && !persistent) + || self.heart_distance_to_creaking(id, key) > TOO_FAR + || stuck + { + self.heart_remove_protector(heart, false); + } + } + Ok(()) + } + fn heart_with_state(&self, state: BlockStateId, wanted: &str) -> Option { + let mut s = self.res.assets.registry.state(state)?.clone(); + s.properties + .insert("creaking_heart_state".to_owned(), wanted.to_owned()); + self.res.assets.registry.resolve(&s).ok() + } + /// `ServerLevel.isSpawningMonsters`. + fn spawning_monsters(&self) -> bool { + self.ui.difficulty != 0 && self.ui.rules.bool("spawn_monsters") + } + /// `EnvironmentAttributes.CREAKING_ACTIVE`. + pub(super) fn creaking_active(&mut self) -> bool { + self.with_level(|b, level, ticks| b.creaking_active(level, ticks)) + } + /// Hearts that came with generated or loaded chunks get their block + /// entity (`newBlockEntity`) the first time their chunk is seen. + fn scan_for_hearts(&mut self) { + let Some(heart) = self + .res + .assets + .registry + .default_state("minecraft:creaking_heart") + else { + return; + }; + let keys: Vec<(i32, i32)> = self + .world + .chunks + .iter() + .filter(|(k, c)| c.lit && !self.creaking.scanned.contains(k)) + .map(|(k, _)| *k) + .collect(); + for key in keys { + self.creaking.scanned.insert(key); + let Some(chunk) = self.world.chunks.get(&key).cloned() else { + continue; + }; + let name = |id: u16| &*self.res.facts.get(BlockStateId(u32::from(id))).name; + let _ = heart; + for (si, section) in chunk.sections.iter().enumerate() { + if section.is_uniform(0) { + continue; + } + for i in 0..4096 { + let id = section.get(i); + if name(id) != "minecraft:creaking_heart" { + continue; + } + let (lx, lz, ly) = ((i & 15) as i32, ((i >> 4) & 15) as i32, (i >> 8) as i32); + let pos = ( + key.0 * 16 + lx, + horizon_client::chunk::MIN_Y + si as i32 * 16 + ly, + key.1 * 16 + lz, + ); + self.world + .block_entities + .entry(pos) + .or_insert_with(|| BlockEntity::CreakingHeart(Box::default())); + } + } + } + let loaded: HashSet<(i32, i32)> = self.world.chunks.keys().copied().collect(); + self.creaking.scanned.retain(|k| loaded.contains(k)); + } +} + +/// What the creaking code remembers between ticks. +#[derive(Default)] +pub(super) struct CreakingState { + /// Chunks already scanned for heart blocks. + scanned: HashSet<(i32, i32)>, +} diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 8e1b6e59d..3889166ae 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -93,7 +93,8 @@ impl ProjectileWorld for ProjWorld<'_, '_> { .full_collision } } -fn seen(m: &Mob) -> Seen { +fn seen(m: &Mob, player: Option<[i32; 4]>) -> Seen { + let villager = m.species() == Species::Villager; Seen { id: m.id, species: m.species(), @@ -102,7 +103,12 @@ fn seen(m: &Mob) -> Seen { eye_y: m.eye_y(), alive: m.alive(), baby: m.is_baby(), - in_love: m.extra.in_love > 0, + // A villager is "in love" when it is willing to breed (`canBreed`). + in_love: if villager { + horizon_client::mobs::villager::can_breed(m) + } else { + m.extra.in_love > 0 + }, tame: m.extra.tame, hostile: m.hostile(), target: m.ai.target, @@ -115,6 +121,13 @@ fn seen(m: &Mob) -> Seen { bed: (m.species() == Species::Villager) .then_some(m.extra.bed) .flatten(), + active_raid: horizon_client::mobs::raider::has_active_raid(m), + player_rep: match (villager, player) { + (true, Some(uuid)) => { + horizon_client::mobs::villager::ext(m).map_or(0, |e| e.gossips.reputation(uuid)) + } + _ => 0, + }, } } impl Game<'_> { @@ -150,6 +163,8 @@ impl Game<'_> { gold_armor: self.wearing_gold(), hurt_by: self.player_hurt_by(), last_hurt: self.combat.last_hurt_mob.map(|(id, at)| (Who::Mob(id), at)), + hero: self.potions.effects.get("hero_of_the_village").is_some(), + uuid: self.level.player_uuid.unwrap_or_default(), }) } /// Biome facts at a position for finalizeSpawn and variant rules. @@ -191,6 +206,17 @@ impl Game<'_> { } /// Create a mob of `kind` at a position, finalized like a natural spawn. pub(super) fn spawn_mob(&mut self, kind: &str, at: [f64; 3], persistent: bool) -> Option { + self.spawn_mob_for(kind, at, persistent, false) + } + /// `spawn_mob` for a patrol or raid (`EntitySpawnReason.PATROL` / `EVENT`), + /// which never rolls a patrol leader. + pub(super) fn spawn_mob_for( + &mut self, + kind: &str, + at: [f64; 3], + persistent: bool, + scripted: bool, + ) -> Option { let kind = if kind.contains(':') { kind.to_owned() } else { @@ -208,6 +234,14 @@ impl Game<'_> { ); let difficulty = self.local_difficulty(at); spawning::finalize(&mut mob, &facts, &difficulty); + if !scripted { + let reason = if persistent { + horizon_client::mobs::raider::Reason::Other + } else { + horizon_client::mobs::raider::Reason::Natural + }; + horizon_client::mobs::raider::finalize(&mut mob, reason); + } let id = mob.id; self.mobs.push(mob); Some(id) @@ -259,13 +293,28 @@ impl Game<'_> { "on_ground": m.on_ground, "variant": m.extra.variant, "color": m.extra.color, + "villager": horizon_client::mobs::villager::ext(m).map(|e| serde_json::json!({ + "food_level": e.food_level, + "inventory": e.inventory.iter().map(|s| format!("{}x{}", s.count, s.item)).collect::>(), + "gossips": e.gossips.len(), + "last_slept": e.last_slept, + "raid": e.raid, + })), + "raider": horizon_client::mobs::raider::state(m).map(|s| serde_json::json!({ + "raid": s.raid_id, + "wave": s.wave, + "leader": s.patrol_leader, + "patrolling": s.patrolling, + "patrol_target": s.patrol_target, + "vehicle": s.vehicle, + })), }) }) .collect(); serde_json::json!({ "count": self.mobs.len(), "near": list, "projectiles": self.creatures.projectiles.len() }) } /// Highest motion-blocking (no leaves) block + 1 (Heightmap MOTION_BLOCKING_NO_LEAVES). - fn motion_top(&self, x: i32, z: i32) -> i32 { + pub(super) fn motion_top(&self, x: i32, z: i32) -> i32 { let top = if self.dim == Dim::Nether { 127 } else { 319 }; for y in (horizon_client::chunk::MIN_Y..=top).rev() { let f = self.res.facts.get(self.world.block(x, y, z)); @@ -602,7 +651,10 @@ impl Game<'_> { } self.tick_inhabited(); self.spawn_natural(); - let snapshot: Vec = self.mobs.iter().map(seen).collect(); + self.tick_patrol_spawner(); + self.tick_raids(); + let uuid = self.level.player_uuid; + let snapshot: Vec = self.mobs.iter().map(|m| seen(m, uuid)).collect(); let mut events = Vec::new(); let mut mobs = std::mem::take(&mut self.mobs); let mut dead = Vec::new(); @@ -625,6 +677,9 @@ impl Game<'_> { push_apart(&mut mobs); } self.mobs.append(&mut mobs); + self.sync_riders(); + self.villager_reputation_tick(); + self.villager_pickups(); for m in dead { self.mob_died(&m); } @@ -647,6 +702,8 @@ impl Game<'_> { self.trigger_entity("minecraft:player_killed_entity", "entity", &view); } self.score_entity_removed(m.id); + self.raider_died(m, by_player); + self.villager_murdered(m, by_player); let held = self.held().cloned(); let pos = [m.position.x, m.position.y + 0.5, m.position.z]; if !m.is_baby() { @@ -690,6 +747,11 @@ impl Game<'_> { for item in gear { self.spawn_item(ItemStack::new(item, 1), pos, [0.0, 0.2, 0.0], 10); } + // AbstractChestedHorse.dropEquipment: the chest contents. + for stack in m.extra.items.clone().into_iter().flatten() { + self.spawn_item(stack, pos, [0.0, 0.2, 0.0], 10); + } + self.raider_death_loot(m, pos); let worn = if horizon_client::mobs::equine::is_equine(m.species()) { [None, None, None, None] } else { @@ -705,6 +767,7 @@ impl Game<'_> { // Vexes never drop their sword. if let Some(item) = &item && by_player + && &**item != horizon_client::mobs::raider::BANNER && m.species() != Species::Vex && self.world.random.next_float() < 0.085 { @@ -972,6 +1035,36 @@ impl Game<'_> { } }, MobEvent::Breed { parent, partner } => self.breed(parent, partner), + MobEvent::CreakingHurt { + home, + by_player, + id, + } => self.creaking_hurt(home, id, by_player), + MobEvent::CreakingTearDown { center, spread } => { + self.creaking_tear_down(center, spread) + } + MobEvent::VillagerMeet { mob, other } => self.villager_meet(mob, other), + MobEvent::VillagerBirth { parent, partner } => self.villager_birth(parent, partner), + MobEvent::GolemCheck { mob, needed } => self.villager_golem_check(mob, needed), + MobEvent::Firework { at, color, flight } => { + self.villager_firework(at, color, flight) + } + MobEvent::ThrowGift { table, from, to } => self.throw_gift(&table, from, to), + MobEvent::PatrolTarget { mob, target } => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { + horizon_client::mobs::raider::set_patrol_target(m, target); + } + } + MobEvent::RaiderTarget { + mob, + target, + aggressive, + } => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { + m.ai.target = Some(target); + m.ai.aggressive |= aggressive; + } + } MobEvent::GiftLoot { table, at } => { let drops = self.res @@ -1549,6 +1642,32 @@ impl Game<'_> { } } } + // A witch's healing potions reach the raiders around the splash. + if matches!( + *effect, + "minecraft:instant_health" | "minecraft:regeneration" + ) { + let center = at; + for m in &mut self.mobs { + let d2 = m.position.distance_squared(center); + if !m.alive() + || d2 >= 16.0 + || !horizon_client::mobs::raider::is_raider(m.species()) + { + continue; + } + let scale = 1.0 - d2.sqrt() / 4.0; + if *effect == "minecraft:instant_health" { + let heal = (4 << *amplifier) as f64 * scale; + m.health = (m.health + heal as f32).min(m.attrs.max_health); + } else { + let t = (f64::from(*ticks) * scale + 0.5) as i32; + if t > 20 { + m.add_effect(effect, t, *amplifier); + } + } + } + } self.audio.play( "minecraft:entity.splash_potion.break", Some(atp), diff --git a/crates/horizon-client/src/game/dispenser.rs b/crates/horizon-client/src/game/dispenser.rs new file mode 100644 index 000000000..75f39881d --- /dev/null +++ b/crates/horizon-client/src/game/dispenser.rs @@ -0,0 +1,1462 @@ +//! Dispenser behaviours: `DispenserBlock.getDispenseMethod(..).dispense` with +//! every `DispenseItemBehavior` registration of vanilla that Horizon has the +//! entities for. A behaviour returns what is left in the slot and the level +//! event it plays (`DefaultDispenseItemBehavior.dispense` then plays that +//! event and the smoke animation, event 2000). +use super::Game; +use horizon_client::{ + Result, + collisions::SceneCollisions, + containers::BlockEntity, + items::ItemStack, + mobs::{MobEvent, SpawnSetup, Species}, + particles::{ParticleOptions, ParticleType}, + projectiles::{Projectile, ProjectileKind}, +}; +use horizon_core::{ + geometry::{Aabb, Direction, Vec3}, + position::BlockPos, + random::RandomSource, +}; +use horizon_world::{ + fluid::FluidKind, + level::{BucketContent, PlaceContext, PlaceOutcome}, + registry::BlockStateId, +}; + +type Pos = (i32, i32, i32); + +/// The sound event of a plain click, a failed dispense and a launched projectile. +const CLICK: i32 = 1000; +const FAIL: i32 = 1001; +const LAUNCH: i32 = 1002; + +fn step(d: Direction) -> [i32; 3] { + match d { + Direction::Down => [0, -1, 0], + Direction::Up => [0, 1, 0], + Direction::North => [0, 0, -1], + Direction::South => [0, 0, 1], + Direction::West => [-1, 0, 0], + Direction::East => [1, 0, 0], + } +} +fn offset(p: Pos, d: Direction) -> Pos { + let s = step(d); + (p.0 + s[0], p.1 + s[1], p.2 + s[2]) +} +/// `Direction.get3DDataValue`. +fn data_value(d: Direction) -> i32 { + match d { + Direction::Down => 0, + Direction::Up => 1, + Direction::North => 2, + Direction::South => 3, + Direction::West => 4, + Direction::East => 5, + } +} +/// `Direction.toYRot` (vertical directions give 270 through `data2d = -1`). +fn y_rot(d: Direction) -> f32 { + match d { + Direction::South => 0.0, + Direction::West => 90.0, + Direction::North => 180.0, + Direction::East => 270.0, + _ => 270.0, + } +} +fn block_box(p: Pos) -> Aabb { + Aabb::new( + Vec3::new(f64::from(p.0), f64::from(p.1), f64::from(p.2)), + Vec3::new(f64::from(p.0 + 1), f64::from(p.1 + 1), f64::from(p.2 + 1)), + ) +} +fn overlaps(a: Aabb, b: Aabb) -> bool { + let (a0, a1, b0, b1) = ( + a.min_position(), + a.max_position(), + b.min_position(), + b.max_position(), + ); + a0.x < b1.x && b0.x < a1.x && a0.y < b1.y && b0.y < a1.y && a0.z < b1.z && b0.z < a1.z +} +/// `ItemStack.shrink(1)`; the slot is empty at zero. +fn shrink(mut stack: ItemStack) -> Option { + stack.count -= 1; + (stack.count > 0).then_some(stack) +} +/// A dispenser's answer: the slot's new content and the level event played. +type Dispensed = (Option, i32); + +/// Entities `getEntitiesOfClass(.., AABB(pos))` can find. +enum Target { + Player, + Mob(usize), + Stand(usize), +} + +impl Game<'_> { + fn prop(&self, state: BlockStateId, key: &str) -> Option { + self.res + .assets + .registry + .state(state)? + .properties + .get(key) + .cloned() + } + /// The same block with other properties (`withProperty`). + fn with_props(&self, state: BlockStateId, props: &[(&str, &str)]) -> Option { + let mut s = self.res.assets.registry.state(state)?.clone(); + for (k, v) in props { + s.properties.insert((*k).to_owned(), (*v).to_owned()); + } + self.res.assets.registry.resolve(&s).ok() + } + fn block_at(&self, p: Pos) -> BlockStateId { + self.world.block(p.0, p.1, p.2) + } + fn dispenser_block_name(&self, p: Pos) -> std::sync::Arc { + self.res.facts.get(self.block_at(p)).name.clone() + } + fn in_block_tag(&self, tag: &str, block: &str) -> bool { + self.res + .items + .block_tags + .get(tag) + .is_some_and(|s| s.contains(block)) + } + fn water_at(&self, p: Pos) -> bool { + matches!( + self.res.behaviours.fluid_kind(self.block_at(p)), + FluidKind::Water | FluidKind::FlowingWater + ) + } + fn center(p: Pos) -> [f64; 3] { + [ + f64::from(p.0) + 0.5, + f64::from(p.1) + 0.5, + f64::from(p.2) + 0.5, + ] + } + fn pos_of(p: Pos) -> BlockPos { + BlockPos::new(p.0, p.1, p.2) + } + + // ---- level events (LevelEventHandler) ---- + + /// The dispenser level events: 1000 click, 1001 fail, 1002 launch, 1004 + /// firework shoot, 1018 blaze shoot and 2000 smoke shot out of the front. + pub(super) fn dispenser_event(&mut self, id: i32, pos: Pos, data: i32) { + let c = Self::center(pos); + match id { + 1000 => self + .audio + .play("minecraft:block.dispenser.dispense", Some(c), 1.0, 1.0), + 1001 => self + .audio + .play("minecraft:block.dispenser.fail", Some(c), 1.0, 1.2), + 1002 => self + .audio + .play("minecraft:block.dispenser.launch", Some(c), 1.0, 1.2), + 1004 => self + .audio + .play("minecraft:entity.firework_rocket.shoot", Some(c), 1.0, 1.2), + 1018 => { + let r = &mut self.world.random; + let pitch = (r.next_float() - r.next_float()) * 0.2 + 1.0; + self.audio + .play("minecraft:entity.blaze.shoot", Some(c), 2.0, pitch); + } + 2000 => { + let s = match data { + 0 => [0, -1, 0], + 1 => [0, 1, 0], + 2 => [0, 0, -1], + 3 => [0, 0, 1], + 4 => [-1, 0, 0], + _ => [1, 0, 0], + }; + for _ in 0..10 { + let r = self.particles.random(); + let pow = r.next_double() * 0.2 + 0.01; + let (sx, sy, sz) = (f64::from(s[0]), f64::from(s[1]), f64::from(s[2])); + let p = [ + f64::from(pos.0) + + sx * 0.6 + + 0.5 + + sx * 0.01 + + (r.next_double() - 0.5) * sz * 0.5, + f64::from(pos.1) + + sy * 0.6 + + 0.5 + + sy * 0.01 + + (r.next_double() - 0.5) * sy * 0.5, + f64::from(pos.2) + + sz * 0.6 + + 0.5 + + sz * 0.01 + + (r.next_double() - 0.5) * sx * 0.5, + ]; + let v = [ + sx * pow + r.next_gaussian() * 0.01, + sy * pow + r.next_gaussian() * 0.01, + sz * pow + r.next_gaussian() * 0.01, + ]; + self.particles + .add(&ParticleOptions::simple(ParticleType::Smoke), p, v); + } + } + _ => {} + } + } + + // ---- DefaultDispenseItemBehavior ---- + + /// `DispenserBlock.getDispensePosition(source, scale, offset)`. + fn dispense_position(pos: Pos, facing: Direction, scale: f64, offset: [f64; 3]) -> Vec3 { + let s = step(facing); + let c = Self::center(pos); + Vec3::new( + c[0] + scale * f64::from(s[0]) + offset[0], + c[1] + scale * f64::from(s[1]) + offset[1], + c[2] + scale * f64::from(s[2]) + offset[2], + ) + } + /// `DefaultDispenseItemBehavior.spawnItem` at `getDispensePosition`. + pub(super) fn spawn_dispensed( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + accuracy: i32, + ) { + let s = step(facing); + let p = Self::dispense_position(pos, facing, 0.7, [0.0; 3]); + let mut at = [p.x, p.y, p.z]; + at[1] -= if s[1] != 0 { 0.125 } else { 0.156_25 }; + let r = &mut self.world.random; + // new ItemEntity(level, x, y, z, stack): its default motion draws first. + let _ = (r.next_double(), r.next_double()); + let pow = r.next_double() * 0.1 + 0.2; + let spread = 0.017_227_5 * f64::from(accuracy); + let v = [ + r.triangle(f64::from(s[0]) * pow, spread), + r.triangle(0.2, spread), + r.triangle(f64::from(s[2]) * pow, spread), + ]; + self.spawn_item(stack, at, v, 0); + } + /// `DefaultDispenseItemBehavior.execute`: drop one item. + fn default_execute( + &mut self, + pos: Pos, + facing: Direction, + mut stack: ItemStack, + ) -> Option { + let one = ItemStack { + count: 1, + ..stack.clone() + }; + stack.count -= 1; + self.spawn_dispensed(pos, facing, one, 6); + (stack.count > 0).then_some(stack) + } + /// `new DefaultDispenseItemBehavior().dispense(..)` including its events. + pub(super) fn dispense_default( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Option { + let left = self.default_execute(pos, facing, stack); + self.dispenser_event(CLICK, pos, 0); + self.dispenser_event(2000, pos, data_value(facing)); + left + } + /// `DefaultDispenseItemBehavior.consumeWithRemainder`: the remainder goes + /// into the dispenser (`insertItem`) or is dropped. + fn consume_with_remainder( + &mut self, + pos: Pos, + facing: Direction, + mut stack: ItemStack, + remainder: ItemStack, + ) -> Option { + stack.count -= 1; + if stack.count == 0 { + return Some(remainder); + } + let mut rest = remainder; + if let Some(entity) = self.world.block_entities.get_mut(&pos) { + let max = self + .res + .items + .get(&rest.item) + .map_or(64, |i| i.max_stack) + .max(1); + for cell in entity.slots_mut() { + match cell { + None => { + let n = rest.count.min(max); + *cell = Some(ItemStack { + count: n, + ..rest.clone() + }); + rest.count -= n; + } + Some(e) if e.same_item_same_components(&rest) => { + let n = rest.count.min(max.saturating_sub(e.count)); + e.count += n; + rest.count -= n; + } + Some(_) => {} + } + if rest.count == 0 { + break; + } + } + } + if rest.count > 0 { + self.spawn_dispensed(pos, facing, rest, 6); + self.dispenser_event(CLICK, pos, 0); + self.dispenser_event(2000, pos, data_value(facing)); + } + Some(stack) + } + /// `ItemStack.hurtAndBreak(amount)` without an entity. + fn hurt_and_break(&mut self, mut stack: ItemStack, amount: u32) -> Option { + let max = self.res.items.get(&stack.item).map_or(0, |i| i.max_damage); + if max == 0 { + return Some(stack); + } + stack.damage += self.durability_loss(&stack, amount); + if stack.damage >= max { + return shrink(ItemStack { damage: 0, ..stack }); + } + Some(stack) + } + + // ---- the registry ---- + + /// `DispenserBlock.getDispenseMethod(..).dispense(source, stack)`: what the + /// slot holds afterwards. + pub(super) fn dispense_item( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result> { + let item = stack.item.to_string(); + let (left, event) = match item.as_str() { + "minecraft:arrow" + | "minecraft:tipped_arrow" + | "minecraft:spectral_arrow" + | "minecraft:egg" + | "minecraft:blue_egg" + | "minecraft:brown_egg" + | "minecraft:snowball" + | "minecraft:experience_bottle" + | "minecraft:splash_potion" + | "minecraft:lingering_potion" + | "minecraft:firework_rocket" + | "minecraft:fire_charge" => self.dispense_projectile(pos, facing, stack), + "minecraft:armor_stand" => self.dispense_armor_stand(pos, facing, stack), + "minecraft:chest" => self.dispense_chest(pos, facing, stack), + "minecraft:lava_bucket" + | "minecraft:water_bucket" + | "minecraft:powder_snow_bucket" + | "minecraft:salmon_bucket" + | "minecraft:cod_bucket" + | "minecraft:pufferfish_bucket" + | "minecraft:tropical_fish_bucket" + | "minecraft:axolotl_bucket" + | "minecraft:tadpole_bucket" => self.dispense_filled_bucket(pos, facing, stack)?, + "minecraft:bucket" => self.dispense_empty_bucket(pos, facing, stack)?, + "minecraft:flint_and_steel" => self.dispense_flint_and_steel(pos, facing, stack)?, + "minecraft:bone_meal" => self.dispense_bone_meal(pos, facing, stack)?, + "minecraft:tnt" => self.dispense_tnt(pos, facing, stack), + "minecraft:wither_skeleton_skull" => self.dispense_wither_skull(pos, facing, stack)?, + "minecraft:carved_pumpkin" => self.dispense_carved_pumpkin(pos, facing, stack)?, + "minecraft:glass_bottle" => self.dispense_glass_bottle(pos, facing, stack)?, + "minecraft:glowstone" => self.dispense_glowstone(pos, facing, stack)?, + "minecraft:shears" => self.dispense_shears(pos, facing, stack)?, + "minecraft:brush" => self.dispense_brush(pos, facing, stack), + "minecraft:honeycomb" => self.dispense_honeycomb(pos, facing, stack)?, + "minecraft:potion" => self.dispense_potion(pos, facing, stack)?, + _ if item.ends_with("shulker_box") => self.dispense_shulker_box(pos, facing, stack)?, + _ if super::boats::boat_wood(&item).is_some() => self.dispense_boat(pos, facing, stack), + _ if super::minecarts::CartKind::from_id(&item).is_some() => { + self.dispense_minecart(pos, facing, stack) + } + _ => self.dispense_default_method(pos, facing, stack), + }; + self.dispenser_event(event, pos, 0); + self.dispenser_event(2000, pos, data_value(facing)); + Ok(left) + } + /// `DispenserBlock.getDefaultDispenseMethod`: equipment, spawn eggs, or a drop. + fn dispense_default_method( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Dispensed { + let equippable = self + .res + .items + .get(&stack.item) + .is_some_and(|i| i.equip_slot.is_some()); + if equippable { + let mut stack = stack; + if self.dispense_equipment(pos, facing, &mut stack) { + return (Some(stack).filter(|s| s.count > 0), CLICK); + } + return (self.default_execute(pos, facing, stack), CLICK); + } + if stack.item.ends_with("_spawn_egg") { + return self.dispense_spawn_egg(pos, facing, stack); + } + (self.default_execute(pos, facing, stack), CLICK) + } + + // ---- entities ---- + + /// Entities whose box overlaps the block at `p`. + fn targets_at(&self, p: Pos) -> Vec { + let block = block_box(p); + let mut out: Vec = self + .mobs + .iter() + .enumerate() + .filter(|(_, m)| m.alive() && overlaps(m.bounds(), block)) + .map(|(i, _)| Target::Mob(i)) + .collect(); + out.extend( + self.armor_stands + .iter() + .enumerate() + .filter(|(_, s)| overlaps(s.bounds(), block)) + .map(|(i, _)| Target::Stand(i)), + ); + if let Some(v) = self.player_view() + && v.alive + && !self.spectator() + && overlaps(v.bounds, block) + { + out.push(Target::Player); + } + out + } + /// The Y offset `EntityType.getYOffset` finds for a box set down into a block. + fn drop_offset(&self, width: f64, height: f64, p: Pos) -> f64 { + let h = width / 2.0; + let (x, z) = (f64::from(p.0) + 0.5, f64::from(p.2) + 0.5); + let y = f64::from(p.1) + 1.0; + let bounds = Aabb::new( + Vec3::new(x - h, y, z - h), + Vec3::new(x + h, y + height, z + h), + ); + let mut scene = SceneCollisions { + world: &self.world, + binding: self.collision, + }; + match scene.resolve(bounds, Vec3::new(0.0, -1.0, 0.0), 0.0, false) { + Ok(moved) => 1.0 + moved.y, + Err(_) => 0.0, + } + } + /// `EntityType.spawn(.., pos, reason, tryMoveDown, false)` for a mob. + fn spawn_mob_at(&mut self, kind: &str, p: Pos, try_move_down: bool) -> Option { + let name = if kind.contains(':') { + kind.to_owned() + } else { + format!("minecraft:{kind}") + }; + let t = self.res.mob_types.get(&name)?.clone(); + let y_off = if try_move_down { + self.drop_offset(t.width, t.height, p) + } else { + 0.0 + }; + let at = [ + f64::from(p.0) + 0.5, + f64::from(p.1) + y_off, + f64::from(p.2) + 0.5, + ]; + self.spawn_mob(&name, at, true) + } + /// `EquipmentDispenseItemBehavior.dispenseEquipment`: the first entity in + /// front that can wear the item gets one of it. + fn dispense_equipment(&mut self, pos: Pos, _facing: Direction, stack: &mut ItemStack) -> bool { + let Some(info) = self.res.items.get(&stack.item) else { + return false; + }; + let (Some(slot), true) = (info.equip_slot.clone(), info.equip_dispensable) else { + return false; + }; + let allowed = info.equip_allowed.clone(); + let sound = info.equip_sound.clone(); + let front = offset(pos, _facing); + let one = ItemStack { + count: 1, + ..stack.clone() + }; + let armor_index = match slot.as_str() { + "head" => Some(0), + "chest" => Some(1), + "legs" => Some(2), + "feet" => Some(3), + _ => None, + }; + let id_allowed = |id: &str| allowed.as_ref().is_none_or(|a| a.contains(id)); + let item: std::sync::Arc = stack.item.clone(); + for target in self.targets_at(front) { + let at = match target { + Target::Player => { + // The player wears armour only. + let Some(i) = armor_index else { continue }; + if !id_allowed("minecraft:player") || self.armor[i].is_some() { + continue; + } + self.armor[i] = Some(one.clone()); + self.apply_equipment(); + self.player_view().map(|v| v.position) + } + Target::Stand(i) => { + let Some(ai) = armor_index else { continue }; + if !id_allowed("minecraft:armor_stand") { + continue; + } + // ArmorStand equipment: mainhand, offhand, feet, legs, chest, head. + let index = 5 - ai; + let stand = &mut self.armor_stands[i]; + if stand.equipment[index].is_some() { + continue; + } + stand.equipment[index] = Some(one.clone()); + Some(stand.position) + } + Target::Mob(i) => { + let m = &mut self.mobs[i]; + if !id_allowed(&m.kind.id) { + continue; + } + let species = m.species(); + let tamed = m.extra.tame; + let equine = matches!( + species, + Species::Horse + | Species::Donkey + | Species::Mule + | Species::SkeletonHorse + | Species::ZombieHorse + | Species::Camel + ); + let slot_free = match (slot.as_str(), armor_index) { + (_, Some(0)) => m.extra.head.is_none(), + (_, Some(1)) => m.extra.chest.is_none(), + (_, Some(2)) => m.extra.legs.is_none(), + (_, Some(3)) => m.extra.feet.is_none(), + ("saddle", _) => !m.extra.saddled, + ("body", _) => species == Species::Horse && m.extra.head.is_none(), + _ => false, + }; + // Mob.canDispenserEquipIntoSlot and the overrides. + let saddle_ok = slot == "saddle" + && (matches!(species, Species::Pig | Species::Strider) || equine && tamed); + let body_ok = slot == "body" && equine && tamed; + if !slot_free || !(m.extra.pick_up_loot || saddle_ok || body_ok) { + continue; + } + if species == Species::Strider && slot == "saddle" && m.is_baby() { + continue; + } + match (slot.as_str(), armor_index) { + (_, Some(0)) => m.extra.head = Some(item.clone()), + (_, Some(1)) => m.extra.chest = Some(item.clone()), + (_, Some(2)) => m.extra.legs = Some(item.clone()), + (_, Some(3)) => m.extra.feet = Some(item.clone()), + ("saddle", _) => m.extra.saddled = true, + _ => m.extra.head = Some(item.clone()), + } + // setGuaranteedDrop / setPersistenceRequired. + m.persistent = true; + Some(m.position) + } + }; + if let (Some(sound), Some(at)) = (sound, at) { + self.audio.play(&sound, Some([at.x, at.y, at.z]), 1.0, 1.0); + } + stack.count -= 1; + return true; + } + false + } + fn dispense_spawn_egg(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed { + let kind = stack.item.trim_end_matches("_spawn_egg").to_owned(); + let front = offset(pos, facing); + if self + .spawn_mob_at(&kind, front, facing != Direction::Up) + .is_none() + { + return (Some(stack), CLICK); + } + (shrink(stack), CLICK) + } + + // ---- ProjectileDispenseBehavior ---- + + fn dispense_projectile(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed { + let item = stack.item.to_string(); + let s = step(facing); + let dir = [f64::from(s[0]), f64::from(s[1]), f64::from(s[2])]; + // ProjectileItem.DispenseConfig per item: position, uncertainty, power, event. + let (at, uncertainty, power, event) = match item.as_str() { + "minecraft:firework_rocket" => ( + Self::dispense_position(pos, facing, 0.500_009_999_999_747_4, [0.0; 3]), + 1.0, + 0.5, + 1004, + ), + "minecraft:fire_charge" => ( + Self::dispense_position(pos, facing, 1.0, [0.0; 3]), + 6.666_666_5, + 1.0, + 1018, + ), + "minecraft:experience_bottle" + | "minecraft:splash_potion" + | "minecraft:lingering_potion" => ( + Self::dispense_position(pos, facing, 0.7, [0.0, 0.1, 0.0]), + 3.0, + 1.375, + LAUNCH, + ), + _ => ( + Self::dispense_position(pos, facing, 0.7, [0.0, 0.1, 0.0]), + 6.0, + 1.1, + LAUNCH, + ), + }; + let one = ItemStack { + count: 1, + ..stack.clone() + }; + match item.as_str() { + "minecraft:experience_bottle" + | "minecraft:splash_potion" + | "minecraft:lingering_potion" => { + let mut shot = Projectile::new(ProjectileKind::Snowball, at, None); + shot.shoot(&mut self.world.random, dir, power, uncertainty); + self.launch_thrown(one, at, shot.velocity); + } + "minecraft:firework_rocket" => { + let mut shot = Projectile::new(ProjectileKind::Snowball, at, None); + shot.shoot(&mut self.world.random, dir, power, uncertainty); + self.launch_dispensed_rocket(at, shot.velocity, &one); + } + _ => { + let kind = match item.as_str() { + "minecraft:arrow" => ProjectileKind::Arrow { + base_damage: 2.0, + critical: false, + effect: None, + }, + "minecraft:spectral_arrow" => ProjectileKind::Arrow { + base_damage: 2.0, + critical: false, + effect: Some(("minecraft:glowing", 200)), + }, + "minecraft:tipped_arrow" => ProjectileKind::Arrow { + base_damage: 2.0, + critical: false, + effect: stack + .potion() + .and_then(horizon_client::brewing::potion) + .and_then(|def| { + def.effects + .iter() + .find(|(id, _, _)| { + !horizon_client::brewing::effect(id) + .is_some_and(|e| e.instant) + }) + .map(|(id, duration, _)| (*id, (duration / 8).max(1))) + }), + }, + "minecraft:fire_charge" => { + // The fireball's own aim is drawn first, then shot along the facing. + let r = &mut self.world.random; + let _ = ( + r.triangle(dir[0], 0.114_85), + r.triangle(dir[1], 0.114_85), + r.triangle(dir[2], 0.114_85), + ); + ProjectileKind::SmallFireball + } + "minecraft:egg" | "minecraft:blue_egg" | "minecraft:brown_egg" => { + ProjectileKind::Egg + } + _ => ProjectileKind::Snowball, + }; + let mut shot = Projectile::new(kind, at, None); + shot.shoot(&mut self.world.random, dir, power, uncertainty); + self.creatures.projectiles.push(shot); + } + } + (shrink(stack), event) + } + + // ---- entities placed by items ---- + + fn dispense_armor_stand(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed { + let front = offset(pos, facing); + let foot = Vec3::new( + f64::from(front.0) + 0.5, + f64::from(front.1), + f64::from(front.2) + 0.5, + ); + self.next_entity += 1; + let stand = + horizon_client::entities::ArmorStand::new(self.next_entity, foot, y_rot(facing)); + self.world.modified.insert((front.0 >> 4, front.2 >> 4)); + self.armor_stands.push(stand); + (shrink(stack), CLICK) + } + /// A tame donkey, mule or llama in front without a chest gets it. + fn dispense_chest(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed { + let front = offset(pos, facing); + for target in self.targets_at(front) { + let Target::Mob(i) = target else { continue }; + let m = &mut self.mobs[i]; + if matches!( + m.species(), + Species::Donkey | Species::Mule | Species::Llama | Species::TraderLlama + ) && m.extra.tame + && !m.extra.chested + { + m.extra.chested = true; + return (shrink(stack), CLICK); + } + } + (self.default_execute(pos, facing, stack), CLICK) + } + /// `BoatDispenseItemBehavior`. + fn dispense_boat(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed { + let Some(wood) = super::boats::boat_wood(&stack.item).map(str::to_owned) else { + return (self.dispense_default(pos, facing, stack), CLICK); + }; + let front = offset(pos, facing); + let s = step(facing); + let c = Self::center(pos); + // Boat width 1.375. + let outside = 0.5625 + 1.375 / 2.0; + let (x, y, z) = ( + c[0] + f64::from(s[0]) * outside, + c[1] + f64::from(s[1]) * f64::from(1.125f32), + c[2] + f64::from(s[2]) * outside, + ); + let below = (front.0, front.1 - 1, front.2); + let y_offset = if self.water_at(front) { + 1.0 + } else if self.res.facts.is_air(self.block_at(front)) && self.water_at(below) { + 0.0 + } else { + return (self.dispense_default(pos, facing, stack), CLICK); + }; + if !self.boat_models.models.contains_key(&wood) { + return (self.dispense_default(pos, facing, stack), CLICK); + } + self.next_entity += 1; + let boat = super::boats::Boat::new( + self.next_entity, + wood.as_str().into(), + Vec3::new(x, y + y_offset, z), + y_rot(facing), + ); + self.world.modified.insert((front.0 >> 4, front.2 >> 4)); + self.boats.push(boat); + (shrink(stack), CLICK) + } + /// `MinecartDispenseItemBehavior`. + fn dispense_minecart(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed { + let Some(kind) = super::minecarts::CartKind::from_id(&stack.item) else { + return (self.dispense_default(pos, facing, stack), CLICK); + }; + let s = step(facing); + let c = Self::center(pos); + let (x, base_y, z) = ( + c[0] + f64::from(s[0]) * 1.125, + c[1].floor() + f64::from(s[1]), + c[2] + f64::from(s[2]) * 1.125, + ); + let front = offset(pos, facing); + let y_offset = if let Some(rail) = self.rail(front.0, front.1, front.2) { + if rail.shape.is_slope() { 0.6 } else { 0.1 } + } else { + if !self.res.facts.is_air(self.block_at(front)) { + return (self.dispense_default(pos, facing, stack), CLICK); + } + let below = (front.0, front.1 - 1, front.2); + let Some(rail) = self.rail(below.0, below.1, below.2) else { + return (self.dispense_default(pos, facing, stack), CLICK); + }; + if facing != Direction::Down && rail.shape.is_slope() { + -0.4 + } else { + -0.9 + } + }; + self.next_entity += 1; + let cart = super::minecarts::Minecart::new( + self.next_entity, + kind, + Vec3::new(x, base_y + y_offset, z), + ); + self.world.modified.insert((front.0 >> 4, front.2 >> 4)); + self.carts.push(cart); + (shrink(stack), CLICK) + } + + // ---- buckets ---- + + /// The filled bucket behaviour: `DispensibleContainerItem.emptyContents`. + fn dispense_filled_bucket( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let item = stack.item.to_string(); + let target = offset(pos, facing); + let (content, sound, mob) = match item.as_str() { + "minecraft:lava_bucket" => ( + BucketContent::Fluid(FluidKind::Lava), + "minecraft:item.bucket.empty_lava", + None, + ), + "minecraft:water_bucket" => ( + BucketContent::Fluid(FluidKind::Water), + "minecraft:item.bucket.empty", + None, + ), + "minecraft:powder_snow_bucket" => ( + BucketContent::Powder, + "minecraft:item.bucket.empty_powder_snow", + None, + ), + "minecraft:axolotl_bucket" => ( + BucketContent::Fluid(FluidKind::Water), + "minecraft:item.bucket.empty_axolotl", + Some("axolotl"), + ), + "minecraft:tadpole_bucket" => ( + BucketContent::Fluid(FluidKind::Water), + "minecraft:item.bucket.empty_tadpole", + Some("tadpole"), + ), + other => ( + BucketContent::Fluid(FluidKind::Water), + "minecraft:item.bucket.empty_fish", + Some(match other { + "minecraft:salmon_bucket" => "salmon", + "minecraft:cod_bucket" => "cod", + "minecraft:pufferfish_bucket" => "pufferfish", + _ => "tropical_fish", + }), + ), + }; + let target_pos = Self::pos_of(target); + let emptied = self + .with_level(|b, level, ticks| b.bucket_empty(level, ticks, target_pos, content, sound)); + self.process_level_events()?; + if !emptied { + return Ok((self.dispense_default(pos, facing, stack), CLICK)); + } + if self.dim == super::Dim::Nether + && matches!(content, BucketContent::Fluid(FluidKind::Water)) + { + // The water evaporates in a cloud of smoke. + let c = Self::center(target); + for _ in 0..8 { + let r = self.particles.random(); + let p = [ + f64::from(target.0) + (r.next_double() * 2.0 - 1.0), + f64::from(target.1) + (r.next_double() * 2.0 - 1.0), + f64::from(target.2) + (r.next_double() * 2.0 - 1.0), + ]; + let _ = c; + self.particles.add( + &ParticleOptions::simple(ParticleType::LargeSmoke), + p, + [0.0; 3], + ); + } + } else if let Some(kind) = mob { + // MobBucketItem.checkExtraContent. + self.spawn_mob_at(kind, target, true); + } + let bucket = ItemStack::new("minecraft:bucket", 1); + Ok(( + self.consume_with_remainder(pos, facing, stack, bucket), + CLICK, + )) + } + /// The empty bucket: `BucketPickup.pickupBlock`. + fn dispense_empty_bucket( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = Self::pos_of(offset(pos, facing)); + let picked = self.with_level(|b, level, ticks| b.bucket_pickup(level, ticks, target)); + self.process_level_events()?; + match picked { + Some(filled) => { + let filled = ItemStack::new(filled, 1); + Ok(( + self.consume_with_remainder(pos, facing, stack, filled), + CLICK, + )) + } + None => Ok((self.default_execute(pos, facing, stack), CLICK)), + } + } + + // ---- fire, bone meal and TNT ---- + + fn dispense_flint_and_steel( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + let target_pos = Self::pos_of(target); + let state = self.block_at(target); + let name = self.dispenser_block_name(target); + let mut success = true; + if self.res.facts.is_air(state) { + // BaseFireBlock.canBePlacedAt: a fire that survives, or a portal. + let below = self.dispenser_block_name((target.0, target.1 - 1, target.2)); + let fire_name = if matches!(&*below, "minecraft:soul_sand" | "minecraft:soul_soil") { + "minecraft:soul_fire" + } else { + "minecraft:fire" + }; + let fire = self.res.assets.registry.default_state(fire_name); + if let Some(fire) = fire + && self.with_level(|b, level, ticks| b.can_survive(level, ticks, target_pos, fire)) + { + self.level_set([target.0, target.1, target.2], fire)?; + } else if !self.try_light_portal([target.0, target.1, target.2])? { + // Nothing to light; vanilla still counts it as a success. + } + } else if self.prop(state, "lit").as_deref() == Some("false") + && (name.contains("campfire") || name.contains("candle")) + && self.prop(state, "waterlogged").as_deref() != Some("true") + { + if let Some(lit) = self.with_props(state, &[("lit", "true")]) { + self.level_set([target.0, target.1, target.2], lit)?; + } + } else if &*name == "minecraft:tnt" { + if self.ui.rules.bool("tnt_explodes") { + self.spawn_primed_tnt(target_pos, false); + self.with_level(|b, level, ticks| b.remove_block(level, ticks, target_pos, false)); + self.process_level_events()?; + } else { + success = false; + } + } + let event = if success { CLICK } else { FAIL }; + if success { + return Ok((self.hurt_and_break(stack, 1), event)); + } + Ok((Some(stack), event)) + } + fn dispense_bone_meal( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + let target_pos = Self::pos_of(target); + let grown = self.with_level(|b, level, ticks| { + b.grow_crop(level, ticks, target_pos) + || b.grow_water_plant(level, ticks, target_pos, None) + }); + if grown { + self.level_events + .push(horizon_world::level::LevelEvent::LevelEvent { + id: 1505, + pos: target_pos, + data: 15, + }); + } + self.process_level_events()?; + if grown { + Ok((shrink(stack), CLICK)) + } else { + Ok((Some(stack), FAIL)) + } + } + fn dispense_tnt(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed { + if !self.ui.rules.bool("tnt_explodes") { + return (Some(stack), FAIL); + } + let target = Self::pos_of(offset(pos, facing)); + self.spawn_primed_tnt(target, false); + (shrink(stack), CLICK) + } + + // ---- blocks placed by dispensers ---- + + fn dispense_wither_skull( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + let free = self.res.facts.is_air(self.block_at(target)) + && target.1 >= horizon_client::chunk::MIN_Y + 2 + && self.ui.difficulty != 0 + && self.can_build_wither(target); + if free { + let rotation = match facing { + Direction::Up | Direction::Down => 0, + other => { + // RotationSegment.convertToSegment: opposite 2D data value * 4. + (match other.opposite() { + Direction::South => 0, + Direction::West => 1, + Direction::North => 2, + _ => 3, + }) * 4 + } + }; + let skull = self + .res + .assets + .registry + .default_state("minecraft:wither_skeleton_skull") + .and_then(|s| self.with_props(s, &[("rotation", &rotation.to_string())])); + if let Some(skull) = skull { + self.level_set([target.0, target.1, target.2], skull)?; + if let Some(entity) = BlockEntity::for_block("minecraft:wither_skeleton_skull") { + self.world.block_entities.insert(target, entity); + } + self.check_wither_spawn([target.0, target.1, target.2])?; + return Ok((shrink(stack), CLICK)); + } + } + let mut stack = stack; + let equipped = self.dispense_equipment(pos, facing, &mut stack); + Ok(( + Some(stack).filter(|s| s.count > 0), + if equipped { CLICK } else { FAIL }, + )) + } + /// `WitherSkullBlock.getOrCreateWitherBase().find(level, pos)`: the soul + /// sand T below the row `head` is in. + fn can_build_wither(&self, head: Pos) -> bool { + let soul = |p: Pos| { + matches!( + &*self.dispenser_block_name(p), + "minecraft:soul_sand" | "minecraft:soul_soil" + ) + }; + let air = |p: Pos| self.res.facts.is_air(self.block_at(p)); + for (ax, az) in [(1, 0), (0, 1)] { + for col in 0..3 { + let left = (head.0 - ax * col, head.1, head.2 - az * col); + let at = |c: i32, row: i32| (left.0 + ax * c, left.1 - row, left.2 + az * c); + if (0..3).all(|c| soul(at(c, 1))) + && soul(at(1, 2)) + && air(at(0, 2)) + && air(at(2, 2)) + { + return true; + } + } + } + false + } + fn dispense_carved_pumpkin( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + if self.res.facts.is_air(self.block_at(target)) + && self.can_spawn_golem([target.0, target.1, target.2]) + { + if let Some(pumpkin) = self + .res + .assets + .registry + .default_state("minecraft:carved_pumpkin") + { + self.level_set([target.0, target.1, target.2], pumpkin)?; + self.check_golem_spawn([target.0, target.1, target.2])?; + } + return Ok((shrink(stack), CLICK)); + } + let mut stack = stack; + let equipped = self.dispense_equipment(pos, facing, &mut stack); + Ok(( + Some(stack).filter(|s| s.count > 0), + if equipped { CLICK } else { FAIL }, + )) + } + /// `ShulkerBoxDispenseBehavior`: place it like a `DirectionalPlaceContext`. + fn dispense_shulker_box( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let front = offset(pos, facing); + let below_empty = self + .res + .facts + .is_air(self.block_at((front.0, front.1 - 1, front.2))); + let clicked_face = if below_empty { facing } else { Direction::Up }; + let front_state = self.block_at(front); + if !(self.res.facts.is_air(front_state) || self.res.facts.get(front_state).replaceable) { + return Ok((Some(stack), FAIL)); + } + let ctx = PlaceContext { + clicked_pos: Self::pos_of(front), + face: clicked_face, + hit: Vec3::new( + f64::from(front.0) + 0.5, + f64::from(front.1), + f64::from(front.2) + 0.5, + ), + inside: false, + yaw: y_rot(facing), + pitch: 0.0, + sneaking: false, + item: stack.item.to_string(), + can_use_game_master_blocks: false, + }; + let outcome = self.with_level(|b, level, ticks| b.place_block(level, ticks, &ctx)); + let PlaceOutcome::Placed { pos: placed, state } = outcome else { + self.process_level_events()?; + return Ok((Some(stack), FAIL)); + }; + let target = (placed.x, placed.y, placed.z); + if let Some(entity) = BlockEntity::for_block(&self.res.facts.get(state).name) { + self.world.block_entities.insert(target, entity); + self.fill_placed_box([target.0, target.1, target.2], &stack); + } + let sounds = self.res.facts.get(state).sounds.clone(); + self.audio.play( + &sounds.place, + Some(Self::center(target)), + (sounds.volume + 1.0) / 2.0, + sounds.pitch * 0.8, + ); + self.process_level_events()?; + Ok((shrink(stack), CLICK)) + } + + // ---- bottles, glowstone, shears, brush, honeycomb ---- + + fn dispense_glass_bottle( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + let state = self.block_at(target); + let name = self.dispenser_block_name(target); + let honey = self + .prop(state, "honey_level") + .and_then(|v| v.parse::().ok()); + if self.in_block_tag("minecraft:beehives", &name) + && let Some(level) = honey + && level >= 5 + { + // releaseBeesAndResetHoneyLevel (the bees themselves are not modelled). + if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) { + self.level_set([target.0, target.1, target.2], reset)?; + } + let bottle = ItemStack::new("minecraft:honey_bottle", 1); + return Ok(( + self.consume_with_remainder(pos, facing, stack, bottle), + CLICK, + )); + } + if self.water_at(target) { + let water = ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"); + return Ok(( + self.consume_with_remainder(pos, facing, stack, water), + CLICK, + )); + } + Ok((self.default_execute(pos, facing, stack), FAIL)) + } + fn dispense_glowstone( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + let state = self.block_at(target); + if &*self.dispenser_block_name(target) == "minecraft:respawn_anchor" { + let charge = self + .prop(state, "charges") + .and_then(|v| v.parse::().ok()) + .unwrap_or(0); + if charge != 4 { + if let Some(next) = + self.with_props(state, &[("charges", &(charge + 1).to_string())]) + { + self.level_set([target.0, target.1, target.2], next)?; + } + self.audio.play( + "minecraft:block.respawn_anchor.charge", + Some(Self::center(target)), + 1.0, + 1.0, + ); + return Ok((shrink(stack), CLICK)); + } + return Ok((Some(stack), FAIL)); + } + Ok((self.default_execute(pos, facing, stack), CLICK)) + } + fn dispense_shears( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + let sheared = self.shear_beehive(target)? || self.shear_entity(target)?; + if sheared { + return Ok((self.hurt_and_break(stack, 1), CLICK)); + } + Ok((Some(stack), FAIL)) + } + fn shear_beehive(&mut self, target: Pos) -> Result { + let state = self.block_at(target); + let name = self.dispenser_block_name(target); + let level = self + .prop(state, "honey_level") + .and_then(|v| v.parse::().ok()); + if !self.in_block_tag("minecraft:beehives", &name) || level.is_none_or(|l| l < 5) { + return Ok(false); + } + self.audio.play( + "minecraft:block.beehive.shear", + Some(Self::center(target)), + 1.0, + 1.0, + ); + // BeehiveBlock.dropHoneycomb, then the honey level resets. + self.pop_resource( + [target.0, target.1, target.2], + ItemStack::new("minecraft:honeycomb", 3), + ); + if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) { + self.level_set([target.0, target.1, target.2], reset)?; + } + Ok(true) + } + /// `Shearable.shear` on the first ready entity in the block. + fn shear_entity(&mut self, target: Pos) -> Result { + for t in self.targets_at(target) { + let Target::Mob(i) = t else { continue }; + let m = &self.mobs[i]; + let at = [m.position.x, m.position.y, m.position.z]; + match m.species() { + Species::Sheep if !m.extra.sheared && !m.is_baby() => { + let color = + horizon_client::mobs::render::DYE_NAMES[m.extra.color as usize & 15]; + self.mobs[i].extra.sheared = true; + self.audio + .play("minecraft:entity.sheep.shear", Some(at), 1.0, 1.0); + let stacks = self.res.items.loot_table( + &format!("minecraft:shearing/sheep/{color}"), + false, + None, + &mut self.world.random, + ); + self.drop_sheared(at, stacks); + return Ok(true); + } + Species::Bogged if !m.extra.sheared => { + self.mobs[i].extra.sheared = true; + self.audio + .play("minecraft:entity.bogged.shear", Some(at), 1.0, 1.0); + let stacks = self.res.items.loot_table( + "minecraft:shearing/bogged", + false, + None, + &mut self.world.random, + ); + self.drop_sheared(at, stacks); + return Ok(true); + } + Species::Mooshroom if !m.is_baby() => { + let mushroom = if m.extra.variant == 1 { + "minecraft:brown_mushroom" + } else { + "minecraft:red_mushroom" + }; + let setup = SpawnSetup { + yaw: m.yaw, + persistent: true, + ..Default::default() + }; + self.mobs[i].removed = true; + self.audio + .play("minecraft:entity.mooshroom.shear", Some(at), 1.0, 1.0); + self.handle_mob_events(vec![MobEvent::SpawnKind { + kind: "minecraft:cow".into(), + at, + setup, + }])?; + for _ in 0..5 { + let v = [0.0, 0.2, 0.0]; + self.spawn_item( + ItemStack::new(mushroom, 1), + [at[0], at[1] + 1.0, at[2]], + v, + 10, + ); + } + return Ok(true); + } + _ => {} + } + } + Ok(false) + } + /// The drops of a sheared mob, one entity per item, a block above its feet. + fn drop_sheared(&mut self, at: [f64; 3], stacks: Vec) { + for stack in stacks { + for _ in 0..stack.count { + let r = &mut self.world.random; + let v = [ + f64::from((r.next_float() - r.next_float()) * 0.1), + f64::from(r.next_float() * 0.05), + f64::from((r.next_float() - r.next_float()) * 0.1), + ]; + let one = ItemStack { + count: 1, + ..stack.clone() + }; + self.spawn_item(one, [at[0], at[1] + 1.0, at[2]], v, 10); + } + } + } + /// A brush used on an adult armadillo in front. + fn dispense_brush(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed { + let target = offset(pos, facing); + let armadillo = self.targets_at(target).into_iter().find_map(|t| match t { + Target::Mob(i) if self.mobs[i].species() == Species::Armadillo => Some(i), + _ => None, + }); + let Some(i) = armadillo.filter(|&i| !self.mobs[i].is_baby()) else { + return (Some(stack), FAIL); + }; + let m = &self.mobs[i]; + let at = [m.position.x, m.position.y, m.position.z]; + let drops = self.res.items.loot_table( + "minecraft:brush/armadillo", + false, + None, + &mut self.world.random, + ); + for d in drops { + self.spawn_item(d, [at[0], at[1] + 0.5, at[2]], [0.0, 0.2, 0.0], 10); + } + self.audio + .play("minecraft:entity.armadillo.brush", Some(at), 1.0, 1.0); + (self.hurt_and_break(stack, 16), CLICK) + } + fn dispense_honeycomb( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + let state = self.block_at(target); + let name = self.dispenser_block_name(target); + // HoneycombItem.WAXABLES: each copper block has a waxed twin. + let waxed = name.strip_prefix("minecraft:").and_then(|n| { + if n.starts_with("waxed_") { + return None; + } + let twin = format!("minecraft:waxed_{n}"); + let mut s = self.res.assets.registry.state(state)?.clone(); + self.res.assets.registry.default_state(&twin)?; + s.name = twin; + self.res.assets.registry.resolve(&s).ok() + }); + let Some(waxed) = + waxed.filter(|_| name.contains("copper") || name.contains("lightning_rod")) + else { + return Ok((self.default_execute(pos, facing, stack), CLICK)); + }; + self.level_set([target.0, target.1, target.2], waxed)?; + self.audio.play( + "minecraft:item.honeycomb.wax_on", + Some(Self::center(target)), + 1.0, + 1.0, + ); + Ok((shrink(stack), CLICK)) + } + fn dispense_potion( + &mut self, + pos: Pos, + facing: Direction, + stack: ItemStack, + ) -> Result { + let target = offset(pos, facing); + let water = stack.potion() == Some("minecraft:water"); + let name = self.dispenser_block_name(target); + if !water || !self.in_block_tag("minecraft:convertible_to_mud", &name) { + // The inner default behaviour dispenses, then the potion's own + // events play on top. + return Ok((self.dispense_default(pos, facing, stack), CLICK)); + } + for _ in 0..5 { + let r = self.particles.random(); + let p = [ + f64::from(pos.0) + r.next_double(), + f64::from(pos.1 + 1), + f64::from(pos.2) + r.next_double(), + ]; + self.particles + .add(&ParticleOptions::simple(ParticleType::Splash), p, [0.0; 3]); + } + self.audio.play( + "minecraft:item.bottle.empty", + Some(Self::center(pos)), + 1.0, + 1.0, + ); + if let Some(mud) = self.res.assets.registry.default_state("minecraft:mud") { + self.level_set([target.0, target.1, target.2], mud)?; + } + let bottle = ItemStack::new("minecraft:glass_bottle", 1); + Ok(( + self.consume_with_remainder(pos, facing, stack, bottle), + CLICK, + )) + } +} diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 398b9a208..be4b4ec1f 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -1842,7 +1842,8 @@ impl Game<'_> { /// The boss bar (`BossHealthOverlay`): name and the pink progress bar. pub(super) fn draw_boss_bar(&self, batch: &mut HudBatch) { let dragon = self.dragon.as_ref().filter(|_| self.dim == Dim::End); - self.draw_wither_bars(batch, if dragon.is_some() { 31.0 } else { 12.0 }); + let y = self.draw_wither_bars(batch, if dragon.is_some() { 31.0 } else { 12.0 }); + self.draw_raid_bar(batch, y); let Some(d) = dragon else { return; }; diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs index c021842e8..4f0c3fa9c 100644 --- a/crates/horizon-client/src/game/fireworks.rs +++ b/crates/horizon-client/src/game/fireworks.rs @@ -24,6 +24,9 @@ pub(super) struct Rocket { explosions: Vec, /// Boosting the player (attachedToEntity). attached: bool, + /// `DATA_SHOT_AT_ANGLE` (dispensers): constant velocity, exploding on + /// the first block it hits. + angled: bool, icon: Option, } fn fireworks_of(stack: &ItemStack) -> (u8, Vec) { @@ -34,7 +37,7 @@ fn fireworks_of(stack: &ItemStack) -> (u8, Vec) { .unwrap_or((1, Vec::new())) } impl Game<'_> { - fn new_rocket(&mut self, at: Vec3, stack: &ItemStack, attached: bool) -> Rocket { + pub(super) fn new_rocket(&mut self, at: Vec3, stack: &ItemStack, attached: bool) -> Rocket { let (flight, explosions) = fireworks_of(stack); let r = &mut self.world.random; let tri = |r: &mut horizon_core::random::LegacyRandom| { @@ -52,6 +55,7 @@ impl Game<'_> { lifetime, explosions, attached, + angled: false, icon: Some("item/firework_rocket".into()), } } @@ -73,6 +77,13 @@ impl Game<'_> { self.swing_arm(); true } + /// `FireworkRocketItem.asProjectile` shot out of a dispenser. + pub(super) fn launch_dispensed_rocket(&mut self, at: Vec3, velocity: Vec3, stack: &ItemStack) { + let mut rocket = self.new_rocket(at, stack, false); + rocket.velocity = velocity; + rocket.angled = true; + self.rockets.push(rocket); + } /// `FireworkRocketItem.use` while gliding: a rocket attached to the player. pub(super) fn boost_firework(&mut self, stack: &ItemStack) -> bool { if &*stack.item != "minecraft:firework_rocket" @@ -118,12 +129,23 @@ impl Game<'_> { Vec3::new(r.position.x - h, r.position.y, r.position.z - h), Vec3::new(r.position.x + h, r.position.y + 2.0 * h, r.position.z + h), ); - let wanted = Vec3::new( - r.velocity.x * 1.15, - r.velocity.y + 0.04, - r.velocity.z * 1.15, - ); + let wanted = if r.angled { + r.velocity + } else { + Vec3::new( + r.velocity.x * 1.15, + r.velocity.y + 0.04, + r.velocity.z * 1.15, + ) + }; if let Ok(moved) = scene.resolve(bounds, wanted, 0.0, false) { + let blocked = (moved.x - wanted.x).abs() > 1e-7 + || (moved.y - wanted.y).abs() > 1e-7 + || (moved.z - wanted.z).abs() > 1e-7; + if r.angled && blocked { + // hitTargetOrDeflectSelf: explode on the block. + r.life = r.lifetime; + } let horizontal = (moved.x - wanted.x).abs() > 1e-7 || (moved.z - wanted.z).abs() > 1e-7; r.position = Vec3::new( diff --git a/crates/horizon-client/src/game/golems.rs b/crates/horizon-client/src/game/golems.rs new file mode 100644 index 000000000..7287c51bd --- /dev/null +++ b/crates/horizon-client/src/game/golems.rs @@ -0,0 +1,82 @@ +//! Building golems from blocks (`CarvedPumpkinBlock.trySpawnGolem`): a carved +//! pumpkin or jack o'lantern on two snow blocks makes a snow golem, and on a +//! T of four iron blocks (arms along X or Z, nothing beside the legs) an iron +//! golem. Players placing the pumpkin and dispensers share it. +use super::Game; +use horizon_client::Result; + +impl Game<'_> { + fn golem_block(&self, p: [i32; 3]) -> &str { + let state = self.world.block(p[0], p[1], p[2]); + &self.res.facts.get(state).name + } + fn is_golem_head(&self, p: [i32; 3]) -> bool { + matches!( + self.golem_block(p), + "minecraft:carved_pumpkin" | "minecraft:jack_o_lantern" + ) + } + /// The blocks of the golem whose head is at `head` and its spawn base + /// (`BlockPattern.find`), snow golems first. + fn find_golem(&self, head: [i32; 3]) -> Option<(&'static str, Vec<[i32; 3]>, [i32; 3])> { + let below = |n: i32| [head[0], head[1] - n, head[2]]; + if self.golem_block(below(1)) == "minecraft:snow_block" + && self.golem_block(below(2)) == "minecraft:snow_block" + { + return Some(( + "minecraft:snow_golem", + vec![head, below(1), below(2)], + below(2), + )); + } + for (ax, az) in [(1, 0), (0, 1)] { + let side = |s: i32, row: i32| [head[0] + ax * s, head[1] - row, head[2] + az * s]; + let arms = (-1..=1).all(|s| self.golem_block(side(s, 1)) == "minecraft:iron_block"); + let air = |p: [i32; 3]| self.res.facts.is_air(self.world.block(p[0], p[1], p[2])); + if arms + && self.golem_block(side(0, 2)) == "minecraft:iron_block" + && [-1, 1].iter().all(|&s| air(side(s, 0)) && air(side(s, 2))) + { + let mut blocks = vec![head]; + blocks.extend((-1..=1).map(|s| side(s, 1))); + blocks.push(side(0, 2)); + return Some(("minecraft:iron_golem", blocks, side(0, 2))); + } + } + None + } + /// `CarvedPumpkinBlock.canSpawnGolem`. + pub(super) fn can_spawn_golem(&self, head: [i32; 3]) -> bool { + self.find_golem(head).is_some() + } + /// `CarvedPumpkinBlock.trySpawnGolem`, after a pumpkin was placed. + pub(super) fn check_golem_spawn(&mut self, head: [i32; 3]) -> Result<()> { + if !self.is_golem_head(head) { + return Ok(()); + } + let Some((kind, blocks, base)) = self.find_golem(head) else { + return Ok(()); + }; + for p in blocks { + let state = self.world.block(p[0], p[1], p[2]); + self.destroy_particles(p, state); + self.level_set(p, self.world.air)?; + } + let at = [ + f64::from(base[0]) + 0.5, + f64::from(base[1]) + 0.05, + f64::from(base[2]) + 0.5, + ]; + if let Some(id) = self.spawn_mob(kind, at, false) + && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) + { + m.yaw = 0.0; + m.body_yaw = 0.0; + m.head_yaw = 0.0; + m.previous_yaw = 0.0; + m.previous_body_yaw = 0.0; + m.previous_head_yaw = 0.0; + } + Ok(()) + } +} diff --git a/crates/horizon-client/src/game/loom.rs b/crates/horizon-client/src/game/loom.rs new file mode 100644 index 000000000..39663c298 --- /dev/null +++ b/crates/horizon-client/src/game/loom.rs @@ -0,0 +1,415 @@ +//! The loom (`LoomMenu`, `LoomScreen`): stacking banner patterns onto a +//! banner with a dye (and a pattern item for the special patterns), the +//! six-layer limit, the scrolling pattern list and the banner preview. +use super::{ + Game, + stations::{INPUT, Station}, +}; +use horizon_client::{ + banner::{self, BannerLayer}, + hud::{HudBatch, Rect, rgba}, + items::ItemStack, +}; +use std::sync::Arc; + +/// Per-menu loom state: `selectablePatterns`, the selected index and the +/// screen's scroller. +#[derive(Default)] +pub(super) struct LoomState { + pub(super) patterns: Vec>, + pub(super) selected: Option, + /// `displayPatterns`: the pattern buttons are shown. + pub(super) display: bool, + pub(super) has_max: bool, + pub(super) scroll: f32, + pub(super) start_row: usize, + pub(super) scrolling: bool, +} +impl LoomState { + fn total_rows(&self) -> usize { + self.patterns.len().div_ceil(4) + } + fn offscreen_rows(&self) -> i32 { + self.total_rows() as i32 - 4 + } + fn scroll_active(&self) -> bool { + self.display && self.patterns.len() > 16 + } + /// `startRow` for a scroller position. + fn row_for(&self, offs: f32) -> usize { + ((offs * self.offscreen_rows() as f32 + 0.5) as i32).max(0) as usize + } +} + +const BUTTON: f32 = 14.0; + +fn inside(p: (f32, f32), x: f32, y: f32, w: f32, h: f32) -> bool { + p.0 >= x && p.1 >= y && p.0 < x + w && p.1 < y + h +} +/// A sub-rectangle of a sprite given in texels. +fn sub_rect(r: Rect, [x, y, w, h]: [f32; 4]) -> Rect { + let (du, dv) = ((r.u1 - r.u0) / r.w as f32, (r.v1 - r.v0) / r.h as f32); + Rect { + u0: r.u0 + x * du, + v0: r.v0 + y * dv, + u1: r.u0 + (x + w) * du, + v1: r.v0 + (y + h) * dv, + w: w as u32, + h: h as u32, + } +} +/// A dye's tint as a HUD vertex colour. +pub(super) fn dye_color(name: &str) -> u32 { + let c = banner::dye_rgb(name); + rgba((c >> 16) as u8, (c >> 8) as u8, c as u8, 255) +} + +impl Game<'_> { + /// `LoomMenu.slotsChanged` and the screen's `containerChanged`. + pub(super) fn loom_changed(&self, s: &mut Station) { + let banners = &self.res.stations.banners; + let items = &self.res.items; + let (banner_in, dye_in) = (s.inputs[0].as_ref(), s.inputs[1].as_ref()); + let l = &mut s.loom; + let mut result = None; + if let (Some(banner_stack), Some(dye_stack)) = (banner_in, dye_in) { + let valid = l.selected.is_some_and(|i| i < l.patterns.len()); + let previous = std::mem::take(&mut l.patterns); + l.patterns = banners.selectable(s.inputs[2].as_ref()); + let shown = if l.patterns.len() == 1 { + l.selected = Some(0); + Some(l.patterns[0].clone()) + } else if !valid { + l.selected = None; + None + } else { + let value = previous[l.selected.unwrap_or(0)].clone(); + match l.patterns.iter().position(|p| *p == value) { + Some(i) => { + l.selected = Some(i); + Some(value) + } + None => { + l.selected = None; + None + } + } + }; + l.has_max = banner::has_max_layers(banner_stack); + if let Some(pattern) = shown { + if l.has_max { + l.selected = None; + } else if let Some(dye) = banners.loom_dye(items, dye_stack) { + result = Some(banner::loom_result(banner_stack, &dye, &pattern)); + } + } + l.display = !l.has_max && !l.patterns.is_empty(); + } else { + l.patterns.clear(); + l.selected = None; + l.has_max = banner_in.is_some_and(banner::has_max_layers); + l.display = false; + } + if l.start_row >= l.total_rows() { + l.start_row = 0; + l.scroll = 0.0; + } + s.result = result; + } + /// The loom slots' `mayPlace`. + pub(super) fn loom_slot_rules(&self, input: usize, stack: &ItemStack) -> (bool, u32) { + let banners = &self.res.stations.banners; + let ok = match input { + 0 => stack.item.ends_with("_banner"), + 1 => banners.loom_dye(&self.res.items, stack).is_some(), + _ => banners.is_pattern_item(&self.res.items, stack), + }; + (ok, 64) + } + /// The result slot's `onTake`: one banner and one dye are used up. + pub(super) fn loom_taken(&mut self, s: &mut Station) { + for slot in &mut s.inputs[..2] { + if let Some(x) = slot.as_mut() { + x.count -= 1; + if x.count == 0 { + *slot = None; + } + } + } + if s.inputs[0].is_none() || s.inputs[1].is_none() { + s.loom.selected = None; + } + if s.last_sound != self.ticks { + s.last_sound = self.ticks; + let pos = s.pos; + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]) + 0.5, + f64::from(pos[2]) + 0.5, + ]; + self.audio + .play("minecraft:ui.loom.take_result", Some(at), 1.0, 1.0); + } + } + /// `LoomMenu.quickMoveStack` from an inventory slot. + pub(super) fn loom_quick_move(&mut self, slot: usize, stack: &mut ItemStack) -> bool { + let banners = &self.res.stations.banners; + let items = &self.res.items; + let target = if stack.item.ends_with("_banner") { + Some(INPUT) + } else if banners.loom_dye(items, stack).is_some() { + Some(INPUT + 1) + } else if banners.is_pattern_item(items, stack) { + Some(INPUT + 2) + } else { + None + }; + match target { + Some(t) => self.move_to(stack, &[t], false), + None if (9..36).contains(&slot) => { + let hotbar: Vec = (0..9).collect(); + self.move_to(stack, &hotbar, false) + } + None if slot < 9 => { + let main: Vec = (9..36).collect(); + self.move_to(stack, &main, false) + } + None => false, + } + } + /// A left click inside the loom's pattern grid or scroller. + pub(super) fn loom_click(&mut self, local: (f32, f32)) -> bool { + let Some(s) = self.station.as_ref() else { + return false; + }; + let l = &s.loom; + if !l.display { + return false; + } + for row in 0..4 { + for column in 0..4 { + let index = (row + l.start_row) * 4 + column; + let (x, y) = (60.0 + column as f32 * BUTTON, 13.0 + row as f32 * BUTTON); + if index < l.patterns.len() && inside(local, x, y, BUTTON, BUTTON) { + if let Some(s) = self.station.as_mut() { + s.loom.selected = Some(index); + } + self.audio + .play("minecraft:ui.loom.select_pattern", None, 1.0, 1.0); + self.station_changed(); + return true; + } + } + } + if inside(local, 119.0, 9.0, 12.0, 56.0) + && let Some(s) = self.station.as_mut() + { + s.loom.scrolling = true; + return true; + } + false + } + /// `LoomScreen.mouseDragged` on the scroller. + pub(super) fn loom_drag(&mut self) { + let Some(size) = self + .renderer + .as_ref() + .map(|r| [r.config.width, r.config.height]) + else { + return; + }; + let (_, oy) = self.inventory_origin(&HudBatch::new(size)); + let cursor_y = self.cursor.1; + let Some(l) = self.station.as_mut().map(|s| &mut s.loom) else { + return; + }; + if l.scrolling && l.display && l.offscreen_rows() > 0 { + let top = oy + 13.0; + l.scroll = ((cursor_y - top - 7.5) / (56.0 - 15.0)).clamp(0.0, 1.0); + l.start_row = l.row_for(l.scroll); + } + } + pub(super) fn loom_release(&mut self) { + if let Some(s) = self.station.as_mut() { + s.loom.scrolling = false; + } + } + /// `LoomScreen.mouseScrolled`. + pub(super) fn loom_scroll(&mut self, d: f32) { + let Some(l) = self.station.as_mut().map(|s| &mut s.loom) else { + return; + }; + let offscreen = l.offscreen_rows(); + if l.display && offscreen > 0 { + l.scroll = (l.scroll - d / offscreen as f32).clamp(0.0, 1.0); + l.start_row = l.row_for(l.scroll); + } + } + /// A banner flag's front face (`BannerFlagModel`, 20x40 texels at (1, 1)) + /// drawn flat: the cloth, the base colour and every layer. + pub(super) fn draw_flag( + &self, + batch: &mut HudBatch, + rect: [f32; 4], + base: &str, + layers: &[BannerLayer], + ) { + let banners = &self.res.stations.banners; + let mut paint = |name: &str, color: u32| { + if let Some(r) = self.res.atlas.sprites.get(name).copied() { + let uv = sub_rect(r, [1.0, 1.0, 20.0, 40.0]); + batch.rect_uv(rect[0], rect[1], rect[2], rect[3], uv, color); + } + }; + paint("entity/banner/banner_base", u32::MAX); + paint("entity/banner/base", dye_color(base)); + for layer in layers.iter().take(16) { + paint( + &banners.banner_texture(&layer.pattern), + dye_color(&layer.color), + ); + } + } + /// `LoomScreen.extractBackground` after the background; returns the + /// pattern name tooltip of the hovered button. + pub(super) fn draw_loom( + &mut self, + batch: &mut HudBatch, + ox: f32, + oy: f32, + local: (f32, f32), + ) -> Option> { + let s = self.station.as_ref()?; + let l = &s.loom; + let atlas = &self.res.atlas; + for (i, icon) in ["banner", "dye", "banner_pattern"].iter().enumerate() { + if s.inputs[i].is_none() { + let pos = [(13.0, 26.0), (33.0, 26.0), (23.0, 45.0)][i]; + batch.sprite( + atlas, + &format!("gui/sprites/container/slot/{icon}"), + ox + pos.0, + oy + pos.1, + ); + } + } + let scroller = if l.scroll_active() { + "scroller" + } else { + "scroller_disabled" + }; + batch.sprite( + atlas, + &format!("gui/sprites/container/loom/{scroller}"), + ox + 119.0, + oy + 13.0 + (41.0 * l.scroll).floor(), + ); + let result = s.result.clone(); + let (display, has_max, start_row, selected) = + (l.display, l.has_max, l.start_row, l.selected); + let patterns = l.patterns.clone(); + let dye = s.inputs[1] + .as_ref() + .and_then(|d| self.res.stations.banners.loom_dye(&self.res.items, d)) + .unwrap_or_else(|| Arc::from("white")); + if let Some(result) = result.filter(|_| !has_max) + && let Some(base) = banner::banner_color(&result.item) + { + self.draw_flag( + batch, + [ox + 141.0, oy + 8.0, 20.0, 40.0], + base, + banner::layers(&result), + ); + } else if has_max { + batch.sprite( + &self.res.atlas, + "gui/sprites/container/loom/error", + ox + 138.0, + oy + 52.0, + ); + } + let mut tooltip = None; + if display { + let atlas = &self.res.atlas; + for row in 0..4 { + for column in 0..4 { + let index = (row + start_row) * 4 + column; + let Some(pattern) = patterns.get(index) else { + return tooltip; + }; + let (x, y) = (60.0 + column as f32 * BUTTON, 13.0 + row as f32 * BUTTON); + let hover = inside(local, x, y, BUTTON, BUTTON); + let sprite = if selected == Some(index) { + "pattern_selected" + } else if hover { + let key = self + .res + .stations + .banners + .layer_key(&BannerLayer::new(pattern, &dye)); + tooltip = Some(vec![(self.translate(&key, &key), u32::MAX)]); + "pattern_highlighted" + } else { + "pattern" + }; + batch.sprite( + atlas, + &format!("gui/sprites/container/loom/{sprite}"), + ox + x, + oy + y, + ); + // extractBannerOnButton: a 5x10 grey cloth with the pattern. + batch.fill( + atlas, + ox + x + 4.0, + oy + y + 2.0, + 5.0, + 10.0, + dye_color("gray"), + ); + let texture = self.res.stations.banners.banner_texture(pattern); + if let Some(r) = atlas.sprites.get(&texture).copied() { + let uv = sub_rect(r, [0.0, 1.0, 21.0, 40.0]); + batch.rect_uv(ox + x + 4.0, oy + y + 2.0, 5.0, 10.0, uv, u32::MAX); + } + } + } + } + tooltip + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn scroller_rows_follow_the_offset() { + let l = LoomState { + patterns: (0..40) + .map(|i| Arc::from(format!("p{i}").as_str())) + .collect(), + display: true, + ..Default::default() + }; + // 40 patterns = 10 rows, 6 off screen. + assert_eq!(l.offscreen_rows(), 6); + assert!(l.scroll_active()); + assert_eq!(l.row_for(0.0), 0); + assert_eq!(l.row_for(1.0), 6); + assert_eq!(l.row_for(0.5), 3); + } + #[test] + fn few_patterns_do_not_scroll() { + let l = LoomState { + patterns: (0..16) + .map(|i| Arc::from(format!("p{i}").as_str())) + .collect(), + display: true, + ..Default::default() + }; + assert!(!l.scroll_active()); + assert_eq!(l.offscreen_rows(), 0); + } +} diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index 835056c09..5f75bf86d 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -3,18 +3,15 @@ //! the vanilla dispense behaviours Horizon has entities for, and container //! comparator signals (`AbstractContainerMenu.getRedstoneSignalFromContainer`). use super::Game; + +mod crafter; use horizon_client::{ Result, containers::BlockEntity, - entities::Arrow, items::{ItemStack, Items}, world::World, }; -use horizon_core::{ - geometry::{Direction, Vec3}, - position::BlockPos, - random::{LegacyRandom, RandomSource}, -}; +use horizon_core::{geometry::Direction, position::BlockPos, random::RandomSource}; use horizon_world::{level::Behaviours, registry::BlockStateId}; type Pos = (i32, i32, i32); @@ -40,6 +37,8 @@ enum Kind { /// `AbstractFurnaceBlockEntity` (a `WorldlyContainer`). Furnace, Hopper, + /// `CrafterBlockEntity`: disabled slots and the smallest-stack-first rule. + Crafter, } /// A container: one block entity, or a double chest (`CompoundContainer`). @@ -72,11 +71,6 @@ impl View { } } -thread_local! { - /// Entity-owned randomness (projectile spread), separate from the level random. - static ENTITY_RANDOM: std::cell::RefCell = std::cell::RefCell::new(LegacyRandom::new(0x0d15_7e45)); -} - fn dir_from_name(name: &str) -> Option { Some(match name { "down" => Direction::Down, @@ -145,6 +139,7 @@ impl Containers<'_> { let name = self.name(state); let kind = match (entity, name) { (BlockEntity::Furnace(_), _) => Kind::Furnace, + (BlockEntity::Crafter(_), _) => Kind::Crafter, (_, "minecraft:hopper") => Kind::Hopper, _ => Kind::Generic, }; @@ -212,6 +207,12 @@ impl Containers<'_> { } /// `Container.canPlaceItem` (+ `canPlaceItemThroughFace` for furnaces). fn can_place(&self, view: &View, slot: usize, stack: &ItemStack) -> bool { + if view.kind == Kind::Crafter { + return match self.world.block_entities.get(&view.parts[0].0) { + Some(BlockEntity::Crafter(c)) => c.can_place(slot, stack, self.max_stack(stack)), + _ => false, + }; + } if view.kind != Kind::Furnace { return true; } @@ -246,6 +247,13 @@ impl Containers<'_> { } /// `AbstractContainerMenu.getRedstoneSignalFromContainer`. fn signal(&self, view: &View) -> i32 { + if view.kind == Kind::Crafter { + // CrafterBlockEntity.getRedstoneSignal: filled or disabled slots. + return match self.world.block_entities.get(&view.parts[0].0) { + Some(BlockEntity::Crafter(c)) => c.redstone_signal(), + _ => 0, + }; + } let mut total = 0.0f32; for i in 0..view.len() { if let Some(s) = self.get(view, i) { @@ -304,10 +312,16 @@ impl Game<'_> { if pos.1 == super::minecarts::CART_KEY_Y { return; } - self.world.modified.insert((pos.0 >> 4, pos.2 >> 4)); - self.with_level(|b, level, ticks| { - b.container_changed(level, ticks, BlockPos::new(pos.0, pos.1, pos.2)) - }); + // A double chest's other half changes with it. + let halves: Vec = std::iter::once(pos) + .chain(self.chest_other_half(pos)) + .collect(); + for pos in halves { + self.world.modified.insert((pos.0 >> 4, pos.2 >> 4)); + self.with_level(|b, level, ticks| { + b.container_changed(level, ticks, BlockPos::new(pos.0, pos.1, pos.2)) + }); + } } /// `HopperBlockEntity.tryMoveInItem`. fn try_move_in_item( @@ -567,6 +581,9 @@ impl Game<'_> { pub(super) fn dispense_from(&mut self, pos: BlockPos, state: BlockStateId) -> Result<()> { let key = (pos.x, pos.y, pos.z); let name = self.res.facts.get(state).name.clone(); + if &*name == "minecraft:crafter" { + return self.crafter_dispense(pos, state); + } let dropper = &*name == "minecraft:dropper"; if !dropper && &*name != "minecraft:dispenser" { return Ok(()); @@ -585,14 +602,8 @@ impl Game<'_> { odds += 1; } } - let center = [ - f64::from(pos.x) + 0.5, - f64::from(pos.y) + 0.5, - f64::from(pos.z) + 0.5, - ]; let Some(slot) = slot else { - self.audio - .play("minecraft:block.dispenser.fail", Some(center), 1.0, 1.2); + self.dispenser_event(1001, key, 0); return Ok(()); }; let Some(facing) = self @@ -608,7 +619,7 @@ impl Game<'_> { let target = offset(key, facing); let remaining = if dropper { match self.containers().view(target, false) { - None => self.default_dispense(key, facing, stack), + None => self.dispense_default(key, facing, stack), Some(into) => { let one = ItemStack { count: 1, @@ -630,7 +641,7 @@ impl Game<'_> { } } } else { - self.dispense_behaviour(key, facing, stack)? + self.dispense_item(key, facing, stack)? }; if let Some(entry) = self.slot_mut_at(&view, slot) { *entry = remaining; @@ -638,367 +649,6 @@ impl Game<'_> { self.container_changed(key); Ok(()) } - /// `DefaultDispenseItemBehavior.dispense`: drop one item, click and smoke. - fn default_dispense( - &mut self, - pos: Pos, - facing: Direction, - mut stack: ItemStack, - ) -> Option { - let one = ItemStack { - count: 1, - ..stack.clone() - }; - stack.count -= 1; - self.spawn_dispensed(pos, facing, one, 6); - self.dispenser_sound(pos, "minecraft:block.dispenser.dispense", 1.0); - (stack.count > 0).then_some(stack) - } - fn dispenser_sound(&mut self, pos: Pos, sound: &str, pitch: f32) { - let center = [ - f64::from(pos.0) + 0.5, - f64::from(pos.1) + 0.5, - f64::from(pos.2) + 0.5, - ]; - self.audio.play(sound, Some(center), 1.0, pitch); - } - /// `DefaultDispenseItemBehavior.spawnItem` at `DispenserBlock.getDispensePosition`. - fn spawn_dispensed(&mut self, pos: Pos, facing: Direction, stack: ItemStack, accuracy: i32) { - let s = step(facing); - let mut at = [ - f64::from(pos.0) + 0.5 + 0.7 * f64::from(s[0]), - f64::from(pos.1) + 0.5 + 0.7 * f64::from(s[1]), - f64::from(pos.2) + 0.5 + 0.7 * f64::from(s[2]), - ]; - at[1] -= if s[1] != 0 { 0.125 } else { 0.156_25 }; - let r = &mut self.world.random; - // new ItemEntity(level, x, y, z, stack): its default motion draws first. - let _ = (r.next_double(), r.next_double()); - let pow = r.next_double() * 0.1 + 0.2; - let spread = 0.017_227_5 * f64::from(accuracy); - let v = [ - r.triangle(f64::from(s[0]) * pow, spread), - r.triangle(0.2, spread), - r.triangle(f64::from(s[2]) * pow, spread), - ]; - self.spawn_item(stack, at, v, 0); - } - /// `DefaultDispenseItemBehavior.consumeWithRemainder`. - fn consume_with_remainder( - &mut self, - pos: Pos, - facing: Direction, - mut stack: ItemStack, - remainder: ItemStack, - ) -> Option { - stack.count -= 1; - if stack.count == 0 { - return Some(remainder); - } - // DispenserBlockEntity.insertItem, then drop what does not fit. - let mut rest = remainder; - if let Some(view) = self.containers().view(pos, false) { - let max = self.containers().max_stack(&rest); - for i in 0..view.len() { - let Some(entry) = self.slot_mut_at(&view, i) else { - continue; - }; - match entry { - None => { - let n = rest.count.min(max); - *entry = Some(ItemStack { - count: n, - ..rest.clone() - }); - rest.count -= n; - } - Some(e) if e.item == rest.item && e.damage == rest.damage => { - let n = rest.count.min(max.saturating_sub(e.count)); - e.count += n; - rest.count -= n; - } - Some(_) => {} - } - if rest.count == 0 { - break; - } - } - } - if rest.count > 0 { - self.spawn_dispensed(pos, facing, rest, 6); - self.dispenser_sound(pos, "minecraft:block.dispenser.dispense", 1.0); - } - Some(stack) - } - /// `DispenserBlock.getDispenseMethod(..).dispense(source, stack)`. - fn dispense_behaviour( - &mut self, - pos: Pos, - facing: Direction, - stack: ItemStack, - ) -> Result> { - let target = offset(pos, facing); - let target_pos = BlockPos::new(target.0, target.1, target.2); - let item = stack.item.to_string(); - let result = match item.as_str() { - "minecraft:bone_meal" => { - let grown = self.with_level(|b, level, ticks| { - b.grow_crop(level, ticks, target_pos) - || b.grow_water_plant(level, ticks, target_pos, None) - }); - self.process_level_events()?; - if grown { - self.dispenser_sound(pos, "minecraft:block.dispenser.dispense", 1.0); - self.audio.play( - "minecraft:item.bone_meal.use", - Some([ - f64::from(target.0) + 0.5, - f64::from(target.1) + 0.5, - f64::from(target.2) + 0.5, - ]), - 1.0, - 1.0, - ); - Some(ItemStack { - count: stack.count - 1, - ..stack - }) - .filter(|s| s.count > 0) - } else { - self.dispenser_sound(pos, "minecraft:block.dispenser.fail", 1.2); - Some(stack) - } - } - "minecraft:tnt" => { - self.spawn_primed_tnt(target_pos, false); - self.dispenser_sound(pos, "minecraft:block.dispenser.dispense", 1.0); - Some(ItemStack { - count: stack.count - 1, - ..stack - }) - .filter(|s| s.count > 0) - } - "minecraft:flint_and_steel" => { - let target_state = self.world.block(target.0, target.1, target.2); - let target_name = self.res.facts.get(target_state).name.clone(); - let fire = self.res.assets.registry.default_state("minecraft:fire"); - let success = if self.res.facts.is_air(target_state) - && let Some(fire) = fire - && self - .with_level(|b, level, ticks| b.can_survive(level, ticks, target_pos, fire)) - { - self.level_set([target.0, target.1, target.2], fire)?; - true - } else if &*target_name == "minecraft:tnt" { - self.spawn_primed_tnt(target_pos, false); - self.with_level(|b, level, ticks| { - b.remove_block(level, ticks, target_pos, false) - }); - self.process_level_events()?; - true - } else if self.containers().prop(target_state, "lit") == Some("false") - && (target_name.contains("campfire") || target_name.contains("candle")) - && self.containers().prop(target_state, "waterlogged") != Some("true") - { - let lit = self - .res - .assets - .registry - .state(target_state) - .cloned() - .and_then(|mut s| { - s.properties.insert("lit".into(), "true".into()); - self.res.assets.registry.resolve(&s).ok() - }); - if let Some(lit) = lit { - self.level_set([target.0, target.1, target.2], lit)?; - } - true - } else { - false - }; - self.dispenser_sound( - pos, - if success { - "minecraft:block.dispenser.dispense" - } else { - "minecraft:block.dispenser.fail" - }, - if success { 1.0 } else { 1.2 }, - ); - let mut stack = stack; - if success { - stack.damage += 1; - let max = self.res.items.get(&stack.item).map_or(0, |i| i.max_damage); - if max > 0 && stack.damage >= max { - return Ok(None); - } - } - Some(stack) - } - "minecraft:water_bucket" | "minecraft:lava_bucket" => { - let fluid = if item == "minecraft:water_bucket" { - "minecraft:water" - } else { - "minecraft:lava" - }; - let target_state = self.world.block(target.0, target.1, target.2); - let f = self.res.facts.get(target_state).clone(); - let waterloggable = item == "minecraft:water_bucket" - && self.containers().prop(target_state, "waterlogged") == Some("false"); - if waterloggable { - let wet = self - .res - .assets - .registry - .state(target_state) - .cloned() - .and_then(|mut s| { - s.properties.insert("waterlogged".into(), "true".into()); - self.res.assets.registry.resolve(&s).ok() - }); - if let Some(wet) = wet { - self.level_set([target.0, target.1, target.2], wet)?; - } - self.consume_with_remainder( - pos, - facing, - stack, - ItemStack { - item: "minecraft:bucket".into(), - count: 1, - damage: 0, - extra: None, - }, - ) - } else if (self.res.facts.is_air(target_state) || f.replaceable) - && !(f.fluid_level == 8 && !f.fluid_falling && &*f.name == fluid) - && let Some(source) = self.res.assets.registry.default_state(fluid) - { - self.level_set([target.0, target.1, target.2], source)?; - let sound = if fluid == "minecraft:water" { - "minecraft:item.bucket.empty" - } else { - "minecraft:item.bucket.empty_lava" - }; - self.audio.play( - sound, - Some([ - f64::from(target.0) + 0.5, - f64::from(target.1) + 0.5, - f64::from(target.2) + 0.5, - ]), - 1.0, - 1.0, - ); - self.dispenser_sound(pos, "minecraft:block.dispenser.dispense", 1.0); - self.consume_with_remainder( - pos, - facing, - stack, - ItemStack { - item: "minecraft:bucket".into(), - count: 1, - damage: 0, - extra: None, - }, - ) - } else { - self.default_dispense(pos, facing, stack) - } - } - "minecraft:bucket" => { - let target_state = self.world.block(target.0, target.1, target.2); - let f = self.res.facts.get(target_state).clone(); - let picked = if f.waterlogged - && self.containers().prop(target_state, "waterlogged") == Some("true") - { - let dry = self - .res - .assets - .registry - .state(target_state) - .cloned() - .and_then(|mut s| { - s.properties.insert("waterlogged".into(), "false".into()); - self.res.assets.registry.resolve(&s).ok() - }); - if let Some(dry) = dry { - self.level_set([target.0, target.1, target.2], dry)?; - } - Some("minecraft:water_bucket") - } else if f.fluid_level == 8 - && !f.fluid_falling - && matches!(&*f.name, "minecraft:water" | "minecraft:lava") - { - self.level_set([target.0, target.1, target.2], self.world.air)?; - Some(if &*f.name == "minecraft:water" { - "minecraft:water_bucket" - } else { - "minecraft:lava_bucket" - }) - } else if &*f.name == "minecraft:powder_snow" { - self.level_set([target.0, target.1, target.2], self.world.air)?; - Some("minecraft:powder_snow_bucket") - } else { - None - }; - match picked { - Some(filled) => { - self.dispenser_sound(pos, "minecraft:block.dispenser.dispense", 1.0); - self.consume_with_remainder( - pos, - facing, - stack, - ItemStack { - item: filled.into(), - count: 1, - damage: 0, - extra: None, - }, - ) - } - None => self.default_dispense(pos, facing, stack), - } - } - "minecraft:arrow" | "minecraft:spectral_arrow" | "minecraft:tipped_arrow" => { - // ProjectileDispenseBehavior: power 1.1, uncertainty 6, from 0.7 ahead and 0.1 up. - let s = step(facing); - let at = Vec3::new( - f64::from(pos.0) + 0.5 + 0.7 * f64::from(s[0]), - f64::from(pos.1) + 0.5 + 0.7 * f64::from(s[1]) + 0.1, - f64::from(pos.2) + 0.5 + 0.7 * f64::from(s[2]), - ); - let spread = 0.017_227_5 * 6.0; - let v = ENTITY_RANDOM.with(|r| { - let r = &mut *r.borrow_mut(); - [ - (f64::from(s[0]) + r.triangle(0.0, spread)) * 1.1, - (f64::from(s[1]) + r.triangle(0.0, spread)) * 1.1, - (f64::from(s[2]) + r.triangle(0.0, spread)) * 1.1, - ] - }); - self.arrows.push(Arrow { - from_player: true, - critical: false, - position: at, - previous: at, - velocity: Vec3::new(v[0], v[1], v[2]), - stuck: false, - age: 0, - base_damage: 2.0, - }); - self.dispenser_sound(pos, "minecraft:block.dispenser.launch", 1.2); - Some(ItemStack { - count: stack.count - 1, - ..stack - }) - .filter(|s| s.count > 0) - } - _ => self.default_dispense(pos, facing, stack), - }; - Ok(result) - } } // ---- hopper, dispenser and dropper screens ---- @@ -1035,6 +685,13 @@ impl Game<'_> { { return super::beacon::HEIGHT; } + if let Some(rows) = self.chest_rows() { + // ContainerScreen: 114 + 18 per row. + return 114.0 + rows as f32 * 18.0; + } + if self.container_block_is_shulker() { + return 167.0; + } if self.machine_screen() == Some(Screen::Hopper) { 133.0 } else { @@ -1070,7 +727,13 @@ impl Game<'_> { return false; }; let atlas = &self.res.atlas; + let key_is_cart = self + .container + .is_some_and(|k| k.1 == super::minecarts::CART_KEY_Y); let (texture, height, title) = match screen { + Screen::Hopper if key_is_cart => { + ("gui/container/hopper", 133.0, "Minecart with Hopper") + } Screen::Hopper => ("gui/container/hopper", 133.0, "Item Hopper"), Screen::Dispenser => ("gui/container/dispenser", 166.0, "Dispenser"), Screen::Dropper => ("gui/container/dispenser", 166.0, "Dropper"), diff --git a/crates/horizon-client/src/game/machines/crafter.rs b/crates/horizon-client/src/game/machines/crafter.rs new file mode 100644 index 000000000..0d1432526 --- /dev/null +++ b/crates/horizon-client/src/game/machines/crafter.rs @@ -0,0 +1,432 @@ +//! The crafter (`CrafterBlock`, `CrafterBlockEntity`, `CrafterMenu`, +//! `CrafterScreen`): redstone-triggered crafting of its 3x3 grid, ejecting +//! the result and remainders into the container in front or as items, the +//! crafting animation ticks, and the menu with its toggleable slots. +use super::*; +use horizon_client::{ + advancements as adv, + containers::Crafter, + hud::{HudBatch, rgba}, + particles::{ParticleOptions, ParticleType}, +}; +use serde_json::Value; + +/// `CrafterBlock`'s crafting animation length. +const CRAFTING_TICKS: i32 = 6; +const RESULT_SLOT: usize = 309; + +fn center(pos: Pos) -> [f64; 3] { + [ + f64::from(pos.0) + 0.5, + f64::from(pos.1) + 0.5, + f64::from(pos.2) + 0.5, + ] +} +/// Whether an advancement condition's `recipes` entry names the recipe. +fn recipe_matches(condition: &Value, id: &str) -> bool { + match condition { + Value::String(s) => s == id, + Value::Array(list) => list.iter().any(|v| v.as_str() == Some(id)), + _ => true, + } +} + +impl Game<'_> { + /// `Level.setBlock` of one boolean property of the block at `pos`. + fn set_bool_prop(&mut self, pos: Pos, key: &str, value: bool, flags: i32) { + let registry = self.res.assets.registry; + let old = self.world.block(pos.0, pos.1, pos.2); + let Some(mut state) = registry.state(old).cloned() else { + return; + }; + if !state.properties.contains_key(key) { + return; + } + state.properties.insert(key.to_owned(), value.to_string()); + let Ok(id) = registry.resolve(&state) else { + return; + }; + self.with_level(|b, level, ticks| { + b.set_block(level, ticks, BlockPos::new(pos.0, pos.1, pos.2), id, flags) + }); + let _ = self.process_level_events(); + } + fn crafter_at(&self, pos: Pos) -> Option<&Crafter> { + match self.world.block_entities.get(&pos)? { + BlockEntity::Crafter(c) => Some(c), + _ => None, + } + } + /// `CrafterBlockEntity.serverTick` for every crafter, and the powered + /// flag following the block state. + pub(in crate::game) fn tick_crafters(&mut self) { + let positions: Vec = self + .world + .block_entities + .iter() + .filter(|(_, e)| matches!(e, BlockEntity::Crafter(_))) + .map(|(p, _)| *p) + .collect(); + for pos in positions { + let state = self.world.block(pos.0, pos.1, pos.2); + let triggered = self.containers().prop(state, "triggered") == Some("true"); + let mut finished = false; + if let Some(BlockEntity::Crafter(c)) = self.world.block_entities.get_mut(&pos) { + c.triggered = triggered; + let remaining = c.crafting_ticks - 1; + if remaining >= 0 { + c.crafting_ticks = remaining; + finished = remaining == 0; + } + } + if finished { + self.set_bool_prop( + pos, + "crafting", + false, + horizon_world::level::flags::UPDATE_ALL, + ); + } + } + } + /// `CrafterBlock.dispenseFrom` (the scheduled tick after a redstone pulse). + pub(super) fn crafter_dispense(&mut self, pos: BlockPos, state: BlockStateId) -> Result<()> { + let key = (pos.x, pos.y, pos.z); + let Some(crafter) = self.crafter_at(key) else { + return Ok(()); + }; + let grid: Vec> = crafter.items.to_vec(); + let found = self + .res + .recipes + .find(&grid, 3) + .map(|(name, result)| (name.to_owned(), result)) + .filter(|(_, result)| result.count > 0); + let Some((recipe, result)) = found else { + // LevelEvent 1050: CRAFTER_FAIL. + self.audio + .play("minecraft:block.crafter.fail", Some(center(key)), 1.0, 1.0); + return Ok(()); + }; + let Some(facing) = self + .containers() + .prop(state, "orientation") + .and_then(|o| o.split('_').next()) + .and_then(dir_from_name) + else { + return Ok(()); + }; + if let Some(BlockEntity::Crafter(c)) = self.world.block_entities.get_mut(&key) { + c.crafting_ticks = CRAFTING_TICKS; + } + self.set_bool_prop( + key, + "crafting", + true, + horizon_world::level::flags::UPDATE_CLIENTS, + ); + let remainders = self.res.recipes.remainders(&self.res.items, &grid, &result); + self.crafter_eject(key, facing, result, &recipe); + for rest in remainders.into_iter().flatten() { + self.crafter_eject(key, facing, rest, &recipe); + } + if let Some(BlockEntity::Crafter(c)) = self.world.block_entities.get_mut(&key) { + for slot in c.items.iter_mut() { + if let Some(s) = slot { + s.count -= 1; + if s.count == 0 { + *slot = None; + } + } + } + } + self.container_changed(key); + Ok(()) + } + /// `CrafterBlock.dispenseItem`: into the container in front, else out as an item. + fn crafter_eject(&mut self, pos: Pos, facing: Direction, stack: ItemStack, recipe: &str) { + let target = offset(pos, facing); + let mut rest = stack; + if let Some(into) = self.containers().view(target, false) { + let one_by_one = self.crafter_at(target).is_some() + || rest.count > self.containers().max_stack(&rest); + while rest.count > 0 { + let before = rest.count; + if one_by_one { + let one = ItemStack { + count: 1, + ..rest.clone() + }; + if self + .add_item(None, &into, one, Some(facing.opposite())) + .is_some() + { + break; + } + rest.count -= 1; + } else { + match self.add_item(None, &into, rest.clone(), Some(facing.opposite())) { + Some(left) => rest = left, + None => rest.count = 0, + } + if rest.count == before { + break; + } + } + } + } + if rest.count == 0 { + return; + } + self.spawn_dispensed(pos, facing, rest, 6); + // LevelEvent 1049 (CRAFTER_CRAFT) and 2010 (white smoke shot out the front). + self.audio + .play("minecraft:block.crafter.craft", Some(center(pos)), 1.0, 1.0); + let s = step(facing); + for _ in 0..10 { + let r = &mut self.world.random; + let pow = r.next_double() * 0.2 + 0.01; + let at = [ + f64::from(pos.0) + + f64::from(s[0]) * 0.6 + + 0.5 + + f64::from(s[0]) * 0.01 + + (r.next_double() - 0.5) * f64::from(s[2]) * 0.5, + f64::from(pos.1) + + f64::from(s[1]) * 0.6 + + 0.5 + + f64::from(s[1]) * 0.01 + + (r.next_double() - 0.5) * f64::from(s[1]) * 0.5, + f64::from(pos.2) + + f64::from(s[2]) * 0.6 + + 0.5 + + f64::from(s[2]) * 0.01 + + (r.next_double() - 0.5) * f64::from(s[0]) * 0.5, + ]; + let v = [ + f64::from(s[0]) * pow + r.next_gaussian() * 0.01, + f64::from(s[1]) * pow + r.next_gaussian() * 0.01, + f64::from(s[2]) * pow + r.next_gaussian() * 0.01, + ]; + self.particles + .add(&ParticleOptions::simple(ParticleType::WhiteSmoke), at, v); + } + // CrafterRecipeCraftedTrigger for players within the 17-block box. + let near = self.eye_position().is_some_and(|e| { + let c = center(pos); + (0..3).all(|i| (e[i] - c[i]).abs() <= 8.5 + 1.0) + }); + if near { + let id = format!("minecraft:{recipe}"); + let me = self.player_entity(); + self.trigger("minecraft:crafter_recipe_crafted", move |c, w| { + let ctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &ctx, w) && recipe_matches(&c["recipes"], &id) + }); + } + } + + // ---- the menu ---- + + /// The grid's current recipe result (`CrafterMenu.refreshRecipeResult`). + pub(in crate::game) fn crafter_result(&self) -> Option { + let key = self.container?; + let c = self.crafter_at(key)?; + self.res.recipes.craft(&c.items, 3) + } + fn crafter_open(&self) -> bool { + matches!(self.container_kind(), Some(BlockEntity::Crafter(_))) + } + /// `CrafterMenu` slot layout: the grid at (26, 17), the result at (134, 35). + pub(in crate::game) fn crafter_slot_position(&self, i: usize) -> Option<(f32, f32)> { + if !self.crafter_open() { + return None; + } + match i { + 300..309 => Some(( + 26.0 + ((i - 300) % 3) as f32 * 18.0, + 17.0 + ((i - 300) / 3) as f32 * 18.0, + )), + RESULT_SLOT => Some((134.0, 35.0)), + _ => None, + } + } + /// `CrafterScreen`'s background, title, disabled slots and powered arrow. + pub(in crate::game) fn draw_crafter_screen(&self, batch: &mut HudBatch, ox: f32, oy: f32) { + let Some(c) = self.container.and_then(|k| self.crafter_at(k)) else { + return; + }; + let atlas = &self.res.atlas; + batch.sprite_region( + atlas, + "gui/container/crafter", + [ox, oy, 176.0, 166.0], + 256.0, + 256.0, + ); + let grey = rgba(64, 64, 64, 255); + let title = self.translate("container.crafter", "Crafter"); + let tw = HudBatch::text_width(atlas, &title); + batch.text( + atlas, + &title, + ox + (176.0 - tw) / 2.0, + oy + 6.0, + grey, + false, + ); + batch.text(atlas, "Inventory", ox + 8.0, oy + 72.0, grey, false); + for slot in 0..9 { + if c.disabled[slot] { + let (x, y) = self.crafter_slot_position(300 + slot).unwrap_or_default(); + batch.sprite( + atlas, + "gui/sprites/container/crafter/disabled_slot", + ox + x - 1.0, + oy + y - 1.0, + ); + } + } + let powered = self + .container + .map(|k| self.world.block(k.0, k.1, k.2)) + .is_some_and(|state| self.containers().prop(state, "triggered") == Some("true")); + let arrow = if powered { + "powered_redstone" + } else { + "unpowered_redstone" + }; + batch.sprite( + atlas, + &format!("gui/sprites/container/crafter/{arrow}"), + ox + 97.0, + oy + 35.0, + ); + } + /// `gui.togglable_slot` over an empty, enabled grid slot. + pub(in crate::game) fn crafter_tooltip(&self, slot: usize) -> Option { + let c = self.container.and_then(|k| self.crafter_at(k))?; + let i = slot.checked_sub(300).filter(|i| *i < 9)?; + (self.carried.is_none() && c.items[i].is_none() && !c.disabled[i] && !self.spectator()) + .then(|| self.translate("gui.togglable_slot", "Click to disable slot")) + } + /// A click in the crafter menu before the generic handling; true when + /// it was fully handled (the result, shift-clicks). + pub(in crate::game) fn crafter_click(&mut self, slot: usize, shift: bool) -> bool { + if !self.crafter_open() { + return false; + } + if slot == RESULT_SLOT { + return true; + } + if (300..309).contains(&slot) { + // CrafterScreen.slotClicked: toggle an empty slot. + let i = slot - 300; + if !shift && !self.spectator() && self.slot_mut(slot).is_none() { + let carried_empty = self.carried.is_none(); + let key = self.container; + let mut toggled = None; + if let Some(BlockEntity::Crafter(c)) = + key.and_then(|k| self.world.block_entities.get_mut(&k)) + { + if c.disabled[i] { + c.set_slot_state(i, true); + toggled = Some(true); + } else if carried_empty { + c.set_slot_state(i, false); + toggled = Some(false); + } + } + if let Some(enabled) = toggled { + let pitch = if enabled { 1.0 } else { 0.75 }; + self.audio + .play("minecraft:ui.button.click", None, 0.4, pitch); + } + } + } + if shift { + self.crafter_quick_move(slot); + return true; + } + false + } + /// `CrafterMenu.quickMoveStack`. + fn crafter_quick_move(&mut self, slot: usize) { + if slot >= 309 { + return; + } + let Some(mut stack) = self.slot_mut(slot).take() else { + return; + }; + if slot >= 300 { + let player: Vec = (9..36).chain(0..9).collect(); + self.move_to(&mut stack, &player, true); + } else { + let grid: Vec = (300..309).collect(); + self.move_to(&mut stack, &grid, false); + } + if stack.count > 0 { + *self.slot_mut(slot) = Some(stack); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn stack(item: &str, count: u32) -> Option { + Some(ItemStack::new(item, count)) + } + #[test] + fn signal_counts_filled_and_disabled_slots() { + let mut c = Crafter::default(); + assert_eq!(c.redstone_signal(), 0); + c.items[0] = stack("minecraft:stick", 3); + c.set_slot_state(4, false); + assert_eq!(c.redstone_signal(), 2); + // A filled slot cannot be disabled. + c.set_slot_state(0, false); + assert!(!c.disabled[0]); + c.set_slot_state(4, true); + assert_eq!(c.redstone_signal(), 1); + } + #[test] + fn hoppers_fill_the_smaller_stacks_first() { + let mut c = Crafter::default(); + let stick = ItemStack::new("minecraft:stick", 1); + c.items[0] = stack("minecraft:stick", 2); + c.items[1] = stack("minecraft:stick", 1); + // A later empty slot counts as smaller: stacks level out front to back. + assert!(!c.can_place(0, &stick, 64)); + assert!(!c.can_place(1, &stick, 64)); + assert!(c.can_place(2, &stick, 64)); + c.disabled[5] = true; + assert!(!c.can_place(5, &stick, 64)); + // With every later slot at least as big, a slot accepts again. + for i in 2..9 { + c.items[i] = stack("minecraft:stick", 2); + } + assert!(c.can_place(1, &stick, 64)); + // A full stack accepts nothing. + c.items[2] = stack("minecraft:stick", 64); + assert!(!c.can_place(2, &stick, 64)); + } + #[test] + fn recipes_condition_accepts_a_name_or_a_list() { + assert!(recipe_matches( + &serde_json::json!("minecraft:crafter"), + "minecraft:crafter" + )); + assert!(!recipe_matches( + &serde_json::json!(["minecraft:stick"]), + "minecraft:crafter" + )); + assert!(recipe_matches(&Value::Null, "minecraft:crafter")); + } +} diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 259758994..6f2b00da7 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -90,7 +90,7 @@ const SEAT: f64 = 0.1875 - 0.6; pub(super) const CART_KEY_Y: i32 = -100_000; #[derive(Clone, Copy, PartialEq, Eq, Debug)] -enum Shape { +pub(super) enum Shape { NorthSouth, EastWest, AscendingEast, @@ -117,7 +117,7 @@ impl Shape { _ => Self::NorthSouth, } } - fn is_slope(self) -> bool { + pub(super) fn is_slope(self) -> bool { matches!( self, Self::AscendingEast | Self::AscendingWest | Self::AscendingNorth | Self::AscendingSouth @@ -141,9 +141,9 @@ impl Shape { } } } -struct Rail { +pub(super) struct Rail { name: Arc, - shape: Shape, + pub(super) shape: Shape, powered: bool, } impl Minecart { @@ -203,7 +203,7 @@ impl CartModels { } } impl Game<'_> { - fn rail(&self, x: i32, y: i32, z: i32) -> Option { + pub(super) fn rail(&self, x: i32, y: i32, z: i32) -> Option { let state = self.world.block(x, y, z); let name = self.res.facts.get(state).name.clone(); if !matches!( @@ -1238,6 +1238,7 @@ impl Game<'_> { nether: self.dim == super::Dim::Nether, lid: &lid, sign: &|_| None, + banner: &|_| Vec::new(), glyph: &|c| self.res.atlas.glyph(c), }; self.res diff --git a/crates/horizon-client/src/game/mount_menu.rs b/crates/horizon-client/src/game/mount_menu.rs new file mode 100644 index 000000000..3e33872cb --- /dev/null +++ b/crates/horizon-client/src/game/mount_menu.rs @@ -0,0 +1,455 @@ +//! The horse inventory (`HorseInventoryMenu`, `HorseInventoryScreen`): the +//! saddle and body armour slots, the 3x5 chest of donkeys and mules and the +//! mount drawn following the cursor. It opens with E while riding a tamed +//! mount or with shift + use on a tamed one. +use super::{Game, Screen}; +use horizon_client::{ + hud::{HudBatch, rgba}, + items::ItemStack, + mobs::{Mob, Species, equine}, +}; + +/// Menu slot ids: the saddle, the body armour and the chest from 710. +pub(super) const SADDLE: usize = 700; +pub(super) const ARMOR: usize = 701; +pub(super) const CHEST: usize = 710; +/// `AbstractChestedHorse.INV_CHEST_COUNT` and `getInventoryColumns`. +const CHEST_SIZE: usize = 15; +const COLUMNS: usize = 5; + +/// The open mount menu: copies of the mount's slots, written back on every change. +#[derive(Default)] +pub(super) struct MountMenu { + open: Option, +} +struct Open { + mob: u32, + species: Species, + columns: usize, + saddle: Option, + armor: Option, + items: Vec>, + /// `shouldRenderSaddleSlot` / `shouldRenderArmorSlot`. + show_saddle: bool, + show_armor: bool, +} + +/// `EntityTypeTags.CAN_WEAR_HORSE_ARMOR`. +fn can_wear_horse_armor(species: Species) -> bool { + matches!(species, Species::Horse | Species::ZombieHorse) +} +/// Whether `item` fits the body slot of the species (`isEquippableInSlot`). +fn body_armor_fits(species: Species, item: &str) -> bool { + can_wear_horse_armor(species) && item.ends_with("_horse_armor") +} + +impl Game<'_> { + /// Whether the mount menu is the open screen. + pub(super) fn mount_active(&self) -> bool { + self.screen == Screen::Inventory && self.mount_menu.open.is_some() + } + fn mount_mob_index(&self, id: u32) -> Option { + self.mobs.iter().position(|m| m.id == id) + } + /// `AbstractHorse.openCustomInventoryScreen` for a tamed adult mount. + pub(super) fn open_mount_menu(&mut self, index: usize) { + let m = &self.mobs[index]; + let species = m.species(); + if !equine::is_equine(species) { + return; + } + let chested = m.extra.chested && matches!(species, Species::Donkey | Species::Mule); + let columns = if chested { COLUMNS } else { 0 }; + let mut items = m.extra.items.clone(); + items.resize(CHEST_SIZE, None); + let show_armor = can_wear_horse_armor(species); + self.mount_menu.open = Some(Open { + mob: m.id, + species, + columns, + saddle: m + .extra + .saddled + .then(|| ItemStack::new("minecraft:saddle", 1)), + armor: m + .extra + .head + .as_deref() + .filter(|_| show_armor) + .map(|i| ItemStack::new(i, 1)), + items, + show_saddle: true, + show_armor, + }); + self.carried = None; + self.station = None; + self.container = None; + self.craft_size = 2; + self.screen = Screen::Inventory; + self.capture(false); + } + /// E while riding a tamed mount opens its inventory instead of the player's. + pub(super) fn open_ridden_mount_menu(&mut self) -> bool { + let Some(id) = self.riding else { + return false; + }; + let Some(index) = self.mount_mob_index(id) else { + return false; + }; + let m = &self.mobs[index]; + if !equine::is_equine(m.species()) || !m.extra.tame || !m.alive() { + return false; + } + self.open_mount_menu(index); + true + } + /// The menu ends when the mount dies or is more than 4 blocks away + /// (`AbstractMountInventoryMenu.stillValid`). + pub(super) fn tick_mount_menu(&mut self) { + let Some(open) = self.mount_menu.open.as_ref() else { + return; + }; + let valid = self.mount_mob_index(open.mob).is_some_and(|i| { + let m = &self.mobs[i]; + let c = m.center(); + m.alive() + && self.eye_position().is_some_and(|e| { + let d = (e[0] - c[0]).powi(2) + (e[1] - c[1]).powi(2) + (e[2] - c[2]).powi(2); + d <= 16.0 + 4.0 + }) + }); + if !valid { + self.close_container(); + self.screen = Screen::Playing; + self.capture(true); + } + } + /// Closing the screen keeps what is in the slots on the mount. + pub(super) fn mount_closed(&mut self) { + self.mount_sync(); + self.mount_menu.open = None; + } + /// Writes the menu slots to the mount, with the equip sounds. + fn mount_sync(&mut self) { + let Some(open) = self.mount_menu.open.as_ref() else { + return; + }; + let Some(index) = self.mount_mob_index(open.mob) else { + return; + }; + let (saddle, armor) = (open.saddle.is_some(), open.armor.clone()); + let items = open.items.clone(); + let m = &mut self.mobs[index]; + let at = m.center(); + let sound = if saddle && !m.extra.saddled { + Some("minecraft:entity.horse.saddle") + } else if armor.is_some() && m.extra.head.is_none() { + Some("minecraft:entity.horse.armor") + } else { + None + }; + m.extra.saddled = saddle; + if open.show_armor { + m.extra.head = armor.map(|a| a.item); + } + m.extra.items = items; + let (x, z) = (at[0].floor() as i32 >> 4, at[2].floor() as i32 >> 4); + self.world.modified.insert((x, z)); + if let Some(sound) = sound { + self.audio.play(sound, Some(at), 0.5, 1.0); + } + } + pub(super) fn mount_slots(&self) -> Option> { + let open = self + .mount_menu + .open + .as_ref() + .filter(|_| self.mount_active())?; + let mut v: Vec = (0..36).collect(); + if open.show_saddle { + v.push(SADDLE); + } + if open.show_armor { + v.push(ARMOR); + } + v.extend((0..open.columns * 3).map(|i| CHEST + i)); + Some(v) + } + pub(super) fn mount_slot_position(&self, i: usize) -> Option<(f32, f32)> { + let open = self + .mount_menu + .open + .as_ref() + .filter(|_| self.mount_active())?; + match i { + SADDLE => Some((8.0, 18.0)), + ARMOR => Some((8.0, 36.0)), + _ if i >= CHEST => { + let n = i - CHEST; + (n < open.columns * 3).then(|| { + ( + 80.0 + (n % open.columns) as f32 * 18.0, + 18.0 + (n / open.columns) as f32 * 18.0, + ) + }) + } + _ => None, + } + } + pub(super) fn mount_slot_mut(&mut self, i: usize) -> &mut Option { + match self.mount_menu.open.as_mut() { + Some(open) if i == SADDLE => &mut open.saddle, + Some(open) if i == ARMOR => &mut open.armor, + Some(open) if i >= CHEST && i - CHEST < CHEST_SIZE => &mut open.items[i - CHEST], + _ => &mut self.scratch_slot, + } + } + /// `ArmorSlot.mayPlace` and the stack limits of the mount's slots. + pub(super) fn mount_slot_rules(&self, slot: usize, stack: &ItemStack) -> (bool, u32) { + let Some(open) = self.mount_menu.open.as_ref() else { + return (false, 64); + }; + match slot { + SADDLE => (&*stack.item == "minecraft:saddle", 1), + ARMOR => (body_armor_fits(open.species, &stack.item), 1), + _ => (true, 64), + } + } + /// A click in the mount menu before the generic handling. + pub(super) fn mount_click(&mut self, right: bool) -> bool { + if !self.mount_active() { + return false; + } + let Some(r) = self.renderer.as_ref() else { + return true; + }; + let batch = HudBatch::new([r.config.width, r.config.height]); + let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else { + return true; + }; + let shift = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft) + || self.keys.contains(&winit::keyboard::KeyCode::ShiftRight); + if shift { + self.mount_quick_move(slot); + } else if slot >= SADDLE { + self.click_filtered(slot, right); + } else { + return false; + } + self.mount_sync(); + true + } + /// The inventory slot ids in menu order. + fn mount_player_slots() -> Vec { + (9..36).chain(0..9).collect() + } + /// `AbstractMountInventoryMenu.quickMoveStack`. + fn mount_quick_move(&mut self, slot: usize) { + let Some(open) = self.mount_menu.open.as_ref() else { + return; + }; + let (columns, show_saddle, show_armor) = (open.columns, open.show_saddle, open.show_armor); + let Some(mut stack) = self.slot_mut(slot).take() else { + return; + }; + if slot >= SADDLE { + let player = Self::mount_player_slots(); + self.move_to(&mut stack, &player, true); + } else { + let armor_free = self.mount_slot_mut(ARMOR).is_none(); + let saddle_free = self.mount_slot_mut(SADDLE).is_none(); + let armor_ok = show_armor && self.mount_slot_rules(ARMOR, &stack).0 && armor_free; + let saddle_ok = show_saddle && self.mount_slot_rules(SADDLE, &stack).0 && saddle_free; + if armor_ok { + self.move_to(&mut stack, &[ARMOR], false); + } else if saddle_ok { + self.move_to(&mut stack, &[SADDLE], false); + } else { + let chest: Vec = (0..columns * 3).map(|i| CHEST + i).collect(); + let moved = columns > 0 && self.move_to(&mut stack, &chest, false); + if !moved { + // Between the hotbar and the main inventory. + let other: Vec = if slot < 9 { + (9..36).collect() + } else { + (0..9).collect() + }; + self.move_to(&mut stack, &other, false); + } + } + } + if stack.count > 0 { + *self.slot_mut(slot) = Some(stack); + } + } + /// `HorseInventoryScreen`'s background, slot frames and the mount. + pub(super) fn draw_mount_background(&self, batch: &mut HudBatch, ox: f32, oy: f32) { + let Some(open) = self.mount_menu.open.as_ref() else { + return; + }; + let atlas = &self.res.atlas; + batch.sprite_region( + atlas, + "gui/container/horse", + [ox, oy, 176.0, 166.0], + 256.0, + 256.0, + ); + if open.columns > 0 { + batch.sprite_region( + atlas, + "gui/sprites/container/horse/chest_slots", + [ox + 79.0, oy + 17.0, open.columns as f32 * 18.0, 54.0], + 90.0, + 54.0, + ); + } + if open.show_saddle { + batch.sprite(atlas, "gui/sprites/container/slot", ox + 7.0, oy + 17.0); + if open.saddle.is_none() { + batch.sprite( + atlas, + "gui/sprites/container/slot/saddle", + ox + 8.0, + oy + 18.0, + ); + } + } + if open.show_armor { + batch.sprite(atlas, "gui/sprites/container/slot", ox + 7.0, oy + 35.0); + if open.armor.is_none() { + batch.sprite( + atlas, + "gui/sprites/container/slot/horse_armor", + ox + 8.0, + oy + 36.0, + ); + } + } + let grey = rgba(64, 64, 64, 255); + let title = match self.mobs.iter().find(|m| m.id == open.mob) { + Some(m) => m.custom_name.clone().unwrap_or_else(|| { + let key = format!( + "entity.minecraft.{}", + m.kind.id.trim_start_matches("minecraft:") + ); + self.translate(&key, &key) + }), + None => String::new(), + }; + batch.text(atlas, &title, ox + 8.0, oy + 6.0, grey, false); + batch.text(atlas, "Inventory", ox + 8.0, oy + 72.0, grey, false); + if let Some(m) = self.mobs.iter().find(|m| m.id == open.mob) { + self.draw_mob_preview( + batch, + m, + ox + 26.0, + oy + 18.0, + ox + 78.0, + oy + 70.0, + 17.0, + 0.25, + ); + } + } + /// `extractEntityInInventoryFollowsMouse` for a mob: depth-sorted, + /// back-face-culled quads turned toward the cursor. + #[allow(clippy::too_many_arguments)] + fn draw_mob_preview( + &self, + batch: &mut HudBatch, + mob: &Mob, + x0: f32, + y0: f32, + x1: f32, + y1: f32, + size: f32, + offset_y: f32, + ) { + let (cx, cy) = ((x0 + x1) / 2.0, (y0 + y1) / 2.0); + let x_angle = ((cx - self.cursor.0) / 40.0).atan(); + let y_angle = ((cy - self.cursor.1) / 40.0).atan(); + let mut m = mob.clone(); + m.previous = m.position; + m.body_yaw = 180.0 + x_angle * 20.0; + m.previous_body_yaw = m.body_yaw; + m.head_yaw = m.body_yaw + x_angle * 20.0; + m.previous_head_yaw = m.head_yaw; + m.head_pitch = -y_angle * 20.0; + m.previous_head_pitch = m.head_pitch; + m.hurt_time = 0; + m.death_time = 0; + let camera = glam::DVec3::new(m.position.x, m.position.y, m.position.z); + let atlas = &self.res.atlas; + let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]); + let mut verts = Vec::new(); + horizon_client::mobs::render::render_with( + &m, + 1.0, + camera, + &lookup, + 240 | 240 << 8, + &self.res.mob_data, + &[], + &mut verts, + ); + let height = m.kind.height as f32; + let gui = glam::Mat4::from_translation(glam::Vec3::new(cx, cy, 0.0)) + * glam::Mat4::from_scale(glam::Vec3::new(size, size, -size)) + * glam::Mat4::from_translation(glam::Vec3::new(0.0, height / 2.0 + offset_y, 0.0)) + * glam::Mat4::from_rotation_z(std::f32::consts::PI) + * glam::Mat4::from_rotation_x((y_angle * 20.0).to_radians()); + let mut quads: Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], u32)> = Vec::new(); + for q in verts.as_chunks::<4>().0 { + let p: [glam::Vec3; 4] = + std::array::from_fn(|i| gui.transform_point3(glam::Vec3::from_array(q[i].pos))); + let n = (p[1] - p[0]).cross(p[2] - p[0]); + if n.z >= 0.0 { + continue; + } + let n = n.normalize_or_zero(); + let shade = (0.55 + 0.45 * -n.z - 0.15 * n.y).clamp(0.4, 1.0); + let c = q[0].color; + let ch = |s: u32| ((((c >> s) & 255) as f32 * shade) as u32) << s; + let color = (c & 0xFF00_0000) | ch(0) | ch(8) | ch(16); + let depth = p.iter().map(|v| v.z).sum::() / 4.0; + quads.push(( + depth, + p.map(|v| [v.x, v.y]), + std::array::from_fn(|i| q[i].uv), + color, + )); + } + quads.sort_by(|a, b| a.0.total_cmp(&b.0)); + let start = batch.vertices.len(); + for (_, p, uv, color) in quads { + batch.quad(p, uv, color); + } + batch.clip_since(start, x0, y0, x1, y1); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn only_horses_wear_horse_armour() { + assert!(body_armor_fits( + Species::Horse, + "minecraft:iron_horse_armor" + )); + assert!(body_armor_fits( + Species::ZombieHorse, + "minecraft:diamond_horse_armor" + )); + assert!(!body_armor_fits( + Species::Donkey, + "minecraft:iron_horse_armor" + )); + assert!(!body_armor_fits( + Species::Horse, + "minecraft:iron_chestplate" + )); + } +} diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs index e79f7ae6e..111f8d90e 100644 --- a/crates/horizon-client/src/game/mounts.rs +++ b/crates/horizon-client/src/game/mounts.rs @@ -99,6 +99,15 @@ impl Game<'_> { if !equine::is_equine(species) || !m.alive() || Some(m.id) == self.riding { return false; } + // AbstractHorse.mobInteract: shift + use opens a tamed adult's inventory. + if !m.is_baby() + && m.extra.tame + && (self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft) + || self.keys.contains(&winit::keyboard::KeyCode::ShiftRight)) + { + self.open_mount_menu(index); + return true; + } if self.feed_mount(index, item) { return true; } diff --git a/crates/horizon-client/src/game/persist.rs b/crates/horizon-client/src/game/persist.rs index bd7532ff2..aa0a3f46d 100644 --- a/crates/horizon-client/src/game/persist.rs +++ b/crates/horizon-client/src/game/persist.rs @@ -272,6 +272,14 @@ impl Game<'_> { pub(super) fn uuid_for(&mut self, id: u32) -> [i32; 4] { *self.persist.uuids.entry(id).or_insert_with(random_uuid) } + /// The loaded mob with a saved UUID. + pub(super) fn mob_id_for_uuid(&self, uuid: [i32; 4]) -> Option { + self.persist + .uuids + .iter() + .find(|(id, u)| **u == uuid && self.mobs.iter().any(|m| m.id == **id && !m.removed)) + .map(|(id, _)| *id) + } /// `BlockState.CODEC`: a block name or `{id, properties}` (or legacy `{Name, Properties}`). fn state_from_nbt(&self, tag: &Tag) -> Option { let registry = self.res.assets.registry; diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index ffa2c86da..00ed63cee 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -19,6 +19,18 @@ pub(super) struct ThrownPotion { velocity: Vec3, age: u32, } +impl Game<'_> { + /// A splash potion, lingering potion or experience bottle in flight (the + /// player's throws and dispensers both end up here). + pub(super) fn launch_thrown(&mut self, stack: ItemStack, position: Vec3, velocity: Vec3) { + self.potions.thrown.push(ThrownPotion { + stack, + position, + velocity, + age: 0, + }); + } +} /// Effects, thrown potions and the attribute modifiers last applied. #[derive(Default)] pub(super) struct PotionState { @@ -40,21 +52,25 @@ impl Game<'_> { /// Right-click with a potion, splash/lingering potion or glass bottle. pub(super) fn use_potion_item(&mut self, stack: &ItemStack) -> horizon_client::Result { match &*stack.item { - "minecraft:potion" => { + "minecraft:potion" | "minecraft:ominous_bottle" => { if self.using.is_none() { self.using = Some((self.selected, 0)); } Ok(true) } - "minecraft:splash_potion" | "minecraft:lingering_potion" => { + "minecraft:splash_potion" + | "minecraft:lingering_potion" + | "minecraft:experience_bottle" => { let Some(eye) = self.eye_position() else { return Ok(true); }; let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8); - let sound = if &*stack.item == "minecraft:splash_potion" { - "minecraft:entity.splash_potion.throw" - } else { - "minecraft:entity.lingering_potion.throw" + let (sound, power) = match &*stack.item { + "minecraft:splash_potion" => ("minecraft:entity.splash_potion.throw", 0.5), + "minecraft:experience_bottle" => { + ("minecraft:entity.experience_bottle.throw", 0.7) + } + _ => ("minecraft:entity.lingering_potion.throw", 0.5), }; self.audio.play(sound, Some(eye), 0.5, pitch); // Projectile.shootFromRotation(xRot, yRot, -20, 0.5, 1.0). @@ -74,9 +90,9 @@ impl Game<'_> { let r = &mut self.world.random; let mut jitter = || r.triangle(0.0, 0.0172275); let v = Vec3::new( - (f64::from(dir[0]) / l + jitter()) * 0.5, - (f64::from(dir[1]) / l + jitter()) * 0.5, - (f64::from(dir[2]) / l + jitter()) * 0.5, + (f64::from(dir[0]) / l + jitter()) * power, + (f64::from(dir[1]) / l + jitter()) * power, + (f64::from(dir[2]) / l + jitter()) * power, ); let pv = self.player.as_ref().map_or(Vec3::ZERO, |p| p.velocity); let on_ground = self.player.as_ref().is_some_and(|p| p.ground.on_ground); @@ -85,15 +101,14 @@ impl Game<'_> { v.y + if on_ground { 0.0 } else { pv.y }, v.z + pv.z, ); - self.potions.thrown.push(ThrownPotion { - stack: ItemStack { + self.launch_thrown( + ItemStack { count: 1, ..stack.clone() }, - position: Vec3::new(eye[0], eye[1] - 0.1, eye[2]), - velocity: v, - age: 0, - }); + Vec3::new(eye[0], eye[1] - 0.1, eye[2]), + v, + ); self.swing_arm(); self.consume_held(); Ok(true) @@ -137,7 +152,8 @@ impl Game<'_> { } /// Drinking a potion while right-click is held; true when handled. pub(super) fn tick_drinking(&mut self, slot: usize, ticks: u32, stack: &ItemStack) -> bool { - if &*stack.item != "minecraft:potion" { + let ominous = &*stack.item == "minecraft:ominous_bottle"; + if &*stack.item != "minecraft:potion" && !ominous { return false; } let ticks = ticks + 1; @@ -154,6 +170,10 @@ impl Game<'_> { return true; } self.using = None; + if ominous { + self.drink_ominous_bottle(slot, stack); + return true; + } let (lasting, now) = PlayerEffects::potion_effects(stack.potion(), 1.0); for e in lasting { self.potions.effects.add(e); @@ -326,19 +346,25 @@ impl Game<'_> { } t.position = next; // ThrowableItemProjectile: drag 0.99 then gravity 0.05. + // ThrownExperienceBottle.getDefaultGravity is 0.07. + let gravity = if &*t.stack.item == "minecraft:experience_bottle" { + 0.07 + } else { + 0.05 + }; t.velocity = Vec3::new( t.velocity.x * 0.99, - t.velocity.y * 0.99 - 0.05, + t.velocity.y * 0.99 - gravity, t.velocity.z * 0.99, ); t.age < 1200 && t.position.y > -128.0 }); // ThrownItemRenderer stand-in: a short-lived sprite of the potion at its position. for t in &thrown { - let sprite = if &*t.stack.item == "minecraft:lingering_potion" { - "item/lingering_potion" - } else { - "item/splash_potion" + let sprite = match &*t.stack.item { + "minecraft:lingering_potion" => "item/lingering_potion", + "minecraft:experience_bottle" => "item/experience_bottle", + _ => "item/splash_potion", }; let mut fixed = horizon_core::random::LegacyRandom::new(0); let mut p = horizon_client::particles::Particle::terrain( @@ -362,6 +388,36 @@ impl Game<'_> { } /// `ThrownSplashPotion.onHitAsPotion` (lingering clouds apply as a weaker splash). fn splash(&mut self, stack: &ItemStack, at: Vec3) { + if &*stack.item == "minecraft:experience_bottle" { + // ThrownExperienceBottle.onHit: the water-coloured splash (level + // event 2002) and 3 to 11 experience. + let pitch = self.world.random.next_float() * 0.1 + 0.9; + self.audio.play( + "minecraft:entity.splash_potion.break", + Some([at.x, at.y, at.z]), + 1.0, + pitch, + ); + for _ in 0..8 { + let v = [ + f64::from(self.world.random.next_float() - 0.5) * 0.3, + 0.2, + f64::from(self.world.random.next_float() - 0.5) * 0.3, + ]; + let p = horizon_client::particles::Particle::terrain( + &mut self.world.random, + [at.x, at.y, at.z], + v, + "item/splash_potion".into(), + 0x38_5DC6, + ); + self.particles.push(p); + } + let r = &mut self.world.random; + let value = 3 + r.next_int_bound(5).unwrap_or(0) + r.next_int_bound(5).unwrap_or(0); + self.spawn_orbs([at.x, at.y, at.z], value as u32); + return; + } let lingering = &*stack.item == "minecraft:lingering_potion"; let event = if lingering { "minecraft:entity.lingering_potion.break" diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs new file mode 100644 index 000000000..ba5d1bc87 --- /dev/null +++ b/crates/horizon-client/src/game/raids.rs @@ -0,0 +1,1091 @@ +//! Pillager patrols (`PatrolSpawner`), the raid omen, and raids (`Raids`): +//! their waves, boss bar, victory and the raiders' bookkeeping. +use super::{Dim, Game}; +use horizon_client::mobs::villager as mobs_villager; +use horizon_client::{ + effects::EffectInstance, + hud::{HudBatch, rgba}, + mobs::{Mob, Species, data, raider}, + raid::{self, Action, BarName, RaidLevel, RaiderInfo, RaiderType, Raids, Spawn}, +}; +use horizon_core::{geometry::Vec3, random::RandomSource}; +use std::collections::{HashMap, HashSet}; + +/// Patrol and raid state owned by the game. +#[derive(Default)] +pub(super) struct Raiding { + /// `PatrolSpawner.nextTick`. + patrol_next_tick: i32, + raids: Raids, + loaded: bool, + /// `ServerPlayer.raidOmenPosition`. + omen_position: Option<[i32; 3]>, + /// Beds near each raid's centre, rescanned now and then (`HOME` points + /// of interest for `RaiderMoveThroughVillageGoal`). + homes: HashMap>)>, +} + +/// `SectionPos` of a block position. +pub(super) fn section(p: [i32; 3]) -> (i32, i32, i32) { + (p[0] >> 4, p[1] >> 4, p[2] >> 4) +} +/// `PoiManager.DistanceTracker`: sections from the nearest village centre, +/// 7 when farther than 6. +pub(super) fn sections_to_village(centers: &HashSet<(i32, i32, i32)>, at: (i32, i32, i32)) -> i32 { + centers + .iter() + .map(|c| { + (c.0 - at.0) + .abs() + .max((c.1 - at.1).abs()) + .max((c.2 - at.2).abs()) + }) + .min() + .map_or(7, |d| d.min(7)) +} + +/// The level as a raid sees it, with this tick's village and raider data. +struct Lvl<'a, 'g> { + game: &'a Game<'g>, + difficulty: i32, + centers: &'a HashSet<(i32, i32, i32)>, + raiders: &'a HashMap>, +} +impl RaidLevel for Lvl<'_, '_> { + fn difficulty(&self) -> i32 { + self.difficulty + } + fn has_chunk_at(&self, p: [i32; 3]) -> bool { + self.game.world.chunks.contains_key(&(p[0] >> 4, p[2] >> 4)) + } + fn is_village(&self, p: [i32; 3]) -> bool { + sections_to_village(self.centers, section(p)) <= 1 + } + fn village_sections_near(&self, p: [i32; 3]) -> Vec<[i32; 3]> { + let (sx, sy, sz) = section(p); + let mut out = Vec::new(); + for dx in -2..=2 { + for dy in -2..=2 { + for dz in -2..=2 { + let s = (sx + dx, sy + dy, sz + dz); + let center = [s.0 * 16 + 8, s.1 * 16 + 8, s.2 * 16 + 8]; + if self.is_village(center) { + out.push(center); + } + } + } + } + out + } + fn raiders(&self, raid: i32) -> Vec { + self.raiders.get(&raid).cloned().unwrap_or_default() + } + fn surface_height(&self, x: i32, z: i32) -> i32 { + self.game.surface_height(x, z) + } + fn is_ticking(&self, p: [i32; 3]) -> bool { + [(-10, -10), (10, -10), (-10, 10), (10, 10)] + .iter() + .all(|(dx, dz)| self.has_chunk_at([p[0] + dx, p[1], p[2] + dz])) + } + fn can_spawn_at(&self, p: [i32; 3]) -> bool { + if !self.is_ticking(p) { + return false; + } + let g = self.game; + let w = g.mob_world_base(&[]); + horizon_client::mobs::spawning::placement_ok(Species::Ravager, &w, p[0], p[1], p[2]) + || w.block_name(p[0], p[1] - 1, p[2]) == "minecraft:snow" + && g.res.facts.is_air(g.world.block(p[0], p[1], p[2])) + } +} + +/// `DyeColor.getFireworkColor`. +const FIREWORK_COLORS: [u32; 16] = [ + 0xF0F0F0, 0xEB8844, 0xC354CD, 0x6689D3, 0xDECF2A, 0x41CD34, 0xD88198, 0x434343, 0xABABAB, + 0x287697, 0x7B2FBE, 0x253192, 0x51301A, 0x3B511A, 0xB3312C, 0x1E1B1B, +]; + +fn block_of(p: Vec3) -> [i32; 3] { + [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32] +} + +impl Game<'_> { + /// `Heightmap.Types.WORLD_SURFACE`: the first free block above the + /// highest non-air one. + pub(super) fn surface_height(&self, x: i32, z: i32) -> i32 { + let top = if self.dim == Dim::Nether { 127 } else { 319 }; + (horizon_client::chunk::MIN_Y..=top) + .rev() + .find(|&y| !self.res.facts.is_air(self.world.block(x, y, z))) + .map_or(horizon_client::chunk::MIN_Y, |y| y + 1) + } + /// Every claimed village point of interest (job sites, beds, bells). + fn village_pois(&self) -> Vec<[i32; 3]> { + let mut out: Vec<[i32; 3]> = Vec::new(); + for m in &self.mobs { + if m.species() != Species::Villager || !m.alive() { + continue; + } + for p in [m.extra.home, m.extra.bed, m.extra.meeting] + .into_iter() + .flatten() + { + if !out.contains(&p) { + out.push(p); + } + } + } + out + } + fn difficulty_id(&self) -> i32 { + use horizon_world::food::Difficulty; + match self.world.health_rules.difficulty { + Difficulty::Peaceful => 0, + Difficulty::Easy => 1, + Difficulty::Normal => 2, + Difficulty::Hard => 3, + } + } + fn player_block(&self) -> Option<[i32; 3]> { + self.player.as_ref().map(|p| block_of(p.position)) + } + fn raids_path(&self) -> std::path::PathBuf { + self.world_root.join("data/minecraft/raids.dat") + } + fn load_raids(&mut self) { + if self.raiding.loaded { + return; + } + self.raiding.loaded = true; + let seed = self.world.random.next_long(); + if let Some(tag) = horizon_client::save::read_dat(&self.raids_path()) + && let Some(data) = tag.get("data") + { + self.raiding.raids = Raids::from_nbt(data, seed); + } + } + /// `Raids` as `data/minecraft/raids.dat`, when it changed. + pub(super) fn save_raids(&mut self) { + if !self.raiding.loaded || !self.raiding.raids.dirty || self.remote.is_some() { + return; + } + let tag = horizon_world::nbt::Tag::compound([ + ("data", self.raiding.raids.to_nbt()), + ( + "DataVersion", + horizon_world::nbt::Tag::Int(horizon_world::DATA_VERSION), + ), + ]); + if horizon_client::save::write_dat(&self.raids_path(), tag).is_ok() { + self.raiding.raids.dirty = false; + } + } + + /// `BadOmenMobEffect` and `RaidOmenMobEffect`, before the effects tick: + /// Bad Omen inside a village becomes Raid Omen, which starts or extends a + /// raid when it runs out. + pub(super) fn tick_omens(&mut self) { + if self.dim != Dim::Overworld || self.spectator() { + return; + } + let Some(pos) = self.player_block() else { + return; + }; + self.load_raids(); + if let Some(amp) = self.potions.effects.amplifier("bad_omen") + && self.difficulty_id() != 0 + && sections_to_village(&self.village_centers(), section(pos)) <= 1 + && self + .raiding + .raids + .nearby(pos) + .is_none_or(|(_, r)| r.omen_level < raid::MAX_OMEN_LEVEL) + { + self.potions.effects.list.retain(|e| e.id != "bad_omen"); + self.potions + .effects + .add(EffectInstance::new("raid_omen", 600, amp)); + self.raiding.omen_position = Some(pos); + let eye = self.eye_position().unwrap_or_default(); + self.audio + .play("minecraft:event.mob_effect.raid_omen", Some(eye), 1.0, 1.0); + } + let due = self + .potions + .effects + .get("raid_omen") + .filter(|e| e.duration == 1) + .map(|e| e.amplifier); + if let Some(amp) = due + && let Some(at) = self.raiding.omen_position.take() + { + self.create_or_extend_raid(at, Some(amp)); + } + } + /// `Raids.createOrExtendRaid`: the raid centres on the claimed village + /// points within 64 blocks. + fn create_or_extend_raid(&mut self, at: [i32; 3], amplifier: Option) -> Option { + if !self.ui.rules.bool("raids") || self.dim != Dim::Overworld { + return None; + } + let near: Vec<[i32; 3]> = self + .village_pois() + .into_iter() + .filter(|p| (0..3).map(|i| f64::from(p[i] - at[i]).powi(2)).sum::() <= 4096.0) + .collect(); + let center = if near.is_empty() { + at + } else { + let n = near.len() as f64; + let mean = |i: usize| near.iter().map(|p| f64::from(p[i])).sum::() / n; + [ + mean(0).floor() as i32, + mean(1).floor() as i32, + mean(2).floor() as i32, + ] + }; + let seed = self.world.random.next_long(); + let difficulty = self.difficulty_id(); + let (id, triggered) = self + .raiding + .raids + .create_or_extend(center, difficulty, amplifier, seed); + if triggered { + self.stats.custom("raid_trigger", 1); + self.trigger_player("minecraft:voluntary_exile"); + } + Some(id) + } + /// `ServerLevel.getRaidAt`. + pub(super) fn raiding_nearby(&self, at: [i32; 3]) -> Option { + self.raiding.raids.nearby(at).map(|(id, _)| id) + } + pub(super) fn raid_started(&self, id: i32) -> bool { + self.raiding.raids.get(id).is_some_and(|r| r.started) + } + /// `/raid start`: a raid in the local village at the given omen level. + pub(super) fn raid_command_create(&mut self, at: [i32; 3], omen_level: i32) -> bool { + self.load_raids(); + let Some(id) = self.create_or_extend_raid(at, None) else { + return false; + }; + if let Some(r) = self.raiding.raids.map.get_mut(&id) { + r.omen_level = omen_level; + } + self.raiding.raids.dirty = true; + true + } + pub(super) fn raid_command_stop(&mut self, id: i32) { + if let Some(r) = self.raiding.raids.map.get_mut(&id) { + r.stop(); + } + } + pub(super) fn raid_set_omen(&mut self, id: i32, level: i32) -> i32 { + let Some(r) = self.raiding.raids.map.get_mut(&id) else { + return 0; + }; + std::mem::replace(&mut r.omen_level, level) + } + pub(super) fn raid_glow(&mut self, id: i32) { + for m in &mut self.mobs { + if raider::state(m).is_some_and(|s| s.raid_id == Some(id)) { + m.add_effect("glowing", 1000, 1); + } + } + } + /// The `/raid check` summary line. + pub(super) fn raid_status_text(&self, id: i32) -> String { + let Some(r) = self.raiding.raids.get(id) else { + return String::new(); + }; + let members: Vec<&Mob> = self + .mobs + .iter() + .filter(|m| m.alive() && raider::state(m).is_some_and(|s| s.raid_id == Some(id))) + .collect(); + let health: f32 = members.iter().map(|m| m.health).sum(); + format!( + "Num groups spawned: {} Raid omen level: {} Num mobs: {} Raid health: {} / {}", + r.groups_spawned, + r.omen_level, + members.len(), + health, + r.total_health + ) + } + + /// The living raiders by raid. + fn raider_infos(&self, centers: &HashSet<(i32, i32, i32)>) -> HashMap> { + let mut out: HashMap> = HashMap::new(); + for m in &self.mobs { + if !m.alive() || m.removed { + continue; + } + let Some(s) = raider::state(m) else { continue }; + let Some(id) = s.raid_id else { continue }; + let position = block_of(m.position); + out.entry(id).or_default().push(RaiderInfo { + id: m.id, + wave: s.wave, + health: m.health, + position, + age: m.age, + no_action_time: m.ai.no_action_time, + ticks_outside: s.ticks_outside_raid, + in_village: sections_to_village(centers, section(position)) <= 1, + }); + } + out + } + /// `ServerLevel.tick` for the raids and their raiders. + pub(super) fn tick_raids(&mut self) { + if self.remote.is_some() || self.dim != Dim::Overworld { + return; + } + self.load_raids(); + let centers = self.village_centers(); + let infos = self.raider_infos(¢ers); + let mut raids = std::mem::take(&mut self.raiding.raids); + let actions = { + let lvl = Lvl { + game: self, + difficulty: self.difficulty_id(), + centers: ¢ers, + raiders: &infos, + }; + raids.tick(&lvl, self.ui.rules.bool("raids"), self.player_block()) + }; + self.raiding.raids = raids; + for (id, action) in actions { + self.apply_raid_action(id, action); + } + self.sync_raiders(¢ers); + self.sync_villager_raids(&infos); + } + fn apply_raid_action(&mut self, id: i32, action: Action) { + match action { + Action::Spawn { pos, wave, spawns } => self.spawn_wave(id, pos, wave, &spawns), + Action::Horn { pos } => self.raid_horn(id, pos), + Action::Remove { id: mob } => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { + let s = raider::state_mut(m); + s.raid_id = None; + s.ticks_outside_raid = 0; + s.active_raid = false; + } + } + Action::SetOutside { id: mob, ticks } => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { + raider::state_mut(m).ticks_outside_raid = ticks; + } + } + Action::Victory { heroes, amplifier } => { + let me = self.level.player_uuid; + if me.is_some_and(|u| heroes.contains(&u)) && !self.spectator() { + let mut effect = + EffectInstance::new("hero_of_the_village", raid::HERO_DURATION, amplifier); + effect.visible = false; + self.potions.effects.add(effect); + self.stats.custom("raid_win", 1); + self.trigger_player("minecraft:hero_of_the_village"); + } + } + } + } + /// `Raid.playSound`: the horn, 13 blocks away from the player toward the + /// wave, for players within 64 blocks or in the raid. + fn raid_horn(&mut self, id: i32, pos: [i32; 3]) { + let Some(p) = self.player.as_ref().map(|p| p.position) else { + return; + }; + let in_raid = self.raiding.raids.get(id).is_some_and(|r| r.bar.player); + let (rx, rz) = (f64::from(pos[0]) + 0.5, f64::from(pos[2]) + 0.5); + let distance = ((rx - p.x).powi(2) + (rz - p.z).powi(2)).sqrt(); + if distance <= 64.0 || in_raid { + let k = 13.0 / distance.max(1e-4); + let at = [p.x + k * (rx - p.x), p.y, p.z + k * (rz - p.z)]; + self.audio + .play("minecraft:event.raid.horn", Some(at), 1.0, 1.0); + } + } + /// `Raid.spawnGroup`: a wave of raiders around `pos`, ravagers carrying + /// their riders. + fn spawn_wave(&mut self, raid_id: i32, pos: [i32; 3], wave: i32, spawns: &[Spawn]) { + let odds = self + .raiding + .raids + .get(raid_id) + .map_or(0.0, raid::Raid::enchant_odds); + for sp in spawns { + let Some(id) = self.spawn_raider(sp.kind, pos, raid_id, wave, sp.leader, odds) else { + continue; + }; + if let Some(kind) = sp.rider + && let Some(rider) = self.spawn_raider(kind, pos, raid_id, wave, false, odds) + { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == rider) { + raider::state_mut(m).vehicle = Some(id); + m.extra.passenger = true; + } + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + raider::state_mut(m).rider = true; + } + } + } + } + /// `Raid.joinRaid` for a new raider, with `applyRaidBuffs`. + fn spawn_raider( + &mut self, + kind: RaiderType, + pos: [i32; 3], + raid_id: i32, + wave: i32, + leader: bool, + odds: f32, + ) -> Option { + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]) + 1.0, + f64::from(pos[2]) + 0.5, + ]; + let id = self.spawn_mob_for(kind.entity(), at, false, true)?; + let m = self.mobs.iter_mut().find(|m| m.id == id)?; + if leader { + raider::set_patrol_leader(m, true); + } + raider::finalize(m, raider::Reason::Event); + let s = raider::state_mut(m); + s.raid_id = Some(raid_id); + s.wave = wave; + s.can_join_raid = true; + s.ticks_outside_raid = 0; + s.active_raid = true; + m.on_ground = true; + // applyRaidBuffs: Quick Charge crossbows and Sharpness axes. + let enchant = m.random.next_float() <= odds; + match kind { + RaiderType::Pillager if enchant => { + raider::state_mut(m).enchant = if wave > raid::num_groups(2) { + 2 + } else if wave > raid::num_groups(1) { + 1 + } else { + 0 + }; + } + RaiderType::Vindicator => { + let level = if !enchant { + 0 + } else if wave > raid::num_groups(2) { + 2 + } else { + 1 + }; + raider::state_mut(m).enchant = level; + if level > 0 { + m.attrs.attack_damage += 1.0 + 0.5 * f32::from(level - 1); + } + } + _ => {} + } + Some(id) + } + + /// Per-tick raid bookkeeping of every raider (and the ravagers they + /// ride): the raid's state for the goals, joining and recruiting, + /// the banner of a fallen captain, idle time. + fn sync_raiders(&mut self, centers: &HashSet<(i32, i32, i32)>) { + let now = self.world.game_time; + let golems: HashSet = self + .mobs + .iter() + .filter(|m| m.species() == Species::IronGolem) + .map(|m| m.id) + .collect(); + // Living leaders and carried riders. + let mut leaders: HashSet<(i32, i32)> = HashSet::new(); + let mut ridden: HashSet = HashSet::new(); + let mut positions: Vec<(u32, Vec3, bool)> = Vec::new(); + for m in &self.mobs { + let Some(s) = raider::state(m) else { continue }; + if !m.alive() { + continue; + } + if let (Some(id), true) = (s.raid_id, s.patrol_leader) { + leaders.insert((id, s.wave)); + } + if let Some(v) = s.vehicle { + ridden.insert(v); + } + positions.push((m.id, m.position, s.active_raid)); + } + let banners: Vec<(usize, Vec3)> = self + .dropped + .iter() + .enumerate() + .filter(|(_, e)| { + &*e.stack.item == raider::BANNER + && e.stack.data().is_some_and(|d| d.ominous_banner) + && e.pickup_delay == 0 + }) + .map(|(i, e)| (i, e.position)) + .collect(); + let mut taken: Vec = Vec::new(); + let mut recruit: Vec<(i32, i32, Vec3)> = Vec::new(); + let homes = self.raid_homes(); + for m in &mut self.mobs { + let species = m.species(); + if !raider::is_raider(species) { + continue; + } + let alive = m.alive(); + let position = m.position; + let block = block_of(position); + let in_village = sections_to_village(centers, section(block)) <= 1; + let has_rider = ridden.contains(&m.id); + let target_golem = matches!(m.ai.target, Some(horizon_client::mobs::Who::Mob(t)) if golems.contains(&t)); + let target_player = m.ai.target == Some(horizon_client::mobs::Who::Player); + let (health, age, range) = (m.health, m.age, m.attrs.follow_range); + let raids = &mut self.raiding.raids; + let s = m.extra.raider.get_or_insert_with(Box::default); + s.rider = has_rider; + s.in_village = in_village; + if s.raid_id.is_some_and(|id| raids.get(id).is_none()) { + s.raid_id = None; + s.ticks_outside_raid = 0; + } + match s.raid_id.and_then(|id| raids.get(id)) { + Some(r) => { + s.active_raid = r.active; + s.raid_over = r.is_over(); + s.raid_loss = r.is_loss(); + s.raid_center = r.center; + s.homes = s.raid_id.and_then(|id| homes.get(&id).cloned()); + } + None => { + s.active_raid = false; + s.raid_over = false; + s.raid_loss = false; + s.homes = None; + s.banner_at = None; + } + } + if !alive { + continue; + } + // Raider.updateNoActionTime adds two per tick, and a raider + // fighting a player or golem in a raid is never idle. + if s.raid_id.is_some() { + m.ai.no_action_time = if target_player || target_golem { + 0 + } else { + m.ai.no_action_time + 1 + }; + } + // Raider.aiStep: join the raid the raider stands in. + if s.raid_id.is_none() + && s.can_join_raid + && now % 20 == 0 + && m.ai.no_action_time <= 2400 + && let Some((id, r)) = raids.nearby(block) + { + let wave = r.groups_spawned; + s.raid_id = Some(id); + s.wave = wave; + s.ticks_outside_raid = 0; + if let Some(r) = raids.map.get_mut(&id) { + r.total_health += health; + } + } + // PathfindToRaidGoal.recruitNearby. + if s.active_raid + && !s.raid_over + && !s.in_village + && age % 20 == 0 + && let Some(id) = s.raid_id + { + recruit.push((id, s.wave, position)); + } + // ObtainRaidLeaderBannerGoal. + s.banner_at = None; + if let Some(id) = s.raid_id + && s.active_raid + && !s.raid_over + && raider::can_be_leader(species) + && m.extra.head.as_deref() != Some(raider::BANNER) + && !leaders.contains(&(id, s.wave)) + { + 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 + }) + .min_by(|a, b| { + a.1.distance_squared(position) + .total_cmp(&b.1.distance_squared(position)) + }); + if let Some((i, p)) = near { + s.banner_at = Some([p.x, p.y, p.z]); + if p.distance_squared(position) < 1.414 * 1.414 { + // pickUpItem: the banner becomes the wave's leader. + taken.push(*i); + leaders.insert((id, s.wave)); + s.banner_at = None; + s.patrol_leader = true; + s.patrolling = true; + m.extra.head = Some(raider::BANNER.into()); + } + } + } + } + taken.sort_unstable(); + for i in taken.into_iter().rev() { + self.dropped.remove(i); + } + // Recruiting: raiders nearby that are in no raid join this one. + for (id, wave, at) in recruit { + let now_nearby: Vec = positions + .iter() + .filter(|(_, p, active)| { + !active + && (p.x - at.x).abs() <= 16.0 + && (p.y - at.y).abs() <= 16.0 + && (p.z - at.z).abs() <= 16.0 + }) + .map(|(i, _, _)| *i) + .collect(); + for mid in now_nearby { + let Some(m) = self.mobs.iter_mut().find(|m| m.id == mid) else { + continue; + }; + let health = m.health; + let idle = m.ai.no_action_time; + let s = raider::state_mut(m); + if s.raid_id.is_none() && s.can_join_raid && idle <= 2400 { + s.raid_id = Some(id); + s.wave = wave; + s.ticks_outside_raid = 0; + s.active_raid = true; + if let Some(r) = self.raiding.raids.map.get_mut(&id) { + r.total_health += health; + } + } + } + } + } + /// Beds within 64 blocks of each raid's centre (the `HOME` points of + /// interest), rescanned every five seconds. + fn raid_homes(&mut self) -> HashMap>> { + let now = self.world.game_time; + let ids: Vec<(i32, [i32; 3])> = self + .raiding + .raids + .map + .iter() + .filter(|(_, r)| r.active && !r.is_over() && r.started) + .map(|(id, r)| (*id, r.center)) + .collect(); + self.raiding + .homes + .retain(|id, _| ids.iter().any(|(i, _)| i == id)); + for (id, c) in ids { + if self + .raiding + .homes + .get(&id) + .is_some_and(|(at, _)| now - at < 100) + { + continue; + } + let mut beds = Vec::new(); + let mut known: HashMap = HashMap::new(); + for y in c[1] - 32..=c[1] + 32 { + for z in c[2] - 64..=c[2] + 64 { + for x in c[0] - 64..=c[0] + 64 { + let state = self.world.block(x, y, z); + if self.res.facts.is_air(state) { + continue; + } + let bed = *known.entry(state.0).or_insert_with(|| { + self.res.facts.get(state).name.ends_with("_bed") + && self.res.assets.registry.state(state).is_some_and(|s| { + s.properties.get("part").map(String::as_str) == Some("head") + }) + }); + if bed { + beds.push([x, y, z]); + } + } + } + } + self.raiding + .homes + .insert(id, (now, std::sync::Arc::new(beds))); + } + self.raiding + .homes + .iter() + .map(|(id, (_, v))| (*id, v.clone())) + .collect() + } + /// A raider riding a ravager sits on its back (`Entity.positionRider` + /// with the ravager's passenger attachment and a 0.6 riding offset). + pub(super) fn sync_riders(&mut self) { + let vehicles: HashMap = self + .mobs + .iter() + .filter(|m| m.species() == Species::Ravager) + .map(|m| { + ( + m.id, + ( + m.position, + m.previous, + m.body_yaw, + m.previous_body_yaw, + m.alive(), + ), + ) + }) + .collect(); + for m in &mut self.mobs { + let Some(v) = raider::state(m).and_then(|s| s.vehicle) else { + continue; + }; + match vehicles.get(&v) { + Some(&(pos, prev, yaw, prev_yaw, true)) => { + let place = |p: Vec3, yaw: f32| { + let a = f64::from(yaw).to_radians(); + // The attachment's z offset of -0.0625, rotated. + Vec3::new( + p.x + a.sin() * -0.0625, + p.y + 2.2625 - 0.6, + p.z - a.cos() * -0.0625, + ) + }; + m.position = place(pos, yaw); + m.previous = place(prev, prev_yaw); + m.velocity = Vec3::ZERO; + m.fall_distance = 0.0; + m.on_ground = false; + m.body_yaw = yaw; + m.previous_body_yaw = prev_yaw; + m.extra.passenger = true; + // Raiders on a ravager never walk off on their own. + m.ai.nav.stop(); + } + _ => { + raider::state_mut(m).vehicle = None; + m.extra.passenger = false; + } + } + } + } + /// `Raider.die`: the killing player becomes a hero of the village. + pub(super) fn raider_died(&mut self, m: &Mob, by_player: bool) { + let Some(id) = raider::state(m).and_then(|s| s.raid_id) else { + return; + }; + if by_player + && let Some(uuid) = self.level.player_uuid + && let Some(r) = self.raiding.raids.map.get_mut(&id) + { + r.add_hero(uuid); + } + } + + /// `SetRaidStatus` / `ResetRaidStatus` for villagers: which raid package + /// they follow, by the raid nearest to them. + fn sync_villager_raids(&mut self, infos: &HashMap>) { + let raids = &self.raiding.raids; + let random = &mut self.world.random; + for m in &mut self.mobs { + if m.species() != Species::Villager { + continue; + } + let at = block_of(m.position); + let status = match raids.nearby(at) { + Some((id, r)) if !r.is_stopped() && !r.is_loss() => { + let alive = infos.get(&id).map_or(0, Vec::len); + if r.is_victory() { + mobs_villager::RAID_VICTORY + } else if r.has_first_wave_spawned() && !r.is_between_waves(alive) { + mobs_villager::RAID + } else { + mobs_villager::PRE_RAID + } + } + _ => mobs_villager::RAID_NONE, + }; + let ext = mobs_villager::ext_mut(m); + // ResetRaidStatus clears at once; SetRaidStatus one tick in twenty. + if status == mobs_villager::RAID_NONE + || ext.raid != status && random.next_int_bound(20).unwrap_or(1) == 0 + { + ext.raid = status; + } + } + } + + /// The raid boss bars (`BossHealthOverlay`): a red notched bar with the + /// raid's title. Returns the next free row. + pub(super) fn draw_raid_bar(&self, batch: &mut HudBatch, mut y: f32) -> f32 { + let atlas = &self.res.atlas; + for raid in self.raiding.raids.map.values() { + if !raid.bar.visible || !raid.bar.player || raid.is_stopped() { + continue; + } + let x = (batch.width / 2.0 - 91.0).floor(); + batch.sprite(atlas, "gui/sprites/boss_bar/red_background", x, y); + batch.sprite(atlas, "gui/sprites/boss_bar/notched_10_background", x, y); + let p = raid.bar.progress; + // Mth.lerpDiscrete(progress, 0, 182). + let width = (p * 181.0).floor() as i32 + i32::from(p > 0.0); + if width > 0 { + let fraction = width as f32 / 182.0; + batch.sprite_part(atlas, "gui/sprites/boss_bar/red_progress", x, y, fraction); + batch.sprite_part( + atlas, + "gui/sprites/boss_bar/notched_10_progress", + x, + y, + fraction, + ); + } + let title = self.translate("event.minecraft.raid", "Raid"); + let name = match raid.bar.name { + BarName::Raid => title, + BarName::Remaining(n) => format!( + "{title} - {}", + self.translate( + "event.minecraft.raid.raiders_remaining", + "Raiders Remaining: %s" + ) + .replace("%s", &n.to_string()) + ), + BarName::Victory => { + self.translate("event.minecraft.raid.victory.full", "Raid - Victory") + } + BarName::Defeat => { + self.translate("event.minecraft.raid.defeat.full", "Raid - Defeat") + } + }; + let w = HudBatch::text_width(atlas, &name); + batch.text( + atlas, + &name, + (batch.width / 2.0 - w / 2.0).floor(), + y - 9.0, + rgba(255, 255, 255, 255), + true, + ); + y += 19.0; + } + y + } + /// A firework a villager launches to celebrate (`CelebrateVillagersSurvivedRaid`). + pub(super) fn villager_firework(&mut self, at: [f64; 3], color: usize, flight: u8) { + let mut stack = horizon_client::items::ItemStack::new("minecraft:firework_rocket", 1); + stack.data_mut().fireworks = Some(( + flight, + vec![horizon_client::particles::FireworkExplosion { + shape: horizon_client::particles::FireworkShape::Burst, + colors: vec![FIREWORK_COLORS[color & 15]], + fade: Vec::new(), + trail: false, + twinkle: false, + }], + )); + let rocket = self.new_rocket(Vec3::new(at[0], at[1], at[2]), &stack, false); + self.rockets.push(rocket); + } + /// `BehaviorUtils.throwItem`: a hero's gift tossed toward the player. + pub(super) fn throw_gift(&mut self, table: &str, from: [f64; 3], to: [f64; 3]) { + let drops = self + .res + .items + .loot_table(table, false, None, &mut self.world.random); + let d = Vec3::new(to[0] - from[0], to[1] - from[1], to[2] - from[2]).normalize(); + for stack in drops { + self.spawn_item(stack, from, [d.x * 0.3, d.y * 0.3, d.z * 0.3], 10); + } + } +} + +impl Game<'_> { + /// Sections holding a claimed village point of interest (a job site, + /// bed or bell a villager has taken): `PoiManager.isVillageCenter`. + pub(super) fn village_centers(&self) -> HashSet<(i32, i32, i32)> { + let mut out = HashSet::new(); + for m in &self.mobs { + if m.species() != Species::Villager || !m.alive() { + continue; + } + for p in [m.extra.home, m.extra.bed, m.extra.meeting] + .into_iter() + .flatten() + { + out.insert(section(p)); + } + } + out + } + /// `ServerLevel.isCloseToVillage`. + pub(super) fn close_to_village(&self, at: [i32; 3], distance: i32) -> bool { + distance <= 6 && sections_to_village(&self.village_centers(), section(at)) <= distance + } + /// `PatrolSpawner.tick`: every 10 minutes, a fifth of the time in + /// daylight, a patrol of pillagers spawns 24 to 48 blocks from a player + /// who is not near a village. + pub(super) fn tick_patrol_spawner(&mut self) { + if self.dim != Dim::Overworld + || self.world.health_rules.difficulty == horizon_world::food::Difficulty::Peaceful + || !self.ui.rules.bool("spawn_monsters") + || !self.ui.rules.bool("spawn_patrols") + { + return; + } + self.raiding.patrol_next_tick -= 1; + if self.raiding.patrol_next_tick > 0 { + return; + } + let delay = self.world.random.next_int_bound(1200).unwrap_or(0); + self.raiding.patrol_next_tick += 12000 + delay; + let bright = self.sky_darken() < 4; + let r = &mut self.world.random; + if !bright || r.next_int_bound(5).unwrap_or(1) != 0 { + return; + } + // One player: `players.get(random.nextInt(1))`. + let _ = r.next_int_bound(1); + let Some(p) = self.player.as_ref().map(|p| p.position) else { + return; + }; + if self.spectator() { + return; + } + let block = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]; + if self.close_to_village(block, 2) { + return; + } + let r = &mut self.world.random; + let x = (24 + r.next_int_bound(24).unwrap_or(0)) * if r.next_boolean() { -1 } else { 1 }; + let z = (24 + r.next_int_bound(24).unwrap_or(0)) * if r.next_boolean() { -1 } else { 1 }; + let mut at = [block[0] + x, block[1], block[2] + z]; + // hasChunksAt(±10). + for (dx, dz) in [(-10, -10), (10, -10), (-10, 10), (10, 10)] { + if !self + .world + .chunks + .contains_key(&((at[0] + dx) >> 4, (at[2] + dz) >> 4)) + { + return; + } + } + // The `can_pillager_patrol_spawn` attribute: the early game timeline + // (first five days) and the mushroom fields forbid it. + let biome = self.biome_facts(at[0], at[1], at[2]); + if self.world.day_time < 120_000 || biome.mushroom { + return; + } + let f = self.local_difficulty([f64::from(at[0]), f64::from(at[1]), f64::from(at[2])]); + let group = f.effective.ceil() as i32 + 1; + for i in 0..group { + at[1] = self.motion_top(at[0], at[2]); + if !self.spawn_patrol_member(at, i == 0) && i == 0 { + break; + } + let r = &mut self.world.random; + at[0] += r.next_int_bound(5).unwrap_or(0) - r.next_int_bound(5).unwrap_or(0); + at[2] += r.next_int_bound(5).unwrap_or(0) - r.next_int_bound(5).unwrap_or(0); + } + } + /// A raider's ominous banner (drop chance 2.0: always dropped) and a + /// patrol captain's ominous bottle (`entities/pillager`). + pub(super) fn raider_death_loot(&mut self, m: &horizon_client::mobs::Mob, pos: [f64; 3]) { + if !raider::is_raider(m.species()) { + return; + } + if m.extra.head.as_deref() == Some(raider::BANNER) { + self.spawn_item(raider::ominous_banner(), pos, [0.0, 0.2, 0.0], 10); + } + if m.species() == Species::Pillager && raider::is_captain(m) { + let amplifier = self.world.random.next_int_bound(5).unwrap_or(0) as u8; + let amplifier = (amplifier > 0).then_some(amplifier); + let mut bottle = horizon_client::items::ItemStack::new("minecraft:ominous_bottle", 1); + bottle.data_mut().ominous_amplifier = amplifier; + self.spawn_item(bottle, pos, [0.0, 0.2, 0.0], 10); + } + } + /// `OminousBottleAmplifier.onConsume`: Bad Omen for 100 minutes at the + /// bottle's amplifier, then the dispose sound; the bottle is used up. + pub(super) fn drink_ominous_bottle( + &mut self, + slot: usize, + stack: &horizon_client::items::ItemStack, + ) { + let amplifier = stack.data().and_then(|d| d.ominous_amplifier).unwrap_or(0); + let mut effect = + horizon_client::effects::EffectInstance::new("bad_omen", 120_000, i32::from(amplifier)); + effect.visible = false; + self.potions.effects.add(effect); + let eye = self.eye_position().unwrap_or_default(); + self.audio + .play("minecraft:item.ominous_bottle.dispose", Some(eye), 1.0, 1.0); + if !self.creative + && let Some(s) = self.inventory[slot].as_mut() + { + s.count -= 1; + if s.count == 0 { + self.inventory[slot] = None; + } + } + } + /// `PatrolSpawner.spawnPatrolMember`: a pillager on a valid empty block + /// that may spawn there; the leader picks a target and wears the banner. + fn spawn_patrol_member(&mut self, at: [i32; 3], leader: bool) -> bool { + let state = self.world.block(at[0], at[1], at[2]); + let below = self.world.block(at[0], at[1] - 1, at[2]); + let empty = self.res.mob_data.state(state).flags & data::VALID_EMPTY_SPAWN != 0; + let valid = self.res.mob_data.state(below).flags & data::VALID_SPAWN != 0; + // PatrollingMonster.checkPatrollingMonsterSpawnRules. + if !empty || !valid || self.world.light(at[0], at[1], at[2]) & 15 > 8 { + return false; + } + let pos = [f64::from(at[0]), f64::from(at[1]), f64::from(at[2])]; + let Some(id) = self.spawn_mob_for("minecraft:pillager", pos, false, true) else { + return false; + }; + let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) else { + return false; + }; + if leader { + raider::set_patrol_leader(m, true); + // findPatrolTarget runs before the mob is placed, so the target + // is around the world origin. + raider::find_patrol_target_from(m, [0, 0, 0]); + } + raider::finalize(m, raider::Reason::Patrol); + true + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn sections_to_village_is_a_chebyshev_distance_capped_at_seven() { + let mut centers = HashSet::new(); + assert_eq!(sections_to_village(¢ers, (0, 0, 0)), 7); + centers.insert(section([40, 64, 40])); + assert_eq!(sections_to_village(¢ers, (2, 4, 2)), 0); + assert_eq!(sections_to_village(¢ers, (4, 4, 2)), 2); + assert_eq!(sections_to_village(¢ers, (-10, 4, 2)), 7); + assert_eq!(section([-1, -17, 15]), (-1, -2, 0)); + } +} diff --git a/crates/horizon-client/src/game/recipe_book.rs b/crates/horizon-client/src/game/recipe_book.rs new file mode 100644 index 000000000..658db4ada --- /dev/null +++ b/crates/horizon-client/src/game/recipe_book.rs @@ -0,0 +1,1249 @@ +//! The recipe book of the inventory, crafting table and furnace screens +//! (`RecipeBookComponent`): the green book button, the tabs by category, the +//! search box, the craftable filter, the pages of recipe buttons with the +//! alternatives overlay, ghost recipes, and placing a recipe in the grid +//! (`ServerPlaceRecipe`). Which recipes are known comes from the advancement +//! rewards; the open and filter settings are saved with the player. +use super::{Game, Screen}; +use horizon_client::{ + containers::{BlockEntity, FurnaceKind}, + hud::{HudBatch, Rect, rgba}, + items::ItemStack, + recipe_book::{Available, Book, BookType, Collection, Display, Entry, Tab}, + ui::EditBox, +}; +use std::{ + collections::BTreeSet, + hash::{Hash, Hasher}, +}; + +const WIDTH: f32 = 147.0; +const HEIGHT: f32 = 166.0; +/// `RecipeBookComponent.TICKS_TO_SWAP_SLOT`. +const SWAP_TICKS: f32 = 30.0; +/// Widest GUI at which the book sits next to the menu (`widthTooNarrow`). +const NARROW: f32 = 379.0; + +/// A ghost recipe slot: the items it cycles through. +struct Ghost { + slot: usize, + items: Vec, + result: bool, +} +/// The alternatives overlay of a recipe button (`OverlayRecipeComponent`). +struct Overlay { + x: f32, + y: f32, + /// (entry index, craftable) + entries: Vec<(usize, bool)>, +} +/// One recipe button: the collection's recipes shown in the current view. +#[derive(Clone, Default)] +struct Button { + /// (entry index, craftable) + entries: Vec<(usize, bool)>, +} +impl Button { + fn craftable(&self) -> bool { + self.entries.iter().any(|e| e.1) + } +} +#[derive(Default)] +struct View { + /// Visible tabs. + tabs: Vec, + buttons: Vec