Campfires and Smelting Recipes

steel-core/build/build.rs

@@ -12,6 +12,7 @@ use std::fs;
 use syn::Ident;
 
 mod blocks;
+mod candle_cakes;
 mod common;
 mod items;
 mod strippables;
@@ -40,6 +41,8 @@ pub fn main() {
         blocks::build(&classes.blocks),
     )
     .expect("Failed to write blocks.rs");
+    fs::write(format!("{out_dir}/candle_cakes.rs"), candle_cakes::build())
+        .expect("Failed to write candle_cakes.rs");
     fs::write(format!("{out_dir}/items.rs"), items::build(&classes.items))
         .expect("Failed to write items.rs");
     fs::write(format!("{out_dir}/waxables.rs"), waxables::build())

steel-core/build/candle_cakes.json

@@ -0,0 +1,19 @@
+{
+  "blue_candle": "blue_candle_cake",
+  "green_candle": "green_candle_cake",
+  "red_candle": "red_candle_cake",
+  "pink_candle": "pink_candle_cake",
+  "yellow_candle": "yellow_candle_cake",
+  "magenta_candle": "magenta_candle_cake",
+  "brown_candle": "brown_candle_cake",
+  "light_gray_candle": "light_gray_candle_cake",
+  "candle": "candle_cake",
+  "white_candle": "white_candle_cake",
+  "gray_candle": "gray_candle_cake",
+  "cyan_candle": "cyan_candle_cake",
+  "lime_candle": "lime_candle_cake",
+  "orange_candle": "orange_candle_cake",
+  "black_candle": "black_candle_cake",
+  "light_blue_candle": "light_blue_candle_cake",
+  "purple_candle": "purple_candle_cake"
+}

steel-core/build/candle_cakes.rs

@@ -0,0 +1,35 @@
+use std::{collections::BTreeMap, fs};
+
+use proc_macro2::Span;
+use quote::quote;
+use syn::Ident;
+
+use crate::to_block_ident;
+
+pub fn build() -> String {
+    println!("cargo:rerun-if-changed=build/candle_cakes.json");
+
+    let candle_cakes_json =
+        fs::read_to_string("build/candle_cakes.json").expect("Failed to read candle_cakes.json");
+    let candle_cakes_raw: BTreeMap<String, String> =
+        serde_json::from_str(&candle_cakes_json).expect("Failed to parse candle_cakes.json");
+
+    let by_candle: Vec<proc_macro2::TokenStream> = candle_cakes_raw
+        .iter()
+        .map(|(key, value)| (Ident::new(key.to_lowercase().as_str(), Span::call_site()), to_block_ident(value)))
+        .map(|(key, value)| quote! { i if i == &vanilla_items::ITEMS.#key => Some(&vanilla_blocks::#value), })
+        .collect();
+
+    let output = quote! {
+        use steel_registry::{blocks::BlockRef, items::ItemRef, vanilla_blocks, vanilla_items};
+
+        pub fn candle_to_candle_cake(item: ItemRef) -> Option<BlockRef> {
+            match item {
+                #(#by_candle)*
+                _ => None
+            }
+        }
+    };
+
+    output.to_string()
+}

steel-core/src/behavior/block.rs

@@ -12,6 +12,7 @@ use steel_registry::{REGISTRY, RegistryEntry, RegistryExt};
 use steel_utils::types::{InteractionHand, UpdateFlags};
 use steel_utils::{BlockPos, BlockStateId};
 
+use crate::behavior::InventoryAccess;
 use crate::behavior::context::{BlockHitResult, BlockPlaceContext, InteractionResult};
 use crate::block_entity::SharedBlockEntity;
 use crate::entity::Entity;
@@ -144,13 +145,13 @@ pub trait BlockBehavior: Send + Sync {
     )]
     fn use_item_on(
         &self,
-        item_stack: &ItemStack,
         state: BlockStateId,
         world: &Arc<World>,
         pos: BlockPos,
         player: &Player,
         hand: InteractionHand,
         hit_result: &BlockHitResult,
+        inv: &mut InventoryAccess,
     ) -> InteractionResult {
         InteractionResult::TryEmptyHandInteraction
     }
@@ -171,6 +172,7 @@ pub trait BlockBehavior: Send + Sync {
         pos: BlockPos,
         player: &Player,
         hit_result: &BlockHitResult,
+        inv: &mut InventoryAccess,
     ) -> InteractionResult {
         InteractionResult::Pass
     }
@@ -398,7 +400,7 @@ pub trait BlockBehavior: Send + Sync {
     /// Vanilla parity: `LiquidBlockContainer.canPlaceLiquid()`.
     ///
     /// Returns `true` if the given fluid type may be placed into this block at the
-    /// given state.  Called by the fluid-spread logic; there is no player context
+    /// given state. Called by the fluid-spread logic; there is no player context
     /// here (fluid spreading has no associated player).
     ///
     /// Default (`SimpleWaterloggedBlock`): accepts water when the block has a

steel-core/src/behavior/blocks/building/campfire.rs

@@ -0,0 +1,221 @@
+use std::sync::{Arc, Weak};
+
+use steel_macros::block_behavior;
+use steel_registry::{
+    REGISTRY, TaggedRegistryExt,
+    blocks::{BlockRef, block_state_ext::BlockStateExt, properties::BlockStateProperties},
+    fluid::{FluidState, FluidStateExt},
+    items::item::BlockHitResult,
+    sound_events, vanilla_block_entity_types, vanilla_block_tags, vanilla_blocks,
+    vanilla_damage_types, vanilla_fluids, vanilla_recipe_property_sets,
+};
+use steel_utils::{
+    BlockPos, BlockStateId, Direction,
+    types::{InteractionHand, UpdateFlags},
+};
+
+use crate::{
+    behavior::{BlockBehavior, BlockPlaceContext, InteractionResult, InventoryAccess},
+    block_entity::{BLOCK_ENTITIES, SharedBlockEntity, entities::CampfireBlockEntity},
+    entity::{Entity, damage::DamageSource},
+    player::Player,
+    world::World,
+};
+
+/// Behavior for Campfires
+/// - [ ] projectile hit
+/// - [ ] getTicker to run cooking ticks
+#[block_behavior]
+pub struct CampfireBlock {
+    block: BlockRef,
+    #[json_arg(value)]
+    fire_damage: i32,
+}
+
+impl CampfireBlock {
+    /// Creates a new Campfire Block Behavior
+    #[must_use]
+    pub const fn new(block: BlockRef, fire_damage: i32) -> Self {
+        Self { block, fire_damage }
+    }
+
+    /// Whether or not the Campfire can be lit
+    #[must_use]
+    pub fn can_light(state: BlockStateId) -> bool {
+        REGISTRY
+            .blocks
+            .is_in_tag(state.get_block(), &vanilla_block_tags::CAMPFIRES_TAG)
+            && !state
+                .try_get_value(&BlockStateProperties::WATERLOGGED)
+                .unwrap_or(true)
+            && !state
+                .try_get_value(&BlockStateProperties::LIT)
+                .unwrap_or(true)
+    }
+}
+
+impl BlockBehavior for CampfireBlock {
+    fn get_state_for_placement(
+        &self,
+        context: &BlockPlaceContext<'_>,
+    ) -> Option<steel_utils::BlockStateId> {
+        let is_replacing_water = context.is_water_source();
+
+        Some(
+            self.block
+                .default_state()
+                .set_value(&BlockStateProperties::WATERLOGGED, is_replacing_water)
+                .set_value(
+                    &BlockStateProperties::SIGNAL_FIRE,
+                    context
+                        .world
+                        .get_block_state(context.relative_pos.below())
+                        .get_block()
+                        == &vanilla_blocks::HAY_BLOCK,
+                )
+                .set_value(&BlockStateProperties::LIT, !is_replacing_water)
+                .set_value(
+                    &BlockStateProperties::HORIZONTAL_FACING,
+                    context.horizontal_direction,
+                ),
+        )
+    }
+
+    fn update_shape(
+        &self,
+        state: BlockStateId,
+        world: &Arc<World>,
+        pos: BlockPos,
+        direction: Direction,
+        _neighbor_pos: BlockPos,
+        _neighbor_state: BlockStateId,
+    ) -> BlockStateId {
+        if state.get_value(&BlockStateProperties::WATERLOGGED) {
+            world.schedule_fluid_tick_default(
+                pos,
+                &vanilla_fluids::WATER,
+                vanilla_fluids::WATER.tick_delay as i32,
+            );
+        }
+
+        if direction == Direction::Down {
+            return state.set_value(
+                &BlockStateProperties::SIGNAL_FIRE,
+                world.get_block_state(pos.below()).get_block() == &vanilla_blocks::HAY_BLOCK,
+            );
+        }
+        state
+    }
+
+    fn entity_inside(
+        &self,
+        state: BlockStateId,
+        _world: &Arc<World>,
+        _pos: BlockPos,
+        entity: &dyn Entity,
+    ) {
+        if state.get_value(&BlockStateProperties::LIT)
+            && let Some(living) = entity.as_living()
+        {
+            living.hurt(
+                &DamageSource::environment(&vanilla_damage_types::CAMPFIRE),
+                self.fire_damage as f32,
+            );
+        }
+    }
+
+    fn get_fluid_state(&self, state: BlockStateId) -> FluidState {
+        if state.get_value(&BlockStateProperties::WATERLOGGED) {
+            FluidState::source(&vanilla_fluids::WATER)
+        } else {
+            FluidState::EMPTY
+        }
+    }
+
+    fn place_liquid(
+        &self,
+        world: &Arc<World>,
+        pos: BlockPos,
+        state: BlockStateId,
+        fluid_state: FluidState,
+    ) -> bool {
+        if state.get_value(&BlockStateProperties::WATERLOGGED) || !fluid_state.is_water() {
+            return false;
+        }
+
+        if !fluid_state.is_source() {
+            // this is a really weird fix for placing campfires not being destroyed when being placed under a water source
+            return true;
+        }
+
+        if state.get_value(&BlockStateProperties::LIT) {
+            world.play_block_sound(
+                sound_events::ENTITY_GENERIC_EXTINGUISH_FIRE,
+                pos,
+                1.0,
+                1.0,
+                None,
+            );
+        }
+        world.set_block(
+            pos,
+            state
+                .set_value(&BlockStateProperties::WATERLOGGED, true)
+                .set_value(&BlockStateProperties::LIT, false),
+            UpdateFlags::UPDATE_ALL,
+        );
+
+        world.schedule_fluid_tick_default(
+            pos,
+            fluid_state.fluid_id,
+            fluid_state.fluid_id.tick_delay as i32,
+        );
+
+        true
+    }
+
+    fn has_block_entity(&self) -> bool {
+        true
+    }
+
+    fn new_block_entity(
+        &self,
+        level: Weak<World>,
+        pos: BlockPos,
+        state: BlockStateId,
+    ) -> Option<SharedBlockEntity> {
+        BLOCK_ENTITIES.create(&vanilla_block_entity_types::CAMPFIRE, level, pos, state)
+    }
+
+    fn use_item_on(
+        &self,
+        _state: BlockStateId,
+        world: &Arc<World>,
+        pos: BlockPos,
+        player: &Player,
+        _hand: InteractionHand,
+        _hit_result: &BlockHitResult,
+        inv: &mut InventoryAccess,
+    ) -> InteractionResult {
+        let item_stack = inv.item();
+        let Some(block_entity) = world.get_block_entity(pos) else {
+            return InteractionResult::Fail;
+        };
+
+        if !vanilla_recipe_property_sets::CAMPFIRE_INPUT.contains(&item_stack.item()) {
+            return InteractionResult::TryEmptyHandInteraction;
+        }
+
+        let mut lock = block_entity.lock();
+
+        let Some(campfire_entity) = lock.as_any_mut().downcast_mut::<CampfireBlockEntity>() else {
+            return InteractionResult::Fail;
+        };
+
+        if campfire_entity.place_food(item_stack, player.has_infinite_materials()) {
+            return InteractionResult::Success;
+        }
+
+        InteractionResult::TryEmptyHandInteraction
+    }
+}

steel-core/src/behavior/blocks/building/mod.rs

@@ -1,7 +1,9 @@
+mod campfire;
 mod fence_block;
 mod rotated_pillar_block;
 mod weathering_block;
 
+pub use campfire::CampfireBlock;
 pub use fence_block::FenceBlock;
 pub use rotated_pillar_block::RotatedPillarBlock;
 pub use weathering_block::{WeatherState, WeatheringCopper, WeatheringCopperFullBlock};

steel-core/src/behavior/blocks/container/barrel_block.rs

@@ -12,6 +12,7 @@ use steel_registry::vanilla_block_entity_types;
 use steel_utils::{BlockPos, BlockStateId, translations};
 use text_components::TextComponent;
 
+use crate::behavior::InventoryAccess;
 use crate::behavior::block::BlockBehavior;
 use crate::behavior::context::{BlockHitResult, BlockPlaceContext, InteractionResult};
 use crate::block_entity::{BLOCK_ENTITIES, SharedBlockEntity};
@@ -57,6 +58,7 @@ impl BlockBehavior for BarrelBlock {
         pos: BlockPos,
         player: &Player,
         _hit_result: &BlockHitResult,
+        _inv: &mut InventoryAccess,
     ) -> InteractionResult {
         // Get the block entity
         let Some(block_entity) = world.get_block_entity(pos) else {

steel-core/src/behavior/blocks/container/crafting_table_block.rs

@@ -8,6 +8,7 @@ use steel_macros::block_behavior;
 use steel_registry::blocks::BlockRef;
 use steel_utils::{BlockPos, BlockStateId};
 
+use crate::behavior::InventoryAccess;
 use crate::behavior::block::BlockBehavior;
 use crate::behavior::context::{BlockHitResult, BlockPlaceContext, InteractionResult};
 use crate::inventory::CraftingMenuProvider;
@@ -43,6 +44,7 @@ impl BlockBehavior for CraftingTableBlock {
         pos: BlockPos,
         player: &Player,
         _hit_result: &BlockHitResult,
+        _inv: &mut InventoryAccess,
     ) -> InteractionResult {
         player.open_menu(&CraftingMenuProvider::new(player.inventory.clone(), pos));
         // TODO: Award stat INTERACT_WITH_CRAFTING_TABLE