Add the crafter

The crafter block now works: right-clicking opens its menu with the 3x3 grid, the recipe result preview and the powered arrow, and clicking an empty slot disables or re-enables it (with the button click sound and the lighter disabled slot art), while shift-click moves stacks between the grid and the inventory. When powered, it crafts after four ticks using the grid's recipe, plays the craft or fail sound, shows the crafting state for six ticks, pushes the result and any remainders into the container in front (or shoots them out with white smoke), uses up one of each ingredient and fires the crafters-crafting-crafters advancement.

Its comparator signal counts filled and disabled slots, hoppers fill its smallest stacks first and skip disabled slots, and its items, disabled slots, powered flag and animation ticks are saved with the chunk.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-09 12:48:23 +02:00
parent 19336564d2
commit f9eaae5a46
7 changed files with 597 additions and 14 deletions
+58
View File
@@ -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<ItemStack>; 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<ItemStack> {
@@ -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<ItemStack>] {
@@ -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<ItemStack>] {
@@ -202,6 +259,7 @@ impl BlockEntity {
| Self::Beacon(_)
| Self::Lectern(_)
| Self::Banner(_) => &mut [],
Self::Crafter(c) => &mut c.items,
}
}
}
+8 -4
View File
@@ -289,6 +289,10 @@ impl Recipes {
}
/// Match a `size`x`size` grid (row-major) against the crafting recipes.
pub fn craft(&self, grid: &[Option<ItemStack>], size: usize) -> Option<ItemStack> {
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<ItemStack>], 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()));
}
}
}
+18 -5
View File
@@ -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<ItemStack> {
match i {
200 => self.craft_result(),
309 => self.crafter_result(),
_ => self.slot_mut(i).clone(),
}
}
fn craft_result(&self) -> Option<ItemStack> {
let n = self.craft_size;
let grid: Vec<Option<ItemStack>> = (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.
@@ -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(());
@@ -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<Pos> = 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<Option<ItemStack>> = 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<ItemStack> {
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<String> {
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<usize> = (9..36).chain(0..9).collect();
self.move_to(&mut stack, &player, true);
} else {
let grid: Vec<usize> = (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<ItemStack> {
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"));
}
}
+9 -5
View File
@@ -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
+51
View File
@@ -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<G: ChunkGenerator> ChunkGenerator for Persistent<G> {
#[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 {