Feat: spawn egg

steel-core/src/behavior/block/mod.rs

@@ -610,6 +610,11 @@ pub trait BlockBehavior: Send + Sync {
         false
     }
 
+    /// Returns whether this behavior implements vanilla `LiquidBlock`.
+    fn is_liquid_block(&self) -> bool {
+        false
+    }
+
     /// Mirrors vanilla `DoorBlock.isWoodenDoor`.
     ///
     /// Despite the vanilla name, this returns true for any door block type that

steel-core/src/behavior/blocks/fluid/liquid_block.rs

@@ -133,6 +133,10 @@ impl LiquidBlock {
 }
 
 impl BlockBehavior for LiquidBlock {
+    fn is_liquid_block(&self) -> bool {
+        true
+    }
+
     fn get_state_for_placement(&self, _context: &BlockPlaceContext<'_>) -> Option<BlockStateId> {
         Some(self.block.default_state())
     }
@@ -357,4 +361,20 @@ mod tests {
         assert_eq!(updated, state);
         assert!(level.scheduled_block_ticks.borrow().is_empty());
     }
+
+    #[test]
+    fn liquid_block_behavior_and_ext_identify_liquid_blocks() {
+        use crate::behavior::BlockStateBehaviorExt as _;
+
+        init_vanilla_registry();
+        init_behaviors();
+
+        let liquid = LiquidBlock::new(&vanilla_blocks::WATER, &vanilla_fluids::WATER);
+        assert!(liquid.is_liquid_block());
+
+        assert!(vanilla_blocks::WATER.default_state().is_liquid_block());
+        assert!(vanilla_blocks::LAVA.default_state().is_liquid_block());
+        assert!(!vanilla_blocks::STONE.default_state().is_liquid_block());
+        assert!(!vanilla_blocks::AIR.default_state().is_liquid_block());
+    }
 }

steel-core/src/behavior/item.rs

@@ -17,7 +17,7 @@ use steel_registry::{REGISTRY, RegistryEntry, RegistryExt, sound_events, vanilla
 use steel_utils::types::InteractionHand;
 use text_components::TextComponent;
 
-use crate::behavior::items::DefaultItemBehavior;
+use crate::behavior::items::{DefaultItemBehavior, SpawnEggItem};
 use crate::behavior::{InteractionResult, UseItemContext, UseOnContext};
 use crate::entity::consume_effect::apply_consume_effect;
 use crate::entity::damage::DamageSource;
@@ -224,6 +224,11 @@ pub trait ItemBehavior: Send + Sync {
             .get_weapon()
             .map(|weapon| weapon.item_damage_per_attack)
     }
+
+    /// Returns this item behavior as a `SpawnEggItem`.
+    fn as_spawn_egg(&self) -> Option<&SpawnEggItem> {
+        None
+    }
 }
 
 fn should_emit_consume_particles_and_sounds(consumable: &Consumable, ticks_remaining: i32) -> bool {

steel-core/src/behavior/items/mod.rs

@@ -36,6 +36,7 @@ mod shovel;
 mod sign_item;
 mod snowball;
 mod solid_bucket_item;
+mod spawn_egg;
 mod spyglass;
 mod standing_and_wall_block_item;
 mod throwable_potion;
@@ -79,6 +80,7 @@ pub use shovel::ShovelItem;
 pub use sign_item::{HangingSignItem, SignItem};
 pub use snowball::SnowballItem;
 pub use solid_bucket_item::SolidBucketItem;
+pub use spawn_egg::SpawnEggItem;
 pub use spyglass::SpyglassItem;
 pub use standing_and_wall_block_item::StandingAndWallBlockItem;
 pub use throwable_potion::{LingeringPotionItem, SplashPotionItem};

steel-core/src/behavior/items/spawn_egg.rs

@@ -0,0 +1,229 @@
+//! Data-driven vanilla spawn-egg behavior.
+
+use std::sync::Arc;
+
+use steel_macros::item_behavior;
+use steel_registry::blocks::block_state_ext::BlockStateExt as _;
+use steel_registry::data_components::components::EntityData;
+use steel_registry::data_components::vanilla_components::ENTITY_DATA;
+use steel_registry::entity_type::EntityTypeRef;
+use steel_registry::item_stack::ItemStack;
+use steel_registry::stat::vanilla_stat_types;
+use steel_registry::{vanilla_blocks, vanilla_game_events};
+use steel_utils::BlockPos;
+
+use crate::behavior::item_utils::get_player_pov_hit_result;
+use crate::behavior::{
+    BLOCK_BEHAVIORS, BlockCollisionContext, BlockStateBehaviorExt as _, ITEM_BEHAVIORS,
+    InteractionResult, InventoryAccess, ItemBehavior, UseItemContext, UseOnContext,
+};
+use crate::entity::{
+    AgeableMob, EntitySpawnPlacement, EntitySpawnReason, EntitySpawnRequest, Mob, SharedEntity,
+    add_spawned_entity, apply_implicit_item_stack_components, create_entity_instance, spawn_entity,
+};
+use crate::player::Player;
+use crate::world::ClipFluid;
+use crate::world::World;
+use crate::world::game_event::GameEventContext;
+
+/// Behavior for every data-driven `SpawnEggItem` registry entry.
+#[item_behavior(class = "SpawnEggItem")]
+pub struct SpawnEggItem;
+
+impl SpawnEggItem {
+    fn entity_type(stack: &ItemStack) -> Option<EntityTypeRef> {
+        stack.get(ENTITY_DATA).map(EntityData::entity_type)
+    }
+
+    fn spawn_mob(
+        world: &Arc<World>,
+        player: &Player,
+        inventory: &InventoryAccess,
+        stack: &ItemStack,
+        spawn_pos: BlockPos,
+        try_move_down: bool,
+        moved_up: bool,
+    ) -> InteractionResult {
+        let Some(entity_type) = Self::entity_type(stack) else {
+            return InteractionResult::Fail;
+        };
+
+        let request = EntitySpawnRequest {
+            entity_type,
+            placement: EntitySpawnPlacement::Block {
+                pos: spawn_pos,
+                try_move_down,
+                moved_up,
+            },
+            reason: EntitySpawnReason::SpawnItemUse,
+            finalize_spawn: true,
+            play_ambient_sound: true,
+            item_stack: Some(stack),
+            user_is_operator: player.is_operator(),
+        };
+        if spawn_entity(world, request).is_err() {
+            return InteractionResult::Fail;
+        }
+
+        inventory.with_item(|item| item.consume_one(player.has_infinite_materials()));
+        world.game_event(
+            &vanilla_game_events::ENTITY_PLACE,
+            spawn_pos,
+            &GameEventContext::new(Some(player), None),
+        );
+        InteractionResult::Success
+    }
+
+    /// Runs the interaction before normal mob handling.
+    pub(crate) fn interact_with_mob<M: Mob + ?Sized>(
+        stack: &mut ItemStack,
+        player: &Player,
+        parent: &M,
+    ) -> InteractionResult {
+        if ITEM_BEHAVIORS
+            .get_behavior(stack.item())
+            .as_spawn_egg()
+            .is_none()
+        {
+            return InteractionResult::Pass;
+        }
+        if Self::spawn_offspring(stack, parent).is_none() {
+            return InteractionResult::Pass;
+        }
+        stack.consume_one(player.has_infinite_materials());
+        InteractionResult::SuccessServer
+    }
+
+    fn spawn_offspring<M: Mob + ?Sized>(stack: &ItemStack, parent: &M) -> Option<SharedEntity> {
+        let entity_type = Self::entity_type(stack)?;
+        if entity_type != parent.entity_type() {
+            return None;
+        }
+
+        let world = parent.level()?;
+        let offspring = if let Some(animal) = parent.as_animal() {
+            animal.get_breed_offspring(&world, animal)?
+        } else {
+            match create_entity_instance(&world, entity_type, parent.position()) {
+                Ok(offspring) => offspring,
+                Err(error) => {
+                    log::warn!(
+                        "Failed to create spawn-egg offspring {} at {:?}: {error:?}",
+                        entity_type.key,
+                        parent.position()
+                    );
+                    return None;
+                }
+            }
+        };
+
+        let ageable = offspring.as_ageable_mob()?;
+        ageable.set_baby(true);
+        if !AgeableMob::is_baby(ageable) {
+            return None;
+        }
+
+        offspring.base().set_position_local(parent.position());
+        offspring.set_rotation((0.0, 0.0));
+        offspring.set_old_position_to_current();
+        offspring.base().set_old_rotation_to_current();
+        apply_implicit_item_stack_components(&offspring, stack);
+        add_spawned_entity(&world, offspring.clone()).ok()?;
+        Some(offspring)
+    }
+}
+
+impl ItemBehavior for SpawnEggItem {
+    fn as_spawn_egg(&self) -> Option<&SpawnEggItem> {
+        Some(self)
+    }
+
+    fn use_on(&self, context: &mut UseOnContext) -> InteractionResult {
+        let stack = context.inv.with_item(|item| item.clone());
+        if Self::entity_type(&stack).is_none() {
+            return InteractionResult::Fail;
+        }
+
+        let clicked_pos = context.hit_result.block_pos;
+        let clicked_state = context.world.get_block_state(clicked_pos);
+        if clicked_state.get_block() == &vanilla_blocks::SPAWNER {
+            // TODO: Use spawn eggs on a spawner block and also check if the condition is correct
+            // Spawner block-entity mutation is a separate foundation; do not
+            // incorrectly create a mob beside a spawner in its place.
+            return InteractionResult::Fail;
+        }
+
+        let clicked_face = context.hit_result.direction;
+        let shape = BLOCK_BEHAVIORS
+            .get_behavior(clicked_state.get_block())
+            .get_collision_shape(
+                clicked_state,
+                context.world.as_ref(),
+                clicked_pos,
+                BlockCollisionContext::empty(),
+            );
+        let spawn_pos = if shape.is_empty() {
+            clicked_pos
+        } else {
+            clicked_face.relative(clicked_pos)
+        };
+
+        let result = Self::spawn_mob(
+            context.world,
+            context.player,
+            &context.inv,
+            &stack,
+            spawn_pos,
+            true,
+            spawn_pos != clicked_pos && clicked_face == steel_utils::Direction::Up,
+        );
+        if result == InteractionResult::Success {
+            context
+                .player
+                .award_stat(&vanilla_stat_types::ITEM_USED, stack.item());
+        }
+        result
+    }
+
+    fn use_item(&self, context: &mut UseItemContext) -> InteractionResult {
+        let hit_result =
+            get_player_pov_hit_result(context.world, context.player, ClipFluid::SourceOnly);
+        if hit_result.miss {
+            return InteractionResult::Pass;
+        }
+
+        let stack = context.inv.with_item(|item| item.clone());
+        if Self::entity_type(&stack).is_none() {
+            return InteractionResult::Fail;
+        }
+
+        let pos = hit_result.block_pos;
+        let state = context.world.get_block_state(pos);
+        if !state.is_liquid_block() {
+            return InteractionResult::Pass;
+        }
+        if !context.world.may_interact(context.player, pos)
+            || !context
+                .player
+                .may_use_item_at(pos, hit_result.direction, &stack)
+        {
+            return InteractionResult::Fail;
+        }
+
+        let result = Self::spawn_mob(
+            context.world,
+            context.player,
+            &context.inv,
+            &stack,
+            pos,
+            false,
+            false,
+        );
+        if result == InteractionResult::Success {
+            context
+                .player
+                .award_stat(&vanilla_stat_types::ITEM_USED, stack.item());
+        }
+        result
+    }
+}

steel-core/src/behavior/mod.rs

@@ -148,6 +148,9 @@ pub trait BlockStateBehaviorExt {
     /// Returns whether this block state extends `BedBlock`
     fn is_bed(&self) -> bool;
 
+    /// Returns whether this block state extends `LiquidBlock`.
+    fn is_liquid_block(&self) -> bool;
+
     /// Returns whether this block state can be occupied by a forced respawn position
     fn is_possible_to_respawn_in_this(&self) -> bool;
 }
@@ -182,6 +185,11 @@ impl BlockStateBehaviorExt for BlockStateId {
         BLOCK_BEHAVIORS.get_behavior(block).is_bed()
     }
 
+    fn is_liquid_block(&self) -> bool {
+        let block = self.get_block();
+        BLOCK_BEHAVIORS.get_behavior(block).is_liquid_block()
+    }
+
     fn is_possible_to_respawn_in_this(&self) -> bool {
         let block = self.get_block();
         let behavior = BLOCK_BEHAVIORS.get_behavior(block);

steel-core/src/chunk_saver/storage/entities.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::entity::clamp_loaded_entity_position;
 
 impl ChunkStorage {
     pub(super) fn entities_to_persistent(entities: &[SharedEntity]) -> Vec<PersistentEntity> {
@@ -116,23 +117,6 @@ impl ChunkStorage {
         }
     }
 
-    pub(super) fn clamp_loaded_entity_position(pos: DVec3) -> DVec3 {
-        DVec3::new(
-            pos.x.clamp(
-                -ENTITY_LOAD_MAX_HORIZONTAL_POSITION,
-                ENTITY_LOAD_MAX_HORIZONTAL_POSITION,
-            ),
-            pos.y.clamp(
-                -ENTITY_LOAD_MAX_VERTICAL_POSITION,
-                ENTITY_LOAD_MAX_VERTICAL_POSITION,
-            ),
-            pos.z.clamp(
-                -ENTITY_LOAD_MAX_HORIZONTAL_POSITION,
-                ENTITY_LOAD_MAX_HORIZONTAL_POSITION,
-            ),
-        )
-    }
-
     pub(super) fn entity_to_persistent(
         entity: &SharedEntity,
         visited: &mut FxHashSet<i32>,
@@ -369,7 +353,7 @@ impl ChunkStorage {
             return None;
         }
 
-        let pos = Self::clamp_loaded_entity_position(stored_pos);
+        let pos = clamp_loaded_entity_position(stored_pos);
 
         // Validate position is within expected chunk (sanity check)
         let expected_chunk = ChunkPos::from_entity_pos(pos);

steel-core/src/chunk_saver/storage/mod.rs

@@ -70,9 +70,6 @@ mod ticks;
 #[cfg(test)]
 mod tests;
 
-const ENTITY_LOAD_MAX_HORIZONTAL_POSITION: f64 = 3.000_051_2E7;
-const ENTITY_LOAD_MAX_VERTICAL_POSITION: f64 = 2.0E7;
-
 /// Converts `Option<Direction>` to the vanilla 2D data value encoding for persistence.
 /// -1 = none, 0 = south, 1 = west, 2 = north, 3 = east.
 const fn direction_to_2d(dir: Option<Direction>) -> i8 {

steel-core/src/chunk_saver/storage/tests/entities.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::entity::{ENTITY_LOAD_MAX_HORIZONTAL_POSITION, ENTITY_LOAD_MAX_VERTICAL_POSITION};
 use steel_registry::RegistryEntry as _;
 
 fn test_persistent_end_crystal(pos: DVec3) -> PersistentEntity {
@@ -50,6 +51,8 @@ fn persistent_entity_load_clamps_position_like_vanilla() {
             -ENTITY_LOAD_MAX_HORIZONTAL_POSITION,
         )
     );
+    assert_eq!(entity.base().old_position(), entity.position());
+    assert_eq!(entity.base().old_rotation(), entity.rotation());
 }
 
 #[test]