From 5febf0d95753a13eaf9ab420f265e08521a5e132 Mon Sep 17 00:00:00 2001 From: vlesmentie <129341611+vlesmentie@users.noreply.github.com> Date: Mon, 26 Oct 2026 00:24:10 -0300 Subject: [PATCH 1/4] Campfires cook food Horizon had no CampfireBlockEntity, so right-clicking a campfire with raw food did nothing. Now: - BlockEntity::Campfire keeps four slots with their cookingProgress and cookingTime, saved as Items, CookingTimes and CookingTotalTimes; both campfires share the minecraft:campfire block entity type. It is not a Container (only Clearable), so hoppers don't reach in. - CampfireBlock.useItemOn: a campfire_cooking input goes into the first free slot (placeFood) with its recipe's time; the use is consumed whether or not there was room, the item is used up outside creative, interact_with_campfire is awarded and a block_change goes out. A client of a server leaves it to the server. - cookTick (lit): each item's progress rises; a finished item's result drops at the block (Containers.dropItemStack), the slot empties and a block_change goes out. cooldownTick (unlit): progress falls by 2. - Breaking the campfire drops its items (preRemoveSideEffects). - The update tag (Items) reaches a server's clients, and CampfireRenderer draws the items on the fire. Fixes #1988. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/containers.rs | 104 +++++++++- crates/horizon-client/src/game.rs | 16 +- .../src/game/block_entity_ticks.rs | 6 +- crates/horizon-client/src/game/campfire.rs | 177 ++++++++++++++++++ crates/horizon-client/src/game/spill.rs | 8 +- crates/horizon-client/src/lan/chunks.rs | 5 + crates/horizon-client/src/save.rs | 43 +++++ 7 files changed, 352 insertions(+), 7 deletions(-) create mode 100644 crates/horizon-client/src/game/campfire.rs diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index 26ca193a2..267bb0ea0 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -83,6 +83,63 @@ pub enum BlockEntity { Beehive(Box), /// `CommandBlockEntity` of the three command blocks (`crate::command_block`). CommandBlock(Box), + /// `CampfireBlockEntity` of campfires and soul campfires. + Campfire(Box), +} +/// `CampfireBlockEntity`: four cooking slots, each with its +/// `cookingProgress` and `cookingTime` (the recipe's). +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Campfire { + pub items: [Option; 4], + pub progress: [i32; 4], + pub total: [i32; 4], +} +impl Campfire { + /// `placeFood`'s slot: the first empty one, given the item's + /// `campfire_cooking` time; it takes one item of `held`. + pub fn place_food(&mut self, held: &mut ItemStack, cooking_time: i32) -> bool { + let Some(slot) = self.items.iter().position(Option::is_none) else { + return false; + }; + self.total[slot] = cooking_time; + self.progress[slot] = 0; + self.items[slot] = Some(ItemStack { + count: 1, + ..held.clone() + }); + held.count = held.count.saturating_sub(1); + true + } + /// `cookTick` (lit): each item's progress rises by one; the slots whose + /// progress reached their cooking time give up their item (the caller + /// drops its result). + pub fn cook_tick(&mut self) -> Vec<(usize, ItemStack)> { + let mut done = Vec::new(); + for i in 0..4 { + if self.items[i].is_none() { + continue; + } + self.progress[i] += 1; + if self.progress[i] >= self.total[i] + && let Some(item) = self.items[i].take() + { + done.push((i, item)); + } + } + done + } + /// `cooldownTick` (unlit): the progress falls by two, no lower than 0. + /// Whether anything changed (`setChanged`). + pub fn cooldown_tick(&mut self) -> bool { + let mut changed = false; + for i in 0..4 { + if self.progress[i] > 0 { + changed = true; + self.progress[i] = (self.progress[i] - 2).clamp(0, self.total[i]); + } + } + changed + } } /// `CrafterBlockEntity`: nine slots that can be disabled, the powered flag /// and the ticks left in the crafting animation. @@ -247,6 +304,9 @@ impl BlockEntity { if name == "minecraft:brewing_stand" { return Some(Self::Brewing(Box::new(crate::brewing::BrewingStand::new()))); } + if name == "minecraft:campfire" || name == "minecraft:soul_campfire" { + return Some(Self::Campfire(Box::default())); + } let size = match name { "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => 27, n if n.ends_with("copper_chest") => 27, @@ -283,6 +343,7 @@ impl BlockEntity { Self::Vault(_) => "minecraft:vault", Self::Beehive(_) => "minecraft:beehive", Self::CommandBlock(_) => "minecraft:command_block", + Self::Campfire(_) => "minecraft:campfire", } } pub fn contents(&self) -> Vec { @@ -303,6 +364,7 @@ impl BlockEntity { Self::Sculk(_) => Vec::new(), Self::Banner(_) => Vec::new(), Self::Crafter(c) => c.items.iter().flatten().cloned().collect(), + Self::Campfire(c) => c.items.iter().flatten().cloned().collect(), } } pub fn slots(&self) -> &[Option] { @@ -322,7 +384,9 @@ impl BlockEntity { | Self::TrialSpawner(_) | Self::Vault(_) | Self::Beehive(_) - | Self::CommandBlock(_) => &[], + | Self::CommandBlock(_) + // Not a Container (only Clearable): hoppers don't reach in. + | Self::Campfire(_) => &[], } } pub fn slots_mut(&mut self) -> &mut [Option] { @@ -342,7 +406,8 @@ impl BlockEntity { | Self::TrialSpawner(_) | Self::Vault(_) | Self::Beehive(_) - | Self::CommandBlock(_) => &mut [], + | Self::CommandBlock(_) + | Self::Campfire(_) => &mut [], } } } @@ -631,6 +696,41 @@ mod tests { use super::*; use horizon_core::random::{LegacyRandom, RandomSource}; + #[test] + fn campfire_slots_take_food_cook_it_and_cool_down() { + let mut c = Campfire::default(); + let mut beef = ItemStack::new("minecraft:beef", 2); + // placeFood: the first free slot, one item, its recipe's time. + assert!(c.place_food(&mut beef, 600)); + assert_eq!(beef.count, 1); + assert_eq!(c.items[0].as_ref().map(|s| s.count), Some(1)); + assert_eq!((c.progress[0], c.total[0]), (0, 600)); + let mut fish = ItemStack::new("minecraft:cod", 1); + assert!(c.place_food(&mut fish, 3)); + assert_eq!(c.items[1].as_ref().map(|s| &*s.item), Some("minecraft:cod")); + // cookTick: the cod is done on its third tick, the beef keeps cooking. + assert!(c.cook_tick().is_empty()); + assert!(c.cook_tick().is_empty()); + let done = c.cook_tick(); + assert_eq!(done.len(), 1); + assert_eq!((done[0].0, &*done[0].1.item), (1, "minecraft:cod")); + assert!(c.items[1].is_none()); + assert_eq!(c.progress[0], 3); + // cooldownTick: two a tick, never below zero. + assert!(c.cooldown_tick()); + assert_eq!(c.progress[0], 1); + assert!(c.cooldown_tick()); + assert_eq!(c.progress[0], 0); + // Full: four slots, no fifth. + for _ in 0..3 { + let mut more = ItemStack::new("minecraft:potato", 1); + assert!(c.place_food(&mut more, 600)); + } + let mut fifth = ItemStack::new("minecraft:potato", 1); + assert!(!c.place_food(&mut fifth, 600)); + assert_eq!(fifth.count, 1); + } + /// A whole amount pays itself without a draw; a fraction is a chance of one more. #[test] fn create_experience_rounds_the_fraction_by_chance() { diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 942e8699f..a51176060 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -18,6 +18,7 @@ mod boats; mod books; mod bossbars; mod breezes; +mod campfire; mod cartography; mod chat; mod client_ambient; @@ -5159,7 +5160,8 @@ impl Game<'_> { | BlockEntity::TrialSpawner(_) | BlockEntity::Vault(_) | BlockEntity::Beehive(_) - | BlockEntity::CommandBlock(_), + | BlockEntity::CommandBlock(_) + | BlockEntity::Campfire(_), ) => {} None => { v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i)); @@ -5428,7 +5430,8 @@ impl Game<'_> { | BlockEntity::TrialSpawner(_) | BlockEntity::Vault(_) | BlockEntity::Beehive(_) - | BlockEntity::CommandBlock(_), + | BlockEntity::CommandBlock(_) + | BlockEntity::Campfire(_), ) => {} None if self.mount_active() => self.draw_mount_background(batch, ox, oy), None => { @@ -6866,6 +6869,9 @@ impl Game<'_> { // `VaultRenderer`. self.mark_entity(out.len(), ""); self.vault_geometry(camera, alpha, &mut out); + // `CampfireRenderer`. + self.mark_entity(out.len(), ""); + self.campfire_geometry(camera, &mut out); self.mark_entity(out.len(), "minecraft:ominous_item_spawner"); self.ominous_item_spawner_geometry(camera, alpha, &mut out); // Mobs and their projectiles (a span each). @@ -8524,6 +8530,12 @@ impl Game<'_> { { return Ok(UseResult::Success { swing: true }); } + if allow_block_actions + && let Some(hit) = self.pick() + && self.use_on_campfire(hit.pos)? + { + return Ok(UseResult::Success { swing: true }); + } // BucketItem has no useOn: a guest's UseItemOn leaves it to UseItem. let bucket = horizon_client::items::bucket_contents(&stack.item); if matches!(self.guest_use, Some(GuestUse::OnBlock(_))) diff --git a/crates/horizon-client/src/game/block_entity_ticks.rs b/crates/horizon-client/src/game/block_entity_ticks.rs index e48c8f398..e0798b4cb 100644 --- a/crates/horizon-client/src/game/block_entity_ticks.rs +++ b/crates/horizon-client/src/game/block_entity_ticks.rs @@ -56,6 +56,7 @@ impl Game<'_> { Some(BlockEntity::Beehive(_)) => self.tick_beehive(pos), Some(BlockEntity::Furnace(_)) => self.tick_furnace(pos)?, Some(BlockEntity::Brewing(_)) => self.tick_brewing_stand(pos)?, + Some(BlockEntity::Campfire(_)) => self.tick_campfire(pos)?, _ => {} } } @@ -92,7 +93,10 @@ impl Game<'_> { | "minecraft:vault" | "minecraft:beehive" | "minecraft:bee_nest" - | "minecraft:brewing_stand" => Ticking::Yes, + | "minecraft:brewing_stand" + // Lit, cookTick; unlit, cooldownTick. + | "minecraft:campfire" + | "minecraft:soul_campfire" => Ticking::Yes, "minecraft:jukebox" => { let record = registry .state(state) diff --git a/crates/horizon-client/src/game/campfire.rs b/crates/horizon-client/src/game/campfire.rs new file mode 100644 index 000000000..cd27914c7 --- /dev/null +++ b/crates/horizon-client/src/game/campfire.rs @@ -0,0 +1,177 @@ +//! Campfires' cooking: `CampfireBlock.useItemOn` (`CampfireBlockEntity.placeFood`) +//! and the block entity's `cookTick` (lit) and `cooldownTick` (unlit). The +//! items drawn on the fire are `campfire_geometry`'s; a server's clients get +//! them through the block entity's update tag (`lan::chunks::entity_tag`). +use super::Game; +use horizon_assets::item_model::DisplayContext; +use horizon_client::{ + Result, block_entities::Pos, block_entity_render::vertex_light, containers::BlockEntity, + items::ItemStack, mesher::Vertex, mobs::Who, +}; +use horizon_core::position::BlockPos; + +/// The `campfire_cooking` recipe kind (`RecipeType.CAMPFIRE_COOKING`). +const KIND: &str = "minecraft:campfire_cooking"; + +fn is_campfire(name: &str) -> bool { + name == "minecraft:campfire" || name == "minecraft:soul_campfire" +} + +impl Game<'_> { + /// `CampfireBlock.useItemOn` with a held item that is a campfire recipe's + /// input (`RecipePropertySet.CAMPFIRE_INPUT`): on a server level the food + /// goes into the first free slot (`placeFood`), and the use is consumed + /// whether or not there was room. A client of a server leaves the placing + /// to the server. False when this isn't a campfire use, so the item's own + /// use runs. + pub(super) fn use_on_campfire(&mut self, pos: [i32; 3]) -> Result { + let state = self.world.block(pos[0], pos[1], pos[2]); + if !is_campfire(&self.res.facts().get(state).name) { + return Ok(false); + } + let Some(held) = self.held().cloned() else { + return Ok(false); + }; + let Some(time) = self.res.recipes().cook(KIND, &held).map(|r| r.time as i32) else { + return Ok(false); + }; + if self.remote.is_some() { + return Ok(true); + } + let key = (pos[0], pos[1], pos[2]); + let placed = match self.world.block_entities.get_mut(&key) { + Some(BlockEntity::Campfire(c)) => { + let mut one = held.clone(); + c.place_food(&mut one, time) + } + _ => false, + }; + if placed { + // ItemStack.consumeAndReturn: creative keeps the item. + self.consume_held(); + self.stats.custom("interact_with_campfire", 1); + self.post_block_game_event( + "minecraft:block_change", + pos, + Some(Who::Player), + Some(state), + ); + self.mark_block_entity_updated(key); + } + Ok(true) + } + + /// `CampfireBlockEntity.cookTick` of a lit campfire, `cooldownTick` of an + /// unlit one. A finished item's result (the recipe's, or the item itself + /// when no recipe takes it any more) drops at the block's corner + /// (`Containers.dropItemStack` at its integer position), then the clients + /// see the slot empty and a `block_change` goes out. + pub(super) fn tick_campfire(&mut self, pos: Pos) -> Result<()> { + let state = self.world.block(pos.0, pos.1, pos.2); + let lit = self + .pack + .assets + .registry + .state(state) + .and_then(|s| s.properties.get("lit")) + .is_some_and(|v| v == "true"); + let Some(BlockEntity::Campfire(c)) = self.world.block_entities.get_mut(&pos) else { + return Ok(()); + }; + if !lit { + c.cooldown_tick(); + return Ok(()); + } + let done = c.cook_tick(); + for (_, item) in done { + let result = self + .res + .recipes() + .cook(KIND, &item) + .map_or_else(|| item.clone(), |r| r.result.clone()); + self.campfire_drop(pos, result); + self.mark_block_entity_updated(pos); + self.post_block_game_event( + "minecraft:block_change", + [pos.0, pos.1, pos.2], + None, + Some(state), + ); + } + Ok(()) + } + + /// `CampfireRenderer`: each cooking item lies on the fire, slot `i` + /// turned to `Direction.from2DDataValue((i + facing) % 4)`, laid flat + /// (90° about X), at a corner and three eighths of its size, drawn as a + /// FIXED item seeded by the block's position plus the slot. + pub(super) fn campfire_geometry(&self, camera: glam::DVec3, out: &mut Vec) { + for (key, entity) in &self.world.block_entities { + let BlockEntity::Campfire(c) = entity else { + continue; + }; + if c.items.iter().all(Option::is_none) { + continue; + } + let at = glam::DVec3::new(f64::from(key.0), f64::from(key.1), f64::from(key.2)); + if at.distance_squared(camera) >= 64.0 * 64.0 { + continue; + } + // Direction.get2DDataValue: south 0, west 1, north 2, east 3. + let state = self.world.block(key.0, key.1, key.2); + let facing = match self + .pack + .assets + .registry + .state(state) + .and_then(|s| s.properties.get("facing")) + .map(String::as_str) + { + Some("west") => 1, + Some("north") => 2, + Some("east") => 3, + _ => 0, + }; + let light = vertex_light(self.world.light(key.0, key.1, key.2)); + let packed = BlockPos::new(key.0, key.1, key.2).pack(); + for (i, stack) in c.items.iter().enumerate() { + let Some(stack) = stack else { + continue; + }; + let seed = (packed as i32).wrapping_add(i as i32); + let item = self.resolve_item(stack, DisplayContext::Fixed, None, seed); + if item.is_empty() { + continue; + } + // Direction.toYRot: 90° per 2D step from south. + let yaw = -(((i + facing) % 4) as f32 * 90.0); + let pose = glam::Mat4::from_translation( + (at - camera).as_vec3() + glam::Vec3::new(0.5, 0.449_218_75, 0.5), + ) * glam::Mat4::from_rotation_y(yaw.to_radians()) + * glam::Mat4::from_rotation_x(90f32.to_radians()) + * glam::Mat4::from_translation(glam::Vec3::new(-0.3125, -0.3125, 0.0)) + * glam::Mat4::from_scale(glam::Vec3::splat(0.375)); + self.submit_item_world(&item, pose, light, out); + } + } + } + + /// `Containers.dropItemStack(level, x, y, z, stack)` at the block's + /// integer position. + fn campfire_drop(&mut self, pos: Pos, stack: ItemStack) { + let at = BlockPos::new(pos.0, pos.1, pos.2); + for piece in + horizon_world::level::removal::drop_item_stack(&mut self.world.random, at, stack.count) + { + self.spawn_item( + ItemStack { + count: piece.count, + ..stack.clone() + }, + piece.pos, + piece.motion, + 0, + ); + } + } +} diff --git a/crates/horizon-client/src/game/spill.rs b/crates/horizon-client/src/game/spill.rs index b7283c57b..7f370507f 100644 --- a/crates/horizon-client/src/game/spill.rs +++ b/crates/horizon-client/src/game/spill.rs @@ -398,8 +398,12 @@ impl GameLevel<'_> { } } PreRemove::Campfire => { - for _ in 0..4 { - self.drop_item_stack(pos, None); + let items = match &entity { + Some(BlockEntity::Campfire(c)) => c.items.clone(), + _ => Default::default(), + }; + for stack in items { + self.drop_item_stack(pos, stack); } } PreRemove::Jukebox => { diff --git a/crates/horizon-client/src/lan/chunks.rs b/crates/horizon-client/src/lan/chunks.rs index 65b092881..aecc9cee6 100644 --- a/crates/horizon-client/src/lan/chunks.rs +++ b/crates/horizon-client/src/lan/chunks.rs @@ -938,6 +938,11 @@ pub fn entity_tag(entity: &BlockEntity) -> Option { BlockEntity::Sign(sign) => Some(Tag::compound(sign.encode())), BlockEntity::Spawner(s) => Some(s.update_tag()), BlockEntity::Jukebox(_) | BlockEntity::Lectern(_) => None, + // CampfireBlockEntity.getUpdateTag: the items alone. + BlockEntity::Campfire(c) => Some(Tag::compound([( + "Items", + crate::save::encode_items(&c.items), + )])), _ => None, } } diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 03a36a2cd..030d13344 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -526,6 +526,12 @@ pub fn encode_block_entity( } } BlockEntity::Sculk(s) => entries.extend(s.to_nbt()), + // CampfireBlockEntity.saveAdditional. + BlockEntity::Campfire(c) => { + entries.push(("Items", encode_items(&c.items))); + entries.push(("CookingTimes", Tag::IntArray(c.progress.to_vec()))); + entries.push(("CookingTotalTimes", Tag::IntArray(c.total.to_vec()))); + } BlockEntity::Crafter(c) => { entries.push(("Items", encode_items(&c.items))); entries.push(( @@ -681,6 +687,18 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain } BlockEntity::Sign(sign) => sign.decode(tag), BlockEntity::Sculk(s) => s.load(tag), + // CampfireBlockEntity.loadAdditional: missing time arrays stay zeros. + BlockEntity::Campfire(c) => { + for (slot, item) in decode_items(tag.get("Items"), 4).into_iter().enumerate() { + c.items[slot] = item; + } + let ints = |key: &str| match tag.get(key) { + Some(Tag::IntArray(v)) => std::array::from_fn(|i| v.get(i).copied().unwrap_or(0)), + _ => [0; 4], + }; + c.progress = ints("CookingTimes"); + c.total = ints("CookingTotalTimes"); + } BlockEntity::Crafter(c) => { for (slot, item) in decode_items(tag.get("Items"), 9).into_iter().enumerate() { c.items[slot] = item; @@ -3849,6 +3867,31 @@ mod tests { assert_eq!(back.redstone_signal(), 2); } #[test] + fn campfire_block_entity_round_trips() { + let mut c = crate::containers::Campfire::default(); + c.items[1] = Some(crate::items::ItemStack::new("minecraft:beef", 1)); + c.progress[1] = 120; + c.total[1] = 600; + let tag = encode_block_entity( + (3, 64, -2), + &crate::containers::BlockEntity::Campfire(Box::new(c.clone())), + "minecraft:soul_campfire", + ); + // One block entity type for both campfires. + assert_eq!(text(tag.get("id")).as_deref(), Some("minecraft:campfire")); + let (pos, back) = decode_block_entity(&tag).expect("campfire"); + assert_eq!(pos, (3, 64, -2)); + let crate::containers::BlockEntity::Campfire(back) = back else { + panic!("not a campfire"); + }; + assert_eq!(*back, c); + // The update tag a server's clients get: the items alone. + let update = + crate::lan::chunks::entity_tag(&crate::containers::BlockEntity::Campfire(Box::new(c))) + .expect("update tag"); + assert!(update.get("Items").is_some() && update.get("CookingTimes").is_none()); + } + #[test] fn spawner_block_entity_round_trips() { // A dungeon spawner as vanilla saves it (`id` is mob_spawner, not the block). let saved = horizon_world::nbt::parse_snbt( From fdba6b41530f3b0258acc5bd7dc778bb0b39f060 Mon Sep 17 00:00:00 2001 From: vlesmentie <129341611+vlesmentie@users.noreply.github.com> Date: Mon, 26 Oct 2026 03:43:02 -0300 Subject: [PATCH 2/4] Campfire timers mark their chunk for saving CampfireBlockEntity.cookTick and cooldownTick call setChanged whenever a timer moves (cookTick while any slot holds food, cooldownTick while any progress is above zero). tick_campfire only marked the chunk when an item finished, so after a save partway through cooking, an unload saved nothing and the progress since went back to the saved value. The chunk is now marked modified on those ticks, with no update to the clients, who don't see the timers. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/campfire.rs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/campfire.rs b/crates/horizon-client/src/game/campfire.rs index cd27914c7..100675c30 100644 --- a/crates/horizon-client/src/game/campfire.rs +++ b/crates/horizon-client/src/game/campfire.rs @@ -78,10 +78,22 @@ impl Game<'_> { let Some(BlockEntity::Campfire(c)) = self.world.block_entities.get_mut(&pos) else { return Ok(()); }; + // BlockEntity.setChanged: a timer that moved is saved with the + // chunk (no update to the clients, who don't see the timers). + let changed = if lit { + c.items.iter().any(Option::is_some) + } else { + c.cooldown_tick() + }; + if changed { + self.world.modified.insert((pos.0 >> 4, pos.2 >> 4)); + } if !lit { - c.cooldown_tick(); return Ok(()); } + let Some(BlockEntity::Campfire(c)) = self.world.block_entities.get_mut(&pos) else { + return Ok(()); + }; let done = c.cook_tick(); for (_, item) in done { let result = self From a83d6f33bea6bd2fc00197580b148edd3eaad3c8 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 14:31:50 +0100 Subject: [PATCH 3/4] Campfire: a full campfire's use does not swing the arm CampfireBlock.useItemOn returns SUCCESS_SERVER (a swing) only when placeFood took the item, and CONSUME (no swing) when all four slots are taken. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 5 +++-- crates/horizon-client/src/game/campfire.rs | 17 +++++++++-------- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 702a26025..c58b01024 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -8666,9 +8666,10 @@ impl Game<'_> { } if allow_block_actions && let Some(hit) = self.pick() - && self.use_on_campfire(hit.pos)? + && let Some(placed) = self.use_on_campfire(hit.pos)? { - return Ok(UseResult::Success { swing: true }); + // SUCCESS_SERVER swings; a full campfire's CONSUME does not. + return Ok(UseResult::Success { swing: placed }); } // BucketItem has no useOn: a guest's UseItemOn leaves it to UseItem. let bucket = horizon_client::items::bucket_contents(&stack.item); diff --git a/crates/horizon-client/src/game/campfire.rs b/crates/horizon-client/src/game/campfire.rs index 100675c30..c388b7561 100644 --- a/crates/horizon-client/src/game/campfire.rs +++ b/crates/horizon-client/src/game/campfire.rs @@ -22,21 +22,22 @@ impl Game<'_> { /// input (`RecipePropertySet.CAMPFIRE_INPUT`): on a server level the food /// goes into the first free slot (`placeFood`), and the use is consumed /// whether or not there was room. A client of a server leaves the placing - /// to the server. False when this isn't a campfire use, so the item's own - /// use runs. - pub(super) fn use_on_campfire(&mut self, pos: [i32; 3]) -> Result { + /// to the server. Whether the food went in; None when this isn't a + /// campfire use, so the item's own use runs. + pub(super) fn use_on_campfire(&mut self, pos: [i32; 3]) -> Result> { let state = self.world.block(pos[0], pos[1], pos[2]); if !is_campfire(&self.res.facts().get(state).name) { - return Ok(false); + return Ok(None); } let Some(held) = self.held().cloned() else { - return Ok(false); + return Ok(None); }; let Some(time) = self.res.recipes().cook(KIND, &held).map(|r| r.time as i32) else { - return Ok(false); + return Ok(None); }; + // A client of a server predicts the placing; the server decides. if self.remote.is_some() { - return Ok(true); + return Ok(Some(true)); } let key = (pos[0], pos[1], pos[2]); let placed = match self.world.block_entities.get_mut(&key) { @@ -58,7 +59,7 @@ impl Game<'_> { ); self.mark_block_entity_updated(key); } - Ok(true) + Ok(Some(placed)) } /// `CampfireBlockEntity.cookTick` of a lit campfire, `cooldownTick` of an From ba797f60a1063472bdf4d5f8dfc23e49c1b60a6b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 16:17:25 +0100 Subject: [PATCH 4/4] save_roundtrip: the lit campfire keeps cooking while Horizon runs Campfires now tick, so the fixture's campfire advances its CookingTimes between load and save, as the lit furnace does. Co-Authored-By: Claude Opus 5.5 --- tools/test_save_roundtrip_parity.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tools/test_save_roundtrip_parity.py b/tools/test_save_roundtrip_parity.py index 732429881..7b3c72e92 100644 --- a/tools/test_save_roundtrip_parity.py +++ b/tools/test_save_roundtrip_parity.py @@ -80,6 +80,8 @@ IGNORED = { # chunk generation first), so counters and positions of live things move on. r'^chunk\.block_entities\.\(2, -60, 5\)\.(cooking_time_spent|lit_time_remaining|Items\[\]\.count)$': 'the lit furnace keeps smelting', + r'^chunk\.block_entities\.\(14, -60, 5\)\.CookingTimes$': + 'the lit campfire keeps cooking', r'^chunk\.block_entities\..*\.(ticks_since_song_started|Age|BrewTime|warning_level|ticks_in_hive|last_vibration_frequency|listener\..*|RecipesUsed\..*|' r'server_data\.state_updating_resumes_at)$': 'block entity timers advance',