diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index 431eac25f..d128b1a25 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -60,6 +60,56 @@ pub enum BlockEntity { Lectern(Lectern), /// `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 { @@ -111,6 +161,9 @@ impl BlockEntity { 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())); } @@ -145,6 +198,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, }) } @@ -166,6 +220,7 @@ impl BlockEntity { Self::Beacon(_) => "minecraft:beacon", Self::Lectern(_) => "minecraft:lectern", Self::Banner(_) => "minecraft:banner", + Self::Crafter(_) => "minecraft:crafter", } } pub fn contents(&self) -> Vec { @@ -178,6 +233,7 @@ impl BlockEntity { Self::Beacon(_) => 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] { @@ -190,6 +246,7 @@ impl BlockEntity { | Self::Beacon(_) | Self::Lectern(_) | Self::Banner(_) => &[], + Self::Crafter(c) => &c.items, } } pub fn slots_mut(&mut self) -> &mut [Option] { @@ -202,6 +259,7 @@ impl BlockEntity { | Self::Beacon(_) | Self::Lectern(_) | Self::Banner(_) => &mut [], + Self::Crafter(c) => &mut c.items, } } } diff --git a/crates/horizon-client/src/crafting.rs b/crates/horizon-client/src/crafting.rs index 7994d0bd7..c20f0bce9 100644 --- a/crates/horizon-client/src/crafting.rs +++ b/crates/horizon-client/src/crafting.rs @@ -289,6 +289,10 @@ impl Recipes { } /// 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()) @@ -307,12 +311,12 @@ 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(result); + return Some((name, result)); } } Recipe::Shaped { @@ -337,7 +341,7 @@ impl Recipes { }) }; if matches(false) || matches(true) { - return Some(result.clone()); + return Some((name, result.clone())); } } Recipe::Shapeless { @@ -361,7 +365,7 @@ impl Recipes { } }); if ok { - return Some(result.clone()); + return Some((name, result.clone())); } } } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index d5e5a8de4..02a649329 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3047,6 +3047,7 @@ impl Game<'_> { Some(BlockEntity::Chest(items)) => v.extend((0..items.len()).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(_) @@ -3069,6 +3070,7 @@ 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)) { return p; } @@ -3148,6 +3150,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(); @@ -3273,6 +3283,7 @@ impl Game<'_> { } } Some(BlockEntity::Brewing(_)) => {} + Some(BlockEntity::Crafter(_)) => self.draw_crafter_screen(batch, ox, oy), Some( BlockEntity::Sign(_) | BlockEntity::Jukebox(_) @@ -3328,11 +3339,7 @@ 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); } @@ -3421,6 +3428,11 @@ 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 let Some(c) = &self.carried && self.refuses(slot, c) { @@ -4335,6 +4347,7 @@ impl Game<'_> { } fn tick_block_entities(&mut self) -> Result<()> { self.tick_hoppers()?; + self.tick_crafters(); self.tick_jukeboxes(); self.tick_beacons(); // ChestLidController: 0.1 per tick towards open/closed. diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index 835056c09..353865c6f 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -3,6 +3,8 @@ //! 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, @@ -40,6 +42,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`). @@ -145,6 +149,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 +217,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 +257,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) { @@ -567,6 +585,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(()); 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..e0315f46f --- /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 toggle")) + } + /// 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/stations.rs b/crates/horizon-client/src/game/stations.rs index e2771daba..d75b84015 100644 --- a/crates/horizon-client/src/game/stations.rs +++ b/crates/horizon-client/src/game/stations.rs @@ -483,6 +483,12 @@ impl Game<'_> { /// `Slot.mayPlace` and `getMaxStackSize` for station and brewing slots. fn slot_rules(&self, slot: usize, stack: &ItemStack) -> (bool, u32) { let data = self.data(); + if let Some(BlockEntity::Crafter(c)) = self.container_kind() + && (300..309).contains(&slot) + { + // CrafterSlot.mayPlace: not a disabled slot. + return (!c.disabled[slot - 300], 64); + } if (300..305).contains(&slot) { return match slot - 300 { 0..=2 => (data.brewing.is_bottle(stack), 1), @@ -1952,14 +1958,12 @@ impl Game<'_> { let Some(slot) = self.slot_at(batch, self.cursor.0, self.cursor.1) else { return; }; - let stack = if slot == 200 { - self.craft_result() - } else { - self.slot_mut(slot).clone() - }; + let stack = self.slot_view(slot); if let Some(stack) = stack { let lines = self.stack_tooltip(&stack); self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1); + } else if let Some(text) = self.crafter_tooltip(slot) { + self.draw_tooltip_lines(batch, &[(text, u32::MAX)], self.cursor.0, self.cursor.1); } } /// Potion items: `layer0` tinted with the potion colour under the bottle diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 9f9893043..6ecac27e3 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -400,6 +400,20 @@ fn encode_block_entity(p: (i32, i32, i32), e: &crate::containers::BlockEntity, b entries.push(("Page", Tag::Int(l.page))); } } + BlockEntity::Crafter(c) => { + entries.push(("Items", encode_items(&c.items))); + entries.push(( + "disabled_slots", + Tag::IntArray( + (0..9) + .filter(|&i| c.disabled[i]) + .map(|i| i as i32) + .collect(), + ), + )); + entries.push(("triggered", Tag::Int(i32::from(c.triggered)))); + entries.push(("crafting_ticks_remaining", Tag::Int(c.crafting_ticks))); + } BlockEntity::Banner(b) => { if !b.layers.is_empty() { entries.push(("patterns", crate::banner::layers_to_nbt(&b.layers))); @@ -491,6 +505,20 @@ fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers: }; } BlockEntity::Sign(sign) => sign.decode(tag), + BlockEntity::Crafter(c) => { + for (slot, item) in decode_items(tag.get("Items"), 9).into_iter().enumerate() { + c.items[slot] = item; + } + if let Some(Tag::IntArray(slots)) = tag.get("disabled_slots") { + for &slot in slots { + if (0..9).contains(&slot) && c.items[slot as usize].is_none() { + c.disabled[slot as usize] = true; + } + } + } + c.triggered = int("triggered").unwrap_or(0) != 0; + c.crafting_ticks = int("crafting_ticks_remaining").unwrap_or(0); + } BlockEntity::Jukebox(_) | BlockEntity::Beacon(_) | BlockEntity::Lectern(_) @@ -2013,6 +2041,29 @@ impl ChunkGenerator for Persistent { #[cfg(test)] mod tests { + #[test] + fn crafter_block_entity_round_trips() { + let mut crafter = crate::containers::Crafter::default(); + crafter.items[2] = Some(crate::items::ItemStack::new("minecraft:stick", 5)); + crafter.disabled[4] = true; + crafter.triggered = true; + crafter.crafting_ticks = 3; + let tag = encode_block_entity( + (7, 8, 9), + &crate::containers::BlockEntity::Crafter(crafter), + "minecraft:crafter", + ); + let (pos, back) = decode_block_entity(&tag).expect("crafter"); + assert_eq!(pos, (7, 8, 9)); + let crate::containers::BlockEntity::Crafter(back) = back else { + panic!("not a crafter"); + }; + assert_eq!(back.items[2].as_ref().map(|s| s.count), Some(5)); + assert!(back.disabled[4] && !back.disabled[3]); + assert!(back.triggered); + assert_eq!(back.crafting_ticks, 3); + assert_eq!(back.redstone_signal(), 2); + } #[test] fn banner_block_entity_round_trips() { let banner = crate::containers::Banner {