feat: Add Vanilla-compatible destructive explosions and TNT

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

@@ -112,6 +112,7 @@ pub struct BlockLootContext<'a> {
     entity: Option<&'a dyn Entity>,
     block_entity: Option<&'a dyn BlockEntity>,
     tool: Option<&'a ItemStack>,
+    explosion_radius: Option<f32>,
     luck: f32,
 }
 
@@ -125,6 +126,7 @@ impl<'a> BlockLootContext<'a> {
             entity: None,
             block_entity: None,
             tool: None,
+            explosion_radius: None,
             luck: 0.0,
         }
     }
@@ -150,6 +152,13 @@ impl<'a> BlockLootContext<'a> {
         self
     }
 
+    /// Adds the explosion radius used by explosion-decay loot functions.
+    #[must_use]
+    pub const fn with_explosion(mut self, radius: f32) -> Self {
+        self.explosion_radius = Some(radius);
+        self
+    }
+
     /// Adds the luck used to evaluate the loot table.
     #[must_use]
     pub const fn with_luck(mut self, luck: f32) -> Self {
@@ -187,6 +196,10 @@ impl<'a> BlockLootContext<'a> {
         self.tool
     }
 
+    pub(crate) const fn explosion_radius(&self) -> Option<f32> {
+        self.explosion_radius
+    }
+
     pub(crate) const fn luck(&self) -> f32 {
         self.luck
     }

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

@@ -45,8 +45,8 @@ use crate::physics::collide;
 use crate::player::Player;
 use crate::world::game_event::SharedGameEventListener;
 use crate::world::{
-    ClipHitResult, ConditionalBlockSetResult, LevelAccessor, LevelReader, ScheduledTickAccess,
-    SignalQueryContext, World,
+    BlockInteraction, ClipHitResult, ConditionalBlockSetResult, Explosion, LevelAccessor,
+    LevelReader, ScheduledTickAccess, SignalQueryContext, World,
 };
 use steel_registry::vanilla_fluids;
 
@@ -400,6 +400,79 @@ pub trait BlockBehavior: Send + Sync {
     ) {
     }
 
+    /// Applies Vanilla's default block response to an explosion.
+    fn on_explosion_hit(
+        &self,
+        state: BlockStateId,
+        world: &Arc<World>,
+        pos: BlockPos,
+        explosion: &dyn Explosion,
+        on_hit: &mut dyn FnMut(ItemStack, BlockPos),
+    ) {
+        self.default_on_explosion_hit(state, world, pos, explosion, on_hit);
+    }
+
+    /// Applies the default response from an overriding explosion hook.
+    fn default_on_explosion_hit(
+        &self,
+        state: BlockStateId,
+        world: &Arc<World>,
+        pos: BlockPos,
+        explosion: &dyn Explosion,
+        on_hit: &mut dyn FnMut(ItemStack, BlockPos),
+    ) {
+        if state.is_air() {
+            return;
+        }
+
+        if self.drop_from_explosion(explosion) {
+            let empty_tool = ItemStack::empty();
+            let block_entity = if state.has_block_entity() {
+                world.get_block_entity(pos)
+            } else {
+                None
+            };
+            let context = BlockLootContext::new(world, pos)
+                .with_block_entity(block_entity.as_deref())
+                .with_entity(explosion.direct_source_entity())
+                .with_tool(&empty_tool);
+            let context = if explosion.block_interaction() == BlockInteraction::DestroyWithDecay {
+                context.with_explosion(explosion.radius())
+            } else {
+                context
+            };
+            let drop_experience = explosion
+                .indirect_source_entity()
+                .is_some_and(|entity| entity.as_player().is_some());
+            self.spawn_after_break(state, world, pos, &empty_tool, drop_experience);
+            for stack in World::block_drops(state, &context) {
+                on_hit(stack, pos);
+            }
+        }
+
+        world.set_block(
+            pos,
+            vanilla_blocks::AIR.default_state(),
+            UpdateFlags::UPDATE_ALL,
+        );
+        self.was_exploded(state, world, pos, explosion);
+    }
+
+    /// Called after this block is removed by an explosion.
+    fn was_exploded(
+        &self,
+        _state: BlockStateId,
+        _world: &Arc<World>,
+        _pos: BlockPos,
+        _explosion: &dyn Explosion,
+    ) {
+    }
+
+    /// Returns whether this block contributes normal explosion loot.
+    fn drop_from_explosion(&self, _explosion: &dyn Explosion) -> bool {
+        true
+    }
+
     /// Called after this block is removed from the world, to affect neighbors.
     ///
     /// This is used for things like rails notifying neighbors when removed.

steel-core/src/behavior/blocks/redstone/java_hash.rs

@@ -14,11 +14,6 @@ pub(super) fn sort_small_map_positions(positions: &mut [BlockPos]) {
 
 #[must_use]
 pub(super) const fn bucket(pos: BlockPos) -> u32 {
-    let hash = pos
-        .z()
-        .wrapping_mul(31)
-        .wrapping_add(pos.y())
-        .wrapping_mul(31)
-        .wrapping_add(pos.x()) as u32;
+    let hash = pos.java_hash_code() as u32;
     (hash ^ (hash >> 16)) & 15
 }

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

@@ -16,6 +16,7 @@ mod redstone_lamp_block;
 mod redstone_ore_block;
 mod redstone_torch_block;
 mod target_block;
+mod tnt_block;
 mod tripwire;
 mod weathering_lightning_rod_block;
 mod wire;
@@ -43,6 +44,7 @@ pub use redstone_lamp_block::*;
 pub use redstone_ore_block::*;
 pub use redstone_torch_block::*;
 pub use target_block::*;
+pub use tnt_block::*;
 pub use tripwire::*;
 pub use weathering_lightning_rod_block::*;
 pub use wire::*;