Fix https://github.com/Pumpkin-MC/Pumpkin/issues/1075

pumpkin-macros/src/lib.rs

@@ -181,7 +181,7 @@ pub fn pumpkin_block(input: TokenStream, item: TokenStream) -> TokenStream {
 
     let code = quote! {
         #item
-        impl #impl_generics crate::block::pumpkin_block::BlockMetadata for #name #ty_generics {
+        impl #impl_generics crate::block::BlockMetadata for #name #ty_generics {
             fn namespace(&self) -> &'static str {
                 #namespace
             }
@@ -210,7 +210,7 @@ pub fn pumpkin_block_from_tag(input: TokenStream, item: TokenStream) -> TokenStr
 
     let code = quote! {
         #item
-        impl #impl_generics crate::block::pumpkin_block::BlockMetadata for #name #ty_generics {
+        impl #impl_generics crate::block::BlockMetadata for #name #ty_generics {
             fn namespace(&self) -> &'static str {
                 #namespace
             }

pumpkin/src/block/blocks/abstruct_wall_mounting.rs

@@ -6,7 +6,7 @@ use pumpkin_data::{
 use pumpkin_util::math::position::BlockPos;
 use pumpkin_world::{BlockStateId, world::BlockAccessor};
 
-use crate::{block::pumpkin_block::GetStateForNeighborUpdateArgs, entity::player::Player};
+use crate::{block::GetStateForNeighborUpdateArgs, entity::player::Player};
 
 #[async_trait]
 pub trait WallMountedBlock {

pumpkin/src/block/blocks/anvil.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::{OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, OnPlaceArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, WallTorchLikeProperties};
 use pumpkin_data::tag::{RegistryKey, get_tag_values};
@@ -9,7 +9,7 @@ use pumpkin_world::BlockStateId;
 pub struct AnvilBlock;
 
 #[async_trait]
-impl PumpkinBlock for AnvilBlock {
+impl BlockBehaviour for AnvilBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let dir = args
             .player

pumpkin/src/block/blocks/bamboo.rs

@@ -3,13 +3,13 @@ use pumpkin_data::tag;
 use pumpkin_data::tag::Taggable;
 use pumpkin_macros::pumpkin_block;
 
-use crate::block::pumpkin_block::{CanPlaceAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, CanPlaceAtArgs};
 
 #[pumpkin_block("minecraft:bamboo")]
 pub struct BambooBlock;
 
 #[async_trait]
-impl PumpkinBlock for BambooBlock {
+impl BlockBehaviour for BambooBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         let block_below = args.block_accessor.get_block(&args.position.down()).await;
         block_below.is_tagged_with_by_tag(&tag::Block::MINECRAFT_BAMBOO_PLANTABLE_ON)

pumpkin/src/block/blocks/banners.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::{OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, OnPlaceArgs};
 use crate::entity::EntityBase;
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, WhiteBannerLikeProperties};
@@ -10,7 +10,7 @@ use pumpkin_world::BlockStateId;
 pub struct BannerBlock;
 
 #[async_trait]
-impl PumpkinBlock for BannerBlock {
+impl BlockBehaviour for BannerBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = WhiteBannerLikeProperties::default(args.block);
         props.rotation = args.player.get_entity().get_flipped_rotation_16();

pumpkin/src/block/blocks/barrel.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::{OnPlaceArgs, PlacedArgs};
+use crate::block::{OnPlaceArgs, PlacedArgs};
 use crate::block::{
-    pumpkin_block::{NormalUseArgs, PumpkinBlock},
     registry::BlockActionResult,
+    {BlockBehaviour, NormalUseArgs},
 };
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BarrelLikeProperties, BlockProperties};
@@ -43,7 +43,7 @@ impl ScreenHandlerFactory for BarrelScreenFactory {
 pub struct BarrelBlock;
 
 #[async_trait]
-impl PumpkinBlock for BarrelBlock {
+impl BlockBehaviour for BarrelBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         if let Some(block_entity) = args.world.get_block_entity(args.position).await {
             if let Some(inventory) = block_entity.get_inventory() {

pumpkin/src/block/blocks/bed.rs

@@ -15,10 +15,10 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::block::entities::bed::BedBlockEntity;
 use pumpkin_world::world::BlockFlags;
 
-use crate::block::pumpkin_block::{
-    BrokenArgs, CanPlaceAtArgs, NormalUseArgs, OnPlaceArgs, PlacedArgs, PumpkinBlock,
-};
 use crate::block::registry::BlockActionResult;
+use crate::block::{
+    BlockBehaviour, BrokenArgs, CanPlaceAtArgs, NormalUseArgs, OnPlaceArgs, PlacedArgs,
+};
 use crate::entity::{Entity, EntityBase};
 use crate::world::World;
 
@@ -66,7 +66,7 @@ const NO_SLEEP_IDS: &[u16] = &[
 pub struct BedBlock;
 
 #[async_trait]
-impl PumpkinBlock for BedBlock {
+impl BlockBehaviour for BedBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         if let Some(player) = args.player {
             let facing = player.living_entity.entity.get_horizontal_facing();

pumpkin/src/block/blocks/blast_furnace.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::{OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, OnPlaceArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, FurnaceLikeProperties};
 use pumpkin_macros::pumpkin_block;
@@ -8,7 +8,7 @@ use pumpkin_world::BlockStateId;
 pub struct BlastFurnaceBlock;
 
 #[async_trait]
-impl PumpkinBlock for BlastFurnaceBlock {
+impl BlockBehaviour for BlastFurnaceBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = FurnaceLikeProperties::default(args.block);
         props.facing = args

pumpkin/src/block/blocks/cactus.rs

@@ -11,16 +11,16 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::tick::TickPriority;
 use pumpkin_world::world::{BlockAccessor, BlockFlags};
 
-use crate::block::pumpkin_block::{
+use crate::block::{
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnEntityCollisionArgs, OnScheduledTickArgs,
+    BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnEntityCollisionArgs,
-    PumpkinBlock, RandomTickArgs,
+    OnScheduledTickArgs, RandomTickArgs,
 };
 
 #[pumpkin_block("minecraft:cactus")]
 pub struct CactusBlock;
 
 #[async_trait]
-impl PumpkinBlock for CactusBlock {
+impl BlockBehaviour for CactusBlock {
     async fn on_scheduled_tick(&self, args: OnScheduledTickArgs<'_>) {
         if !can_place_at(args.world.as_ref(), args.position).await {
             args.world

pumpkin/src/block/blocks/cake.rs

@@ -3,8 +3,8 @@ use std::sync::Arc;
 use crate::{
     block::{
         blocks::candle_cakes::cake_from_candle,
-        pumpkin_block::{NormalUseArgs, PumpkinBlock, UseWithItemArgs},
         registry::BlockActionResult,
+        {BlockBehaviour, NormalUseArgs, UseWithItemArgs},
     },
     entity::player::Player,
     world::World,
@@ -79,7 +79,7 @@ impl CakeBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for CakeBlock {
+impl BlockBehaviour for CakeBlock {
     async fn use_with_item(&self, args: UseWithItemArgs<'_>) -> BlockActionResult {
         let state_id = args.world.get_block_state_id(args.position).await;
         let properties = CakeLikeProperties::from_state_id(state_id, args.block);

pumpkin/src/block/blocks/campfire.rs

@@ -10,9 +10,9 @@ use pumpkin_world::{BlockStateId, tick::TickPriority};
 use crate::{
     block::{
         BlockIsReplacing,
-        pumpkin_block::{
+        {
-            BlockMetadata, GetStateForNeighborUpdateArgs, OnEntityCollisionArgs, OnPlaceArgs,
+            BlockBehaviour, BlockMetadata, GetStateForNeighborUpdateArgs, OnEntityCollisionArgs,
-            PumpkinBlock,
+            OnPlaceArgs,
         },
     },
     entity::EntityBase,
@@ -31,7 +31,7 @@ impl BlockMetadata for CampfireBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for CampfireBlock {
+impl BlockBehaviour for CampfireBlock {
     // TODO: cooking food on campfire (CampfireBlockEntity)
     async fn on_entity_collision(&self, args: OnEntityCollisionArgs<'_>) {
         if CampfireLikeProperties::from_state_id(args.state.id, args.block).lit

pumpkin/src/block/blocks/candle_cakes.rs

@@ -13,8 +13,8 @@ use pumpkin_world::{item::ItemStack, world::BlockFlags};
 use crate::{
     block::{
         blocks::cake::CakeBlock,
-        pumpkin_block::{NormalUseArgs, PumpkinBlock, UseWithItemArgs},
         registry::BlockActionResult,
+        {BlockBehaviour, NormalUseArgs, UseWithItemArgs},
     },
     entity::player::Player,
     world::World,
@@ -101,7 +101,7 @@ impl CandleCakeBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for CandleCakeBlock {
+impl BlockBehaviour for CandleCakeBlock {
     async fn use_with_item(&self, args: UseWithItemArgs<'_>) -> BlockActionResult {
         match args.item_stack.lock().await.item.id {
             id if id == Item::FIRE_CHARGE.id || id == Item::FLINT_AND_STEEL.id => {

pumpkin/src/block/blocks/candles.rs

@@ -12,11 +12,11 @@ use pumpkin_world::{BlockStateId, world::BlockFlags};
 use crate::{
     block::{
         BlockIsReplacing,
-        pumpkin_block::{
+        registry::BlockActionResult,
-            CanPlaceAtArgs, CanUpdateAtArgs, NormalUseArgs, OnPlaceArgs, PumpkinBlock,
+        {
+            BlockBehaviour, CanPlaceAtArgs, CanUpdateAtArgs, NormalUseArgs, OnPlaceArgs,
             UseWithItemArgs,
         },
-        registry::BlockActionResult,
     },
     entity::EntityBase,
 };
@@ -25,7 +25,7 @@ use crate::{
 pub struct CandleBlock;
 
 #[async_trait]
-impl PumpkinBlock for CandleBlock {
+impl BlockBehaviour for CandleBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         if args.player.get_entity().pose.load() != EntityPose::Crouching {
             if let BlockIsReplacing::Itself(state_id) = args.replacing {

pumpkin/src/block/blocks/carpet.rs

@@ -1,5 +1,5 @@
-use crate::block::pumpkin_block::{
+use crate::block::{
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnScheduledTickArgs, PumpkinBlock,
+    BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnScheduledTickArgs,
 };
 use async_trait::async_trait;
 use pumpkin_data::tag::{RegistryKey, get_tag_values};
@@ -13,7 +13,7 @@ use pumpkin_world::world::{BlockAccessor, BlockFlags};
 pub struct CarpetBlock;
 
 #[async_trait]
-impl PumpkinBlock for CarpetBlock {
+impl BlockBehaviour for CarpetBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         can_place_at(args.block_accessor, args.position).await
     }
@@ -43,7 +43,7 @@ impl PumpkinBlock for CarpetBlock {
 pub struct MossCarpetBlock;
 
 #[async_trait]
-impl PumpkinBlock for MossCarpetBlock {
+impl BlockBehaviour for MossCarpetBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         can_place_at(args.block_accessor, args.position).await
     }
@@ -73,7 +73,7 @@ impl PumpkinBlock for MossCarpetBlock {
 pub struct PaleMossCarpetBlock;
 
 #[async_trait]
-impl PumpkinBlock for PaleMossCarpetBlock {
+impl BlockBehaviour for PaleMossCarpetBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         can_place_at(args.block_accessor, args.position).await
     }

pumpkin/src/block/blocks/chests.rs

@@ -12,13 +12,11 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::block::entities::chest::ChestBlockEntity;
 use pumpkin_world::world::BlockFlags;
 
-use crate::block::pumpkin_block::{
+use crate::block::{BlockMetadata, BrokenArgs, OnPlaceArgs, PlacedArgs, UseWithItemArgs};
-    BlockMetadata, BrokenArgs, OnPlaceArgs, PlacedArgs, UseWithItemArgs,
-};
 use crate::entity::EntityBase;
 use crate::world::World;
 use crate::{
-    block::{pumpkin_block::PumpkinBlock, registry::BlockActionResult},
+    block::{BlockBehaviour, registry::BlockActionResult},
     entity::player::Player,
 };
 
@@ -35,7 +33,7 @@ impl BlockMetadata for ChestBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for ChestBlock {
+impl BlockBehaviour for ChestBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut chest_props = ChestLikeProperties::default(args.block);
 

pumpkin/src/block/blocks/chiseled_bookshelf.rs

@@ -2,11 +2,11 @@ use std::sync::{Arc, atomic::Ordering};
 
 use crate::{
     block::{
-        pumpkin_block::{
-            BlockHitResult, GetComparatorOutputArgs, NormalUseArgs, OnPlaceArgs, PlacedArgs,
-            PumpkinBlock, UseWithItemArgs,
-        },
         registry::BlockActionResult,
+        {
+            BlockBehaviour, BlockHitResult, GetComparatorOutputArgs, NormalUseArgs, OnPlaceArgs,
+            PlacedArgs, UseWithItemArgs,
+        },
     },
     entity::{EntityBase, player::Player},
     world::World,
@@ -32,7 +32,7 @@ use tokio::sync::Mutex;
 pub struct ChiseledBookshelfBlock;
 
 #[async_trait]
-impl PumpkinBlock for ChiseledBookshelfBlock {
+impl BlockBehaviour for ChiseledBookshelfBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut properties = ChiseledBookshelfLikeProperties::default(args.block);
 

pumpkin/src/block/blocks/command.rs

@@ -6,8 +6,8 @@ use pumpkin_util::{GameMode, math::position::BlockPos};
 use pumpkin_world::{block::entities::command_block::CommandBlockEntity, tick::TickPriority};
 
 use crate::{
-    block::pumpkin_block::{
+    block::{
-        BlockMetadata, CanPlaceAtArgs, OnNeighborUpdateArgs, OnScheduledTickArgs, PumpkinBlock,
+        BlockBehaviour, BlockMetadata, CanPlaceAtArgs, OnNeighborUpdateArgs, OnScheduledTickArgs,
     },
     world::World,
 };
@@ -51,7 +51,7 @@ impl BlockMetadata for CommandBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for CommandBlock {
+impl BlockBehaviour for CommandBlock {
     async fn on_neighbor_update(&self, args: OnNeighborUpdateArgs<'_>) {
         if let Some(block_entity) = args.world.get_block_entity(args.position).await {
             if block_entity.resource_location() != CommandBlockEntity::ID {

pumpkin/src/block/blocks/composter.rs

@@ -2,11 +2,11 @@ use std::sync::Arc;
 
 use crate::{
     block::{
-        pumpkin_block::{
+        registry::BlockActionResult,
-            GetComparatorOutputArgs, NormalUseArgs, OnScheduledTickArgs, PumpkinBlock,
+        {
+            BlockBehaviour, GetComparatorOutputArgs, NormalUseArgs, OnScheduledTickArgs,
             UseWithItemArgs,
         },
-        registry::BlockActionResult,
     },
     entity::{Entity, item::ItemEntity},
     world::World,
@@ -30,7 +30,7 @@ use uuid::Uuid;
 pub struct ComposterBlock;
 
 #[async_trait]
-impl PumpkinBlock for ComposterBlock {
+impl BlockBehaviour for ComposterBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         let state_id = args.world.get_block_state_id(args.position).await;
         let props = ComposterLikeProperties::from_state_id(state_id, args.block);

pumpkin/src/block/blocks/crafting_table.rs

@@ -1,5 +1,5 @@
-use crate::block::pumpkin_block::{NormalUseArgs, PumpkinBlock};
 use crate::block::registry::BlockActionResult;
+use crate::block::{BlockBehaviour, NormalUseArgs};
 use async_trait::async_trait;
 use pumpkin_inventory::crafting::crafting_screen_handler::CraftingTableScreenHandler;
 use pumpkin_inventory::player::player_inventory::PlayerInventory;
@@ -13,7 +13,7 @@ use tokio::sync::Mutex;
 pub struct CraftingTableBlock;
 
 #[async_trait]
-impl PumpkinBlock for CraftingTableBlock {
+impl BlockBehaviour for CraftingTableBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         args.player
             .open_handled_screen(&CraftingTableScreenFactory)

pumpkin/src/block/blocks/dirt_path.rs

@@ -1,8 +1,8 @@
-use crate::block::pumpkin_block::CanPlaceAtArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
+use crate::block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnScheduledTickArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::OnScheduledTickArgs;
 use async_trait::async_trait;
 use pumpkin_data::Block;
 use pumpkin_data::BlockDirection;
@@ -17,7 +17,7 @@ use pumpkin_world::world::BlockFlags;
 pub struct DirtPathBlock;
 
 #[async_trait]
-impl PumpkinBlock for DirtPathBlock {
+impl BlockBehaviour for DirtPathBlock {
     async fn on_scheduled_tick(&self, args: OnScheduledTickArgs<'_>) {
         // TODO: push up entities
         args.world

pumpkin/src/block/blocks/doors.rs

@@ -19,14 +19,14 @@ use pumpkin_world::world::BlockAccessor;
 use pumpkin_world::world::BlockFlags;
 use std::sync::Arc;
 
+use crate::block::BlockBehaviour;
+use crate::block::CanPlaceAtArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
+use crate::block::NormalUseArgs;
+use crate::block::OnNeighborUpdateArgs;
+use crate::block::OnPlaceArgs;
+use crate::block::PlacedArgs;
 use crate::block::blocks::redstone::block_receives_redstone_power;
-use crate::block::pumpkin_block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::NormalUseArgs;
-use crate::block::pumpkin_block::OnNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
-use crate::block::pumpkin_block::PlacedArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
 use crate::block::registry::BlockActionResult;
 use crate::entity::player::Player;
 use pumpkin_protocol::java::server::play::SUseItemOn;
@@ -164,7 +164,7 @@ async fn get_hinge(
 pub struct DoorBlock;
 
 #[async_trait]
-impl PumpkinBlock for DoorBlock {
+impl BlockBehaviour for DoorBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let powered = block_receives_redstone_power(args.world, args.position).await
             || block_receives_redstone_power(args.world, &args.position.up()).await;

pumpkin/src/block/blocks/end_portal.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::OnEntityCollisionArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::PlacedArgs;
+use crate::block::OnEntityCollisionArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::PlacedArgs;
 use async_trait::async_trait;
 use pumpkin_macros::pumpkin_block;
 use pumpkin_registry::VanillaDimensionType;
@@ -12,7 +12,7 @@ use pumpkin_world::block::entities::end_portal::EndPortalBlockEntity;
 pub struct EndPortalBlock;
 
 #[async_trait]
-impl PumpkinBlock for EndPortalBlock {
+impl BlockBehaviour for EndPortalBlock {
     async fn on_entity_collision(&self, args: OnEntityCollisionArgs<'_>) {
         let world = if args.world.dimension_type == VanillaDimensionType::TheEnd {
             args.server

pumpkin/src/block/blocks/end_portal_frame.rs

@@ -4,7 +4,7 @@ use pumpkin_macros::pumpkin_block;
 use pumpkin_world::BlockStateId;
 
 use crate::{
-    block::pumpkin_block::{OnPlaceArgs, PumpkinBlock},
+    block::{BlockBehaviour, OnPlaceArgs},
     entity::EntityBase,
 };
 
@@ -14,7 +14,7 @@ type EndPortalFrameProperties = pumpkin_data::block_properties::EndPortalFrameLi
 pub struct EndPortalFrameBlock;
 
 #[async_trait]
-impl PumpkinBlock for EndPortalFrameBlock {
+impl BlockBehaviour for EndPortalFrameBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut end_portal_frame_props = EndPortalFrameProperties::default(args.block);
         end_portal_frame_props.facing = args.player.get_entity().get_horizontal_facing().opposite();

pumpkin/src/block/blocks/ender_chest.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::{OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, OnPlaceArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, LadderLikeProperties};
 use pumpkin_macros::pumpkin_block;
@@ -8,7 +8,7 @@ use pumpkin_world::BlockStateId;
 pub struct EnderChestBlock;
 
 #[async_trait]
-impl PumpkinBlock for EnderChestBlock {
+impl BlockBehaviour for EnderChestBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = LadderLikeProperties::default(args.block);
         props.facing = args

pumpkin/src/block/blocks/farmland.rs

@@ -1,8 +1,8 @@
-use crate::block::pumpkin_block::CanPlaceAtArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
+use crate::block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnScheduledTickArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::OnScheduledTickArgs;
 use async_trait::async_trait;
 use pumpkin_data::Block;
 use pumpkin_data::BlockDirection;
@@ -17,7 +17,7 @@ use pumpkin_world::world::BlockFlags;
 pub struct FarmLandBlock;
 
 #[async_trait]
-impl PumpkinBlock for FarmLandBlock {
+impl BlockBehaviour for FarmLandBlock {
     async fn on_scheduled_tick(&self, args: OnScheduledTickArgs<'_>) {
         // TODO: push up entities
         args.world

pumpkin/src/block/blocks/fence_gates.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::NormalUseArgs;
+use crate::block::NormalUseArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnPlaceArgs;
 use crate::entity::player::Player;
 use async_trait::async_trait;
 use pumpkin_data::block_properties::BlockProperties;
@@ -15,7 +15,7 @@ use pumpkin_util::math::position::BlockPos;
 use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockFlags;
 
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::BlockBehaviour;
 use crate::block::registry::BlockActionResult;
 use crate::world::World;
 
@@ -58,7 +58,7 @@ pub async fn toggle_fence_gate(
 pub struct FenceGateBlock;
 
 #[async_trait]
-impl PumpkinBlock for FenceGateBlock {
+impl BlockBehaviour for FenceGateBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut fence_gate_props = FenceGateProperties::default(args.block);
         fence_gate_props.facing = args.player.living_entity.entity.get_horizontal_facing();

pumpkin/src/block/blocks/fences.rs

@@ -1,5 +1,5 @@
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnPlaceArgs;
 use async_trait::async_trait;
 use pumpkin_data::BlockDirection;
 use pumpkin_data::BlockState;
@@ -14,7 +14,7 @@ use pumpkin_world::BlockStateId;
 type FenceGateProperties = pumpkin_data::block_properties::OakFenceGateLikeProperties;
 type FenceProperties = pumpkin_data::block_properties::OakFenceLikeProperties;
 
-use crate::block::pumpkin_block::{BlockMetadata, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata};
 use crate::world::World;
 
 pub struct FenceBlock;
@@ -29,7 +29,7 @@ impl BlockMetadata for FenceBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for FenceBlock {
+impl BlockBehaviour for FenceBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut fence_props = FenceProperties::default(args.block);
         fence_props.waterlogged = args.replacing.water_source();

pumpkin/src/block/blocks/fire/fire.rs

@@ -16,9 +16,9 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::tick::TickPriority;
 
 use crate::block::blocks::tnt::TNTBlock;
-use crate::block::pumpkin_block::{
+use crate::block::{
-    BrokenArgs, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnEntityCollisionArgs,
+    BlockBehaviour, BrokenArgs, CanPlaceAtArgs, GetStateForNeighborUpdateArgs,
-    OnScheduledTickArgs, PlacedArgs, PumpkinBlock,
+    OnEntityCollisionArgs, OnScheduledTickArgs, PlacedArgs,
 };
 use crate::world::World;
 use crate::world::portal::nether::NetherPortal;
@@ -166,7 +166,7 @@ impl FireBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for FireBlock {
+impl BlockBehaviour for FireBlock {
     async fn placed(&self, args: PlacedArgs<'_>) {
         if args.old_state_id == args.state_id {
             // Already a fire

pumpkin/src/block/blocks/fire/mod.rs

@@ -11,7 +11,7 @@ use rand::Rng;
 use soul_fire::SoulFireBlock;
 
 use crate::block::blocks::fire::fire::FireBlock;
-use crate::block::pumpkin_block::{CanPlaceAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, CanPlaceAtArgs};
 use crate::world::World;
 use crate::world::portal::nether::NetherPortal;
 

pumpkin/src/block/blocks/fire/soul_fire.rs

@@ -4,9 +4,7 @@ use pumpkin_data::{Block, tag};
 use pumpkin_macros::pumpkin_block;
 use pumpkin_world::BlockStateId;
 
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, BrokenArgs, CanPlaceAtArgs, GetStateForNeighborUpdateArgs};
-    BrokenArgs, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock,
-};
 
 use super::FireBlockBase;
 
@@ -21,7 +19,7 @@ impl SoulFireBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for SoulFireBlock {
+impl BlockBehaviour for SoulFireBlock {
     async fn get_state_for_neighbor_update(
         &self,
         args: GetStateForNeighborUpdateArgs<'_>,

pumpkin/src/block/blocks/flower_pots.rs

@@ -1,5 +1,5 @@
-use crate::block::pumpkin_block::{PumpkinBlock, RandomTickArgs, UseWithItemArgs};
 use crate::block::registry::BlockActionResult;
+use crate::block::{BlockBehaviour, RandomTickArgs, UseWithItemArgs};
 use async_trait::async_trait;
 use pumpkin_data::Block;
 use pumpkin_data::flower_pot_transformations::get_potted_item;
@@ -12,7 +12,7 @@ use pumpkin_world::world::BlockFlags;
 pub struct FlowerPotBlock;
 
 #[async_trait]
-impl PumpkinBlock for FlowerPotBlock {
+impl BlockBehaviour for FlowerPotBlock {
     async fn use_with_item(&self, args: UseWithItemArgs<'_>) -> BlockActionResult {
         let item = args.item_stack.lock().await.item;
         //Place the flower inside the pot

pumpkin/src/block/blocks/furnace.rs

@@ -13,7 +13,7 @@ use pumpkin_world::{
 };
 use tokio::sync::Mutex;
 
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::BlockBehaviour;
 
 struct FurnaceScreenFactory {
     inventory: Arc<dyn Inventory>,
@@ -56,10 +56,10 @@ impl ScreenHandlerFactory for FurnaceScreenFactory {
 pub struct FurnaceBlock;
 
 #[async_trait]
-impl PumpkinBlock for FurnaceBlock {
+impl BlockBehaviour for FurnaceBlock {
     async fn normal_use(
         &self,
-        args: crate::block::pumpkin_block::NormalUseArgs<'_>,
+        args: crate::block::NormalUseArgs<'_>,
     ) -> crate::block::registry::BlockActionResult {
         if let Some(block_entity) = args.world.get_block_entity(args.position).await {
             if let Some(inventory) = block_entity.clone().get_inventory() {
@@ -75,34 +75,24 @@ impl PumpkinBlock for FurnaceBlock {
     //Same to normal_use
     async fn use_with_item(
         &self,
-        _args: crate::block::pumpkin_block::UseWithItemArgs<'_>,
+        _args: crate::block::UseWithItemArgs<'_>,
     ) -> crate::block::registry::BlockActionResult {
         crate::block::registry::BlockActionResult::PassToDefaultBlockAction
     }
 
-    async fn on_entity_collision(
+    async fn on_entity_collision(&self, _args: crate::block::OnEntityCollisionArgs<'_>) {}
-        &self,
-        _args: crate::block::pumpkin_block::OnEntityCollisionArgs<'_>,
-    ) {
-    }
 
     fn should_drop_items_on_explosion(&self) -> bool {
         true
     }
 
-    async fn explode(&self, _args: crate::block::pumpkin_block::ExplodeArgs<'_>) {}
+    async fn explode(&self, _args: crate::block::ExplodeArgs<'_>) {}
 
-    async fn on_synced_block_event(
+    async fn on_synced_block_event(&self, _args: crate::block::OnSyncedBlockEventArgs<'_>) -> bool {
-        &self,
-        _args: crate::block::pumpkin_block::OnSyncedBlockEventArgs<'_>,
-    ) -> bool {
         false
     }
 
-    async fn on_place(
+    async fn on_place(&self, args: crate::block::OnPlaceArgs<'_>) -> pumpkin_world::BlockStateId {
-        &self,
-        args: crate::block::pumpkin_block::OnPlaceArgs<'_>,
-    ) -> pumpkin_world::BlockStateId {
         let mut props = FurnaceLikeProperties::default(args.block);
         props.facing = args
             .player
@@ -114,74 +104,59 @@ impl PumpkinBlock for FurnaceBlock {
         props.to_state_id(args.block)
     }
 
-    async fn random_tick(&self, _args: crate::block::pumpkin_block::RandomTickArgs<'_>) {}
+    async fn random_tick(&self, _args: crate::block::RandomTickArgs<'_>) {}
 
-    async fn can_place_at(&self, _args: crate::block::pumpkin_block::CanPlaceAtArgs<'_>) -> bool {
+    async fn can_place_at(&self, _args: crate::block::CanPlaceAtArgs<'_>) -> bool {
         true
     }
 
-    async fn can_update_at(&self, _args: crate::block::pumpkin_block::CanUpdateAtArgs<'_>) -> bool {
+    async fn can_update_at(&self, _args: crate::block::CanUpdateAtArgs<'_>) -> bool {
         false
     }
 
-    async fn placed(&self, args: crate::block::pumpkin_block::PlacedArgs<'_>) {
+    async fn placed(&self, args: crate::block::PlacedArgs<'_>) {
         let furnace_block_entity = FurnaceBlockEntity::new(*args.position);
         args.world
             .add_block_entity(Arc::new(furnace_block_entity))
             .await;
     }
 
-    async fn player_placed(&self, _args: crate::block::pumpkin_block::PlayerPlacedArgs<'_>) {}
+    async fn player_placed(&self, _args: crate::block::PlayerPlacedArgs<'_>) {}
 
-    async fn broken(&self, args: crate::block::pumpkin_block::BrokenArgs<'_>) {
+    async fn broken(&self, args: crate::block::BrokenArgs<'_>) {
         args.world.remove_block_entity(args.position).await;
     }
 
-    async fn on_neighbor_update(
+    async fn on_neighbor_update(&self, _args: crate::block::OnNeighborUpdateArgs<'_>) {}
-        &self,
-        _args: crate::block::pumpkin_block::OnNeighborUpdateArgs<'_>,
-    ) {
-    }
 
-    async fn prepare(&self, _args: crate::block::pumpkin_block::PrepareArgs<'_>) {}
+    async fn prepare(&self, _args: crate::block::PrepareArgs<'_>) {}
 
     async fn get_state_for_neighbor_update(
         &self,
-        args: crate::block::pumpkin_block::GetStateForNeighborUpdateArgs<'_>,
+        args: crate::block::GetStateForNeighborUpdateArgs<'_>,
     ) -> pumpkin_world::BlockStateId {
         args.state_id
     }
 
-    async fn on_scheduled_tick(&self, _args: crate::block::pumpkin_block::OnScheduledTickArgs<'_>) {
+    async fn on_scheduled_tick(&self, _args: crate::block::OnScheduledTickArgs<'_>) {}
-    }
 
-    async fn on_state_replaced(&self, _args: crate::block::pumpkin_block::OnStateReplacedArgs<'_>) {
+    async fn on_state_replaced(&self, _args: crate::block::OnStateReplacedArgs<'_>) {}
-    }
 
-    async fn emits_redstone_power(
+    async fn emits_redstone_power(&self, _args: crate::block::EmitsRedstonePowerArgs<'_>) -> bool {
-        &self,
-        _args: crate::block::pumpkin_block::EmitsRedstonePowerArgs<'_>,
-    ) -> bool {
         false
     }
 
-    async fn get_weak_redstone_power(
+    async fn get_weak_redstone_power(&self, _args: crate::block::GetRedstonePowerArgs<'_>) -> u8 {
-        &self,
-        _args: crate::block::pumpkin_block::GetRedstonePowerArgs<'_>,
-    ) -> u8 {
         0
     }
 
-    async fn get_strong_redstone_power(
+    async fn get_strong_redstone_power(&self, _args: crate::block::GetRedstonePowerArgs<'_>) -> u8 {
-        &self,
-        _args: crate::block::pumpkin_block::GetRedstonePowerArgs<'_>,
-    ) -> u8 {
         0
     }
 
     async fn get_comparator_output(
         &self,
-        _args: crate::block::pumpkin_block::GetComparatorOutputArgs<'_>,
+        _args: crate::block::GetComparatorOutputArgs<'_>,
     ) -> Option<u8> {
         None
     }

pumpkin/src/block/blocks/glass_panes.rs

@@ -1,5 +1,5 @@
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnPlaceArgs;
 use async_trait::async_trait;
 use pumpkin_data::BlockDirection;
 use pumpkin_data::block_properties::BlockProperties;
@@ -12,7 +12,7 @@ use pumpkin_world::BlockStateId;
 
 type GlassPaneProperties = pumpkin_data::block_properties::OakFenceLikeProperties;
 
-use crate::block::pumpkin_block::{BlockMetadata, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata};
 use crate::world::World;
 
 pub struct GlassPaneBlock;
@@ -27,7 +27,7 @@ impl BlockMetadata for GlassPaneBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for GlassPaneBlock {
+impl BlockBehaviour for GlassPaneBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut pane_props = GlassPaneProperties::default(args.block);
         pane_props.waterlogged = args.replacing.water_source();

pumpkin/src/block/blocks/glazed_terracotta.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::{BlockMetadata, OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, OnPlaceArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, WallTorchLikeProperties};
 use pumpkin_data::tag::{RegistryKey, get_tag_values};
@@ -16,7 +16,7 @@ impl BlockMetadata for GlazedTerracottaBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for GlazedTerracottaBlock {
+impl BlockBehaviour for GlazedTerracottaBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut prop = WallTorchLikeProperties::default(args.block);
         prop.facing = args

pumpkin/src/block/blocks/grindstone.rs

@@ -7,9 +7,9 @@ use pumpkin_macros::pumpkin_block;
 use pumpkin_util::math::position::BlockPos;
 use pumpkin_world::{BlockStateId, world::BlockAccessor};
 
-use crate::block::pumpkin_block::CanPlaceAtArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::{GetStateForNeighborUpdateArgs, OnPlaceArgs};
+use crate::block::{GetStateForNeighborUpdateArgs, OnPlaceArgs};
 
 use super::abstruct_wall_mounting::WallMountedBlock;
 
@@ -17,7 +17,7 @@ use super::abstruct_wall_mounting::WallMountedBlock;
 pub struct GrindstoneBlock;
 
 #[async_trait]
-impl PumpkinBlock for GrindstoneBlock {
+impl BlockBehaviour for GrindstoneBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props =
             GrindstoneLikeProperties::from_state_id(args.block.default_state.id, args.block);

pumpkin/src/block/blocks/hopper.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use crate::block::blocks::redstone::block_receives_redstone_power;
-use crate::block::pumpkin_block::{OnNeighborUpdateArgs, OnPlaceArgs, PlacedArgs};
+use crate::block::{OnNeighborUpdateArgs, OnPlaceArgs, PlacedArgs};
 use crate::block::{
-    pumpkin_block::{NormalUseArgs, PumpkinBlock},
     registry::BlockActionResult,
+    {BlockBehaviour, NormalUseArgs},
 };
 use crate::world::World;
 use async_trait::async_trait;
@@ -50,7 +50,7 @@ pub struct HopperBlock;
 type HopperLikeProperties = pumpkin_data::block_properties::HopperLikeProperties;
 
 #[async_trait]
-impl PumpkinBlock for HopperBlock {
+impl BlockBehaviour for HopperBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         if let Some(block_entity) = args.world.get_block_entity(args.position).await {
             if let Some(inventory) = block_entity.get_inventory() {

pumpkin/src/block/blocks/iron_bars.rs

@@ -1,5 +1,5 @@
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnPlaceArgs;
 use async_trait::async_trait;
 use pumpkin_data::BlockDirection;
 use pumpkin_data::block_properties::BlockProperties;
@@ -11,14 +11,14 @@ use pumpkin_world::BlockStateId;
 
 type IronBarsProperties = pumpkin_data::block_properties::OakFenceLikeProperties;
 
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::BlockBehaviour;
 use crate::world::World;
 
 #[pumpkin_block("minecraft:iron_bars")]
 pub struct IronBarsBlock;
 
 #[async_trait]
-impl PumpkinBlock for IronBarsBlock {
+impl BlockBehaviour for IronBarsBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut bars_props = IronBarsProperties::default(args.block);
         bars_props.waterlogged = args.replacing.water_source();

pumpkin/src/block/blocks/jukebox.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::{BrokenArgs, PumpkinBlock, UseWithItemArgs};
 use crate::block::registry::BlockActionResult;
+use crate::block::{BlockBehaviour, BrokenArgs, UseWithItemArgs};
 use crate::world::World;
 use async_trait::async_trait;
 use pumpkin_data::data_component_impl::JukeboxPlayableImpl;
@@ -46,7 +46,7 @@ impl JukeboxBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for JukeboxBlock {
+impl BlockBehaviour for JukeboxBlock {
     async fn use_with_item(&self, args: UseWithItemArgs<'_>) -> BlockActionResult {
         let world = &args.player.living_entity.entity.world.read().await;
 

pumpkin/src/block/blocks/ladder.rs

@@ -1,5 +1,5 @@
-use crate::block::pumpkin_block::{
+use crate::block::{
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs, PumpkinBlock,
+    BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs,
 };
 use crate::world::World;
 use async_trait::async_trait;
@@ -16,7 +16,7 @@ use pumpkin_world::world::BlockFlags;
 pub struct LadderBlock;
 
 #[async_trait]
-impl PumpkinBlock for LadderBlock {
+impl BlockBehaviour for LadderBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = LadderLikeProperties::default(args.block);
         props.facing = args.direction.opposite().to_cardinal_direction();

pumpkin/src/block/blocks/lectern.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::{OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, OnPlaceArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, LecternLikeProperties};
 use pumpkin_macros::pumpkin_block;
@@ -8,7 +8,7 @@ use pumpkin_world::BlockStateId;
 pub struct LecternBlock;
 
 #[async_trait]
-impl PumpkinBlock for LecternBlock {
+impl BlockBehaviour for LecternBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = LecternLikeProperties::default(args.block);
         props.facing = args

pumpkin/src/block/blocks/logs.rs

@@ -4,8 +4,8 @@ use pumpkin_data::tag::{RegistryKey, get_tag_values};
 use pumpkin_macros::pumpkin_block_from_tag;
 use pumpkin_world::BlockStateId;
 
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::OnPlaceArgs;
 
 type LogProperties = pumpkin_data::block_properties::PaleOakWoodLikeProperties;
 
@@ -13,7 +13,7 @@ type LogProperties = pumpkin_data::block_properties::PaleOakWoodLikeProperties;
 pub struct LogBlock;
 
 #[async_trait]
-impl PumpkinBlock for LogBlock {
+impl BlockBehaviour for LogBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut log_props = LogProperties::default(args.block);
         log_props.axis = args.direction.to_axis();

pumpkin/src/block/blocks/nether_portal.rs

@@ -1,8 +1,6 @@
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, GetStateForNeighborUpdateArgs, OnEntityCollisionArgs};
-    GetStateForNeighborUpdateArgs, OnEntityCollisionArgs, PumpkinBlock,
-};
 use crate::entity::EntityBase;
 use crate::world::World;
 use crate::world::portal::nether::NetherPortal;
@@ -35,7 +33,7 @@ impl NetherPortalBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for NetherPortalBlock {
+impl BlockBehaviour for NetherPortalBlock {
     async fn get_state_for_neighbor_update(
         &self,
         args: GetStateForNeighborUpdateArgs<'_>,

pumpkin/src/block/blocks/note.rs

@@ -1,8 +1,8 @@
-use crate::block::pumpkin_block::{
+use crate::block::registry::BlockActionResult;
+use crate::block::{
     GetStateForNeighborUpdateArgs, NormalUseArgs, OnNeighborUpdateArgs, OnPlaceArgs,
     UseWithItemArgs,
 };
-use crate::block::registry::BlockActionResult;
 use async_trait::async_trait;
 use pumpkin_data::block_properties::Axis;
 use pumpkin_data::sound::{Sound, SoundCategory};
@@ -18,7 +18,7 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockFlags;
 
 use crate::{
-    block::pumpkin_block::{OnSyncedBlockEventArgs, PumpkinBlock},
+    block::{BlockBehaviour, OnSyncedBlockEventArgs},
     world::World,
 };
 
@@ -62,7 +62,7 @@ impl NoteBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for NoteBlock {
+impl BlockBehaviour for NoteBlock {
     async fn on_neighbor_update(&self, args: OnNeighborUpdateArgs<'_>) {
         let block_state = args.world.get_block_state(args.position).await;
         let mut note_props = NoteBlockLikeProperties::from_state_id(block_state.id, args.block);

pumpkin/src/block/blocks/piston/piston.rs

@@ -18,9 +18,9 @@ use pumpkin_world::{
 use crate::{
     block::{
         blocks::redstone::is_emitting_redstone_power,
-        pumpkin_block::{
+        {
-            BlockMetadata, OnNeighborUpdateArgs, OnPlaceArgs, OnSyncedBlockEventArgs, PlacedArgs,
+            BlockBehaviour, BlockMetadata, OnNeighborUpdateArgs, OnPlaceArgs,
-            PumpkinBlock,
+            OnSyncedBlockEventArgs, PlacedArgs,
         },
     },
     world::World,
@@ -85,7 +85,7 @@ impl PistonBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for PistonBlock {
+impl BlockBehaviour for PistonBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = PistonProps::default(args.block);
         props.extended = false;

pumpkin/src/block/blocks/piston/piston_extension.rs

@@ -4,8 +4,8 @@ use pumpkin_data::{Block, FacingExt};
 use pumpkin_macros::pumpkin_block;
 use pumpkin_world::world::BlockFlags;
 
-use crate::block::pumpkin_block::BrokenArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::BrokenArgs;
 
 use super::piston::PistonProps;
 
@@ -15,7 +15,7 @@ pub(crate) type MovingPistonProps = pumpkin_data::block_properties::MovingPiston
 pub struct PistonExtensionBlock;
 
 #[async_trait]
-impl PumpkinBlock for PistonExtensionBlock {
+impl BlockBehaviour for PistonExtensionBlock {
     async fn broken(&self, args: BrokenArgs<'_>) {
         let props = MovingPistonProps::from_state_id(args.state.id, &Block::MOVING_PISTON);
         let pos = args

pumpkin/src/block/blocks/piston/piston_head.rs

@@ -4,8 +4,8 @@ use pumpkin_data::{Block, FacingExt};
 use pumpkin_macros::pumpkin_block;
 use pumpkin_world::world::BlockFlags;
 
-use crate::block::pumpkin_block::BrokenArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::BrokenArgs;
 
 use super::piston::PistonProps;
 
@@ -15,7 +15,7 @@ pub(crate) type PistonHeadProperties = pumpkin_data::block_properties::PistonHea
 pub struct PistonHeadBlock;
 
 #[async_trait]
-impl PumpkinBlock for PistonHeadBlock {
+impl BlockBehaviour for PistonHeadBlock {
     async fn broken(&self, args: BrokenArgs<'_>) {
         let props = PistonHeadProperties::from_state_id(args.state.id, &Block::PISTON_HEAD);
         let pos = args

pumpkin/src/block/blocks/plant/bush.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use pumpkin_data::Block;
 
 use crate::block::blocks::plant::PlantBlockBase;
-use crate::block::pumpkin_block::{BlockMetadata, CanPlaceAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, CanPlaceAtArgs};
 
 pub struct BushBlock;
 
@@ -17,7 +17,7 @@ impl BlockMetadata for BushBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for BushBlock {
+impl BlockBehaviour for BushBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as PlantBlockBase>::can_place_at(self, args.block_accessor, args.position).await
     }

pumpkin/src/block/blocks/plant/crop/beetroot.rs

@@ -9,9 +9,7 @@ use rand::Rng;
 
 use crate::block::blocks::plant::PlantBlockBase;
 use crate::block::blocks::plant::crop::CropBlockBase;
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, RandomTickArgs};
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock, RandomTickArgs,
-};
 
 type BeetrootProperties = NetherWartLikeProperties;
 
@@ -19,7 +17,7 @@ type BeetrootProperties = NetherWartLikeProperties;
 pub struct BeetrootBlock;
 
 #[async_trait]
-impl PumpkinBlock for BeetrootBlock {
+impl BlockBehaviour for BeetrootBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as CropBlockBase>::can_plant_on_top(self, args.block_accessor, &args.position.down())
             .await

pumpkin/src/block/blocks/plant/crop/carrot.rs

@@ -4,15 +4,13 @@ use pumpkin_world::BlockStateId;
 
 use crate::block::blocks::plant::PlantBlockBase;
 use crate::block::blocks::plant::crop::CropBlockBase;
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, RandomTickArgs};
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock, RandomTickArgs,
-};
 
 #[pumpkin_block("minecraft:carrots")]
 pub struct CarrotBlock;
 
 #[async_trait]
-impl PumpkinBlock for CarrotBlock {
+impl BlockBehaviour for CarrotBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as CropBlockBase>::can_plant_on_top(self, args.block_accessor, &args.position.down())
             .await

pumpkin/src/block/blocks/plant/crop/potatoes.rs

@@ -4,15 +4,13 @@ use pumpkin_world::BlockStateId;
 
 use crate::block::blocks::plant::PlantBlockBase;
 use crate::block::blocks::plant::crop::CropBlockBase;
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, RandomTickArgs};
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock, RandomTickArgs,
-};
 
 #[pumpkin_block("minecraft:potatoes")]
 pub struct PotatoBlock;
 
 #[async_trait]
-impl PumpkinBlock for PotatoBlock {
+impl BlockBehaviour for PotatoBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as CropBlockBase>::can_plant_on_top(self, args.block_accessor, &args.position.down())
             .await

pumpkin/src/block/blocks/plant/crop/torch_flower.rs

@@ -9,9 +9,7 @@ use rand::Rng;
 
 use crate::block::blocks::plant::PlantBlockBase;
 use crate::block::blocks::plant::crop::CropBlockBase;
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, RandomTickArgs};
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock, RandomTickArgs,
-};
 
 type TorchFlowerProperties = TorchflowerCropLikeProperties;
 
@@ -19,7 +17,7 @@ type TorchFlowerProperties = TorchflowerCropLikeProperties;
 pub struct TorchFlowerBlock;
 
 #[async_trait]
-impl PumpkinBlock for TorchFlowerBlock {
+impl BlockBehaviour for TorchFlowerBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as CropBlockBase>::can_plant_on_top(self, args.block_accessor, &args.position.down())
             .await

pumpkin/src/block/blocks/plant/crop/wheat.rs

@@ -4,15 +4,13 @@ use pumpkin_world::BlockStateId;
 
 use crate::block::blocks::plant::PlantBlockBase;
 use crate::block::blocks::plant::crop::CropBlockBase;
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, RandomTickArgs};
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock, RandomTickArgs,
-};
 
 #[pumpkin_block("minecraft:wheat")]
 pub struct WheatBlock;
 
 #[async_trait]
-impl PumpkinBlock for WheatBlock {
+impl BlockBehaviour for WheatBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as CropBlockBase>::can_plant_on_top(self, args.block_accessor, &args.position.down())
             .await

pumpkin/src/block/blocks/plant/dry_vegetation.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use pumpkin_data::tag;
 use pumpkin_data::tag::Taggable;
 
-use crate::block::pumpkin_block::{BlockMetadata, CanPlaceAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, CanPlaceAtArgs};
 
 pub struct DryVegetationBlock;
 
@@ -17,7 +17,7 @@ impl BlockMetadata for DryVegetationBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for DryVegetationBlock {
+impl BlockBehaviour for DryVegetationBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         let block_below = args.block_accessor.get_block(&args.position.down()).await;
         block_below.is_tagged_with_by_tag(&tag::Block::MINECRAFT_DRY_VEGETATION_MAY_PLACE_ON)

pumpkin/src/block/blocks/plant/flower.rs

@@ -6,11 +6,9 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockFlags;
 
 use crate::block::blocks::plant::PlantBlockBase;
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, BlockMetadata, CanPlaceAtArgs, GetStateForNeighborUpdateArgs};
-    BlockMetadata, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock,
-};
 
-use crate::block::pumpkin_block::RandomTickArgs;
+use crate::block::RandomTickArgs;
 
 pub struct FlowerBlock;
 
@@ -25,7 +23,7 @@ impl BlockMetadata for FlowerBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for FlowerBlock {
+impl BlockBehaviour for FlowerBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as PlantBlockBase>::can_place_at(self, args.block_accessor, args.position).await
     }

pumpkin/src/block/blocks/plant/flowerbed.rs

@@ -5,9 +5,9 @@ use pumpkin_world::BlockStateId;
 
 use crate::block::blocks::plant::PlantBlockBase;
 
-use crate::block::pumpkin_block::{
+use crate::block::{
-    BlockMetadata, CanPlaceAtArgs, CanUpdateAtArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs,
+    BlockBehaviour, BlockMetadata, CanPlaceAtArgs, CanUpdateAtArgs, GetStateForNeighborUpdateArgs,
-    PumpkinBlock,
+    OnPlaceArgs,
 };
 
 use super::segmented::Segmented;
@@ -27,7 +27,7 @@ impl BlockMetadata for FlowerbedBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for FlowerbedBlock {
+impl BlockBehaviour for FlowerbedBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         let block_below = args.block_accessor.get_block(&args.position.down()).await;
         block_below.is_tagged_with_by_tag(&tag::Block::MINECRAFT_DIRT)

pumpkin/src/block/blocks/plant/leaf_litter.rs

@@ -2,9 +2,9 @@ use async_trait::async_trait;
 use pumpkin_data::{Block, BlockDirection};
 use pumpkin_world::BlockStateId;
 
-use crate::block::pumpkin_block::{
+use crate::block::{
-    BlockMetadata, CanPlaceAtArgs, CanUpdateAtArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs,
+    BlockBehaviour, BlockMetadata, CanPlaceAtArgs, CanUpdateAtArgs, GetStateForNeighborUpdateArgs,
-    PumpkinBlock,
+    OnPlaceArgs,
 };
 
 use super::segmented::Segmented;
@@ -24,7 +24,7 @@ impl BlockMetadata for LeafLitterBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for LeafLitterBlock {
+impl BlockBehaviour for LeafLitterBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         let block_below = args
             .block_accessor

pumpkin/src/block/blocks/plant/lily_pad.rs

@@ -7,15 +7,15 @@ use pumpkin_world::{
     world::{BlockAccessor, BlockFlags},
 };
 
-use crate::block::{blocks::plant::PlantBlockBase, pumpkin_block::GetStateForNeighborUpdateArgs};
+use crate::block::{GetStateForNeighborUpdateArgs, blocks::plant::PlantBlockBase};
 
-use crate::block::pumpkin_block::{CanPlaceAtArgs, OnEntityCollisionArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, CanPlaceAtArgs, OnEntityCollisionArgs};
 
 #[pumpkin_block("minecraft:lily_pad")]
 pub struct LilyPadBlock;
 
 #[async_trait]
-impl PumpkinBlock for LilyPadBlock {
+impl BlockBehaviour for LilyPadBlock {
     async fn on_entity_collision(&self, args: OnEntityCollisionArgs<'_>) {
         // Proberbly not the best solution, but works
         if args

pumpkin/src/block/blocks/plant/mushroom_plant.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use pumpkin_data::tag;
 use pumpkin_data::tag::Taggable;
 
-use crate::block::pumpkin_block::{BlockMetadata, CanPlaceAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, CanPlaceAtArgs};
 
 pub struct MushroomPlantBlock;
 
@@ -17,7 +17,7 @@ impl BlockMetadata for MushroomPlantBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for MushroomPlantBlock {
+impl BlockBehaviour for MushroomPlantBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         let block_below = args.block_accessor.get_block(&args.position.down()).await;
         if block_below.is_tagged_with_by_tag(&tag::Block::MINECRAFT_MUSHROOM_GROW_BLOCK) {

pumpkin/src/block/blocks/plant/nether_wart.rs

@@ -6,13 +6,13 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockAccessor;
 
 use crate::block::blocks::plant::PlantBlockBase;
-use crate::block::pumpkin_block::{CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs};
 
 #[pumpkin_block("minecraft:nether_wart")]
 pub struct NetherWartBlock;
 
 #[async_trait]
-impl PumpkinBlock for NetherWartBlock {
+impl BlockBehaviour for NetherWartBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as PlantBlockBase>::can_place_at(self, args.block_accessor, args.position).await
     }

pumpkin/src/block/blocks/plant/roots.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use pumpkin_data::tag::Taggable;
 use pumpkin_data::{Block, tag};
 
-use crate::block::pumpkin_block::{BlockMetadata, CanPlaceAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, CanPlaceAtArgs};
 
 pub struct RootsBlock;
 
@@ -17,7 +17,7 @@ impl BlockMetadata for RootsBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for RootsBlock {
+impl BlockBehaviour for RootsBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         let block_below = args.block_accessor.get_block(&args.position.down()).await;
         block_below.is_tagged_with_by_tag(&tag::Block::MINECRAFT_NYLIUM)

pumpkin/src/block/blocks/plant/sapling.rs

@@ -8,9 +8,7 @@ use pumpkin_world::world::BlockFlags;
 use std::sync::Arc;
 
 use crate::block::blocks::plant::PlantBlockBase;
-use crate::block::pumpkin_block::{
+use crate::block::{BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, RandomTickArgs};
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock, RandomTickArgs,
-};
 use crate::world::World;
 
 type SaplingProperties = pumpkin_data::block_properties::OakSaplingLikeProperties;
@@ -34,7 +32,7 @@ impl SaplingBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for SaplingBlock {
+impl BlockBehaviour for SaplingBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as PlantBlockBase>::can_place_at(self, args.block_accessor, args.position).await
     }

pumpkin/src/block/blocks/plant/sea_grass.rs

@@ -5,14 +5,14 @@ use pumpkin_world::BlockStateId;
 
 use crate::block::{
     blocks::plant::PlantBlockBase,
-    pumpkin_block::{CanPlaceAtArgs, GetStateForNeighborUpdateArgs, PumpkinBlock},
+    {BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs},
 };
 
 #[pumpkin_block("minecraft:seagrass")]
 pub struct SeaGrassBlock;
 
 #[async_trait]
-impl PumpkinBlock for SeaGrassBlock {
+impl BlockBehaviour for SeaGrassBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         <Self as PlantBlockBase>::can_place_at(self, args.block_accessor, args.position).await
     }

pumpkin/src/block/blocks/plant/sea_pickles.rs

@@ -1,10 +1,10 @@
 use crate::block::BlockIsReplacing;
 use crate::block::blocks::plant::PlantBlockBase;
-use crate::block::pumpkin_block::{
+use crate::block::registry::BlockActionResult;
-    CanPlaceAtArgs, CanUpdateAtArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs, PumpkinBlock,
+use crate::block::{
+    BlockBehaviour, CanPlaceAtArgs, CanUpdateAtArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs,
     UseWithItemArgs,
 };
-use crate::block::registry::BlockActionResult;
 use crate::entity::EntityBase;
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, Integer1To4};
@@ -24,7 +24,7 @@ type SeaPickleProperties = pumpkin_data::block_properties::SeaPickleLikeProperti
 pub struct SeaPickleBlock;
 
 #[async_trait]
-impl PumpkinBlock for SeaPickleBlock {
+impl BlockBehaviour for SeaPickleBlock {
     #[allow(clippy::many_single_char_names)]
     async fn use_with_item(&self, args: UseWithItemArgs<'_>) -> BlockActionResult {
         if args.item_stack.lock().await.item != &Item::BONE_MEAL

pumpkin/src/block/blocks/plant/segmented.rs

@@ -2,8 +2,8 @@ use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, HorizontalFacing, Integer1To4};
 use pumpkin_world::BlockStateId;
 
-use crate::block::pumpkin_block::{CanUpdateAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, CanUpdateAtArgs};
-use crate::block::{BlockIsReplacing, pumpkin_block::OnPlaceArgs};
+use crate::block::{BlockIsReplacing, OnPlaceArgs};
 
 pub trait SegmentProperties {
     fn get_segment_amount(&self) -> Integer1To4;
@@ -44,7 +44,7 @@ impl_segment_properties!(
 );
 
 #[async_trait]
-pub trait Segmented: PumpkinBlock {
+pub trait Segmented: BlockBehaviour {
     type Properties: BlockProperties + SegmentProperties;
 
     fn can_add_segment(&self, props: &Self::Properties) -> bool {

pumpkin/src/block/blocks/plant/short_plant.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use pumpkin_data::tag::Taggable;
 use pumpkin_data::{Block, tag};
 
-use crate::block::pumpkin_block::{BlockMetadata, CanPlaceAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, CanPlaceAtArgs};
 
 pub struct ShortPlantBlock;
 
@@ -17,7 +17,7 @@ impl BlockMetadata for ShortPlantBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for ShortPlantBlock {
+impl BlockBehaviour for ShortPlantBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         let block_below = args.block_accessor.get_block(&args.position.down()).await;
         block_below.is_tagged_with_by_tag(&tag::Block::MINECRAFT_DIRT)

pumpkin/src/block/blocks/plant/tall_plant.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use pumpkin_data::tag::Taggable;
 use pumpkin_data::{Block, tag};
 
-use crate::block::pumpkin_block::{BlockMetadata, CanPlaceAtArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, CanPlaceAtArgs};
 
 pub struct TallPlantBlock;
 
@@ -26,7 +26,7 @@ impl BlockMetadata for TallPlantBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for TallPlantBlock {
+impl BlockBehaviour for TallPlantBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         let (block, state) = args.block_accessor.get_block_and_state(args.position).await;
         if let Some(props) = block.properties(state.id).map(|s| s.to_props()) {

pumpkin/src/block/blocks/pumpkin.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::UseWithItemArgs;
+use crate::block::UseWithItemArgs;
 use crate::block::registry::BlockActionResult;
 use crate::entity::Entity;
 use crate::entity::item::ItemEntity;
@@ -16,7 +16,7 @@ use uuid::Uuid;
 pub struct PumpkinBlock;
 
 #[async_trait]
-impl crate::block::pumpkin_block::PumpkinBlock for PumpkinBlock {
+impl crate::block::BlockBehaviour for PumpkinBlock {
     async fn use_with_item(&self, args: UseWithItemArgs<'_>) -> BlockActionResult {
         if args.item_stack.lock().await.item != &Item::SHEARS {
             return BlockActionResult::Pass;

pumpkin/src/block/blocks/redstone/abstruct_redstone_gate.rs

@@ -16,9 +16,7 @@ use pumpkin_world::{
 };
 
 use crate::{
-    block::pumpkin_block::{
+    block::{GetRedstonePowerArgs, OnNeighborUpdateArgs, OnStateReplacedArgs, PlayerPlacedArgs},
-        GetRedstonePowerArgs, OnNeighborUpdateArgs, OnStateReplacedArgs, PlayerPlacedArgs,
-    },
     entity::player::Player,
     world::World,
 };

pumpkin/src/block/blocks/redstone/buttons.rs

@@ -16,17 +16,17 @@ use pumpkin_world::world::BlockFlags;
 
 type ButtonLikeProperties = pumpkin_data::block_properties::LeverLikeProperties;
 
+use crate::block::CanPlaceAtArgs;
+use crate::block::EmitsRedstonePowerArgs;
+use crate::block::GetRedstonePowerArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
+use crate::block::OnPlaceArgs;
+use crate::block::OnScheduledTickArgs;
+use crate::block::OnStateReplacedArgs;
 use crate::block::blocks::abstruct_wall_mounting::WallMountedBlock;
 use crate::block::blocks::redstone::lever::LeverLikePropertiesExt;
-use crate::block::pumpkin_block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::EmitsRedstonePowerArgs;
-use crate::block::pumpkin_block::GetRedstonePowerArgs;
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
-use crate::block::pumpkin_block::OnScheduledTickArgs;
-use crate::block::pumpkin_block::OnStateReplacedArgs;
-use crate::block::pumpkin_block::{NormalUseArgs, PumpkinBlock};
 use crate::block::registry::BlockActionResult;
+use crate::block::{BlockBehaviour, NormalUseArgs};
 use crate::world::World;
 
 async fn click_button(world: &Arc<World>, block_pos: &BlockPos) {
@@ -58,7 +58,7 @@ async fn click_button(world: &Arc<World>, block_pos: &BlockPos) {
 pub struct ButtonBlock;
 
 #[async_trait]
-impl PumpkinBlock for ButtonBlock {
+impl BlockBehaviour for ButtonBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         click_button(args.world, args.position).await;
 

pumpkin/src/block/blocks/redstone/comparator.rs

@@ -17,13 +17,13 @@ use pumpkin_world::{
 
 use crate::{
     block::{
-        pumpkin_block::{
-            BrokenArgs, CanPlaceAtArgs, EmitsRedstonePowerArgs, GetComparatorOutputArgs,
-            GetRedstonePowerArgs, GetStateForNeighborUpdateArgs, NormalUseArgs,
-            OnNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs, OnStateReplacedArgs,
-            PlacedArgs, PlayerPlacedArgs, PumpkinBlock,
-        },
         registry::BlockActionResult,
+        {
+            BlockBehaviour, BrokenArgs, CanPlaceAtArgs, EmitsRedstonePowerArgs,
+            GetComparatorOutputArgs, GetRedstonePowerArgs, GetStateForNeighborUpdateArgs,
+            NormalUseArgs, OnNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs,
+            OnStateReplacedArgs, PlacedArgs, PlayerPlacedArgs,
+        },
     },
     world::World,
 };
@@ -34,7 +34,7 @@ use super::abstruct_redstone_gate::{self, RedstoneGateBlock, RedstoneGateBlockPr
 pub struct ComparatorBlock;
 
 #[async_trait]
-impl PumpkinBlock for ComparatorBlock {
+impl BlockBehaviour for ComparatorBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         RedstoneGateBlock::on_place(self, args.player, args.block).await
     }

pumpkin/src/block/blocks/redstone/copper_bulb.rs

@@ -1,5 +1,5 @@
 use crate::block::blocks::redstone::block_receives_redstone_power;
-use crate::block::pumpkin_block::{BlockMetadata, OnNeighborUpdateArgs, OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, OnNeighborUpdateArgs, OnPlaceArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::BlockProperties;
 use pumpkin_data::sound::{Sound, SoundCategory};
@@ -30,7 +30,7 @@ impl BlockMetadata for CopperBulbBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for CopperBulbBlock {
+impl BlockBehaviour for CopperBulbBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = CopperBulbLikeProperties::default(args.block);
         let is_receiving_power = block_receives_redstone_power(args.world, args.position).await;

pumpkin/src/block/blocks/redstone/dispenser.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::{OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, OnPlaceArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, DispenserLikeProperties};
 use pumpkin_macros::pumpkin_block;
@@ -8,7 +8,7 @@ use pumpkin_world::BlockStateId;
 pub struct DispenserBlock;
 
 #[async_trait]
-impl PumpkinBlock for DispenserBlock {
+impl BlockBehaviour for DispenserBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = DispenserLikeProperties::default(args.block);
         props.facing = args.player.living_entity.entity.get_facing().opposite();

pumpkin/src/block/blocks/redstone/dropper.rs

@@ -1,8 +1,9 @@
 use crate::block::blocks::redstone::block_receives_redstone_power;
-use crate::block::pumpkin_block::{
-    NormalUseArgs, OnNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs, PlacedArgs, PumpkinBlock,
-};
 use crate::block::registry::BlockActionResult;
+use crate::block::{
+    BlockBehaviour, NormalUseArgs, OnNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs,
+    PlacedArgs,
+};
 use crate::entity::Entity;
 use crate::entity::item::ItemEntity;
 use async_trait::async_trait;
@@ -81,7 +82,7 @@ const fn to_data3d(facing: Facing) -> i32 {
 }
 
 #[async_trait]
-impl PumpkinBlock for DropperBlock {
+impl BlockBehaviour for DropperBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         if let Some(block_entity) = args.world.get_block_entity(args.position).await {
             if let Some(inventory) = block_entity.get_inventory() {

pumpkin/src/block/blocks/redstone/lever.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::block::{
     blocks::abstruct_wall_mounting::WallMountedBlock,
-    pumpkin_block::{
+    {
         CanPlaceAtArgs, EmitsRedstonePowerArgs, GetRedstonePowerArgs,
         GetStateForNeighborUpdateArgs, OnPlaceArgs, OnStateReplacedArgs,
     },
@@ -18,8 +18,8 @@ use pumpkin_world::{BlockStateId, world::BlockFlags};
 
 use crate::{
     block::{
-        pumpkin_block::{NormalUseArgs, PumpkinBlock},
         registry::BlockActionResult,
+        {BlockBehaviour, NormalUseArgs},
     },
     world::World,
 };
@@ -44,7 +44,7 @@ async fn toggle_lever(world: &Arc<World>, block_pos: &BlockPos) {
 pub struct LeverBlock;
 
 #[async_trait]
-impl PumpkinBlock for LeverBlock {
+impl BlockBehaviour for LeverBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         toggle_lever(args.world, args.position).await;
 

pumpkin/src/block/blocks/redstone/observer.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::{
+use crate::block::{
     EmitsRedstonePowerArgs, GetRedstonePowerArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs,
     OnScheduledTickArgs, OnStateReplacedArgs,
 };
@@ -14,7 +14,7 @@ use pumpkin_util::math::position::BlockPos;
 use pumpkin_world::{BlockStateId, tick::TickPriority, world::BlockFlags};
 
 use crate::{
-    block::pumpkin_block::{OnNeighborUpdateArgs, PumpkinBlock},
+    block::{BlockBehaviour, OnNeighborUpdateArgs},
     world::World,
 };
 
@@ -22,7 +22,7 @@ use crate::{
 pub struct ObserverBlock;
 
 #[async_trait]
-impl PumpkinBlock for ObserverBlock {
+impl BlockBehaviour for ObserverBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = ObserverLikeProperties::default(args.block);
         props.facing = args.player.living_entity.entity.get_facing();

pumpkin/src/block/blocks/redstone/pressure_plate/mod.rs

@@ -5,7 +5,7 @@ use pumpkin_util::math::position::BlockPos;
 use pumpkin_world::{BlockStateId, tick::TickPriority, world::BlockFlags};
 
 use crate::{
-    block::pumpkin_block::{OnEntityCollisionArgs, OnScheduledTickArgs, OnStateReplacedArgs},
+    block::{OnEntityCollisionArgs, OnScheduledTickArgs, OnStateReplacedArgs},
     world::World,
 };
 

pumpkin/src/block/blocks/redstone/pressure_plate/plate.rs

@@ -8,10 +8,10 @@ use pumpkin_util::math::{boundingbox::BoundingBox, position::BlockPos};
 use pumpkin_world::{BlockStateId, world::BlockFlags};
 
 use crate::{
-    block::pumpkin_block::{
+    block::{
-        BlockMetadata, CanPlaceAtArgs, EmitsRedstonePowerArgs, GetRedstonePowerArgs,
+        BlockBehaviour, BlockMetadata, CanPlaceAtArgs, EmitsRedstonePowerArgs,
-        OnEntityCollisionArgs, OnNeighborUpdateArgs, OnScheduledTickArgs, OnStateReplacedArgs,
+        GetRedstonePowerArgs, OnEntityCollisionArgs, OnNeighborUpdateArgs, OnScheduledTickArgs,
-        PumpkinBlock,
+        OnStateReplacedArgs,
     },
     world::World,
 };
@@ -41,7 +41,7 @@ impl BlockMetadata for PressurePlateBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for PressurePlateBlock {
+impl BlockBehaviour for PressurePlateBlock {
     async fn on_entity_collision(&self, args: OnEntityCollisionArgs<'_>) {
         self.on_entity_collision_pp(args).await;
     }

pumpkin/src/block/blocks/redstone/pressure_plate/weighted.rs

@@ -7,10 +7,10 @@ use pumpkin_util::math::{boundingbox::BoundingBox, position::BlockPos};
 use pumpkin_world::{BlockStateId, world::BlockFlags};
 
 use crate::{
-    block::pumpkin_block::{
+    block::{
-        BlockMetadata, CanPlaceAtArgs, EmitsRedstonePowerArgs, GetRedstonePowerArgs,
+        BlockBehaviour, BlockMetadata, CanPlaceAtArgs, EmitsRedstonePowerArgs,
-        OnEntityCollisionArgs, OnNeighborUpdateArgs, OnScheduledTickArgs, OnStateReplacedArgs,
+        GetRedstonePowerArgs, OnEntityCollisionArgs, OnNeighborUpdateArgs, OnScheduledTickArgs,
-        PumpkinBlock,
+        OnStateReplacedArgs,
     },
     world::World,
 };
@@ -38,7 +38,7 @@ impl BlockMetadata for WeightedPressurePlateBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for WeightedPressurePlateBlock {
+impl BlockBehaviour for WeightedPressurePlateBlock {
     async fn on_entity_collision(&self, args: OnEntityCollisionArgs<'_>) {
         self.on_entity_collision_pp(args).await;
     }

pumpkin/src/block/blocks/redstone/rails/activator_rail.rs

@@ -4,12 +4,12 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockFlags;
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::CanPlaceAtArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::OnNeighborUpdateArgs;
+use crate::block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnStateReplacedArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::PlacedArgs;
+use crate::block::OnStateReplacedArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::PlacedArgs;
 use crate::world::World;
 use pumpkin_data::Block;
 use pumpkin_util::math::position::BlockPos;
@@ -38,7 +38,7 @@ use super::common::{
 pub struct ActivatorRailBlock;
 
 #[async_trait]
-impl PumpkinBlock for ActivatorRailBlock {
+impl BlockBehaviour for ActivatorRailBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut rail_props = RailProperties::default(args.block);
         let player_facing = args.player.living_entity.entity.get_horizontal_facing();
@@ -179,17 +179,11 @@ impl PumpkinBlock for ActivatorRailBlock {
         can_place_rail_at(args.block_accessor, args.position).await
     }
 
-    async fn emits_redstone_power(
+    async fn emits_redstone_power(&self, _args: crate::block::EmitsRedstonePowerArgs<'_>) -> bool {
-        &self,
-        _args: crate::block::pumpkin_block::EmitsRedstonePowerArgs<'_>,
-    ) -> bool {
         false
     }
 
-    async fn get_weak_redstone_power(
+    async fn get_weak_redstone_power(&self, _args: crate::block::GetRedstonePowerArgs<'_>) -> u8 {
-        &self,
-        _args: crate::block::pumpkin_block::GetRedstonePowerArgs<'_>,
-    ) -> u8 {
         0
     }
 }

pumpkin/src/block/blocks/redstone/rails/detector_rail.rs

@@ -3,11 +3,11 @@ use pumpkin_macros::pumpkin_block;
 use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockFlags;
 
-use crate::block::pumpkin_block::CanPlaceAtArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::OnNeighborUpdateArgs;
+use crate::block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnNeighborUpdateArgs;
-use crate::block::pumpkin_block::PlacedArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::PlacedArgs;
 
 use super::RailProperties;
 use super::common::{
@@ -19,7 +19,7 @@ use super::common::{
 pub struct DetectorRailBlock;
 
 #[async_trait]
-impl PumpkinBlock for DetectorRailBlock {
+impl BlockBehaviour for DetectorRailBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut rail_props = RailProperties::default(args.block);
         let player_facing = args.player.living_entity.entity.get_horizontal_facing();

pumpkin/src/block/blocks/redstone/rails/powered_rail.rs

@@ -4,12 +4,12 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockFlags;
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::CanPlaceAtArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::OnNeighborUpdateArgs;
+use crate::block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnStateReplacedArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::PlacedArgs;
+use crate::block::OnStateReplacedArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::PlacedArgs;
 use crate::world::World;
 use pumpkin_data::Block;
 use pumpkin_util::math::position::BlockPos;
@@ -38,7 +38,7 @@ use super::common::{
 pub struct PoweredRailBlock;
 
 #[async_trait]
-impl PumpkinBlock for PoweredRailBlock {
+impl BlockBehaviour for PoweredRailBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut rail_props = RailProperties::default(args.block);
         let player_facing = args.player.living_entity.entity.get_horizontal_facing();
@@ -180,17 +180,11 @@ impl PumpkinBlock for PoweredRailBlock {
         can_place_rail_at(args.block_accessor, args.position).await
     }
 
-    async fn emits_redstone_power(
+    async fn emits_redstone_power(&self, _args: crate::block::EmitsRedstonePowerArgs<'_>) -> bool {
-        &self,
-        _args: crate::block::pumpkin_block::EmitsRedstonePowerArgs<'_>,
-    ) -> bool {
         false
     }
 
-    async fn get_weak_redstone_power(
+    async fn get_weak_redstone_power(&self, _args: crate::block::GetRedstonePowerArgs<'_>) -> u8 {
-        &self,
-        _args: crate::block::pumpkin_block::GetRedstonePowerArgs<'_>,
-    ) -> u8 {
         0
     }
 }

pumpkin/src/block/blocks/redstone/rails/rail.rs

@@ -5,11 +5,11 @@ use pumpkin_macros::pumpkin_block;
 use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockFlags;
 
-use crate::block::pumpkin_block::CanPlaceAtArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::OnNeighborUpdateArgs;
+use crate::block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnNeighborUpdateArgs;
-use crate::block::pumpkin_block::PlacedArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::PlacedArgs;
 
 use super::StraightRailShapeExt;
 use super::common::{can_place_rail_at, rail_placement_is_valid, update_flanking_rails_shape};
@@ -19,7 +19,7 @@ use super::{HorizontalFacingRailExt, Rail, RailElevation, RailProperties};
 pub struct RailBlock;
 
 #[async_trait]
-impl PumpkinBlock for RailBlock {
+impl BlockBehaviour for RailBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let world = args.world;
         let block_pos = args.position;

pumpkin/src/block/blocks/redstone/redstone_block.rs

@@ -1,13 +1,13 @@
 use async_trait::async_trait;
 use pumpkin_macros::pumpkin_block;
 
-use crate::block::pumpkin_block::{EmitsRedstonePowerArgs, GetRedstonePowerArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, EmitsRedstonePowerArgs, GetRedstonePowerArgs};
 
 #[pumpkin_block("minecraft:redstone_block")]
 pub struct RedstoneBlock;
 
 #[async_trait]
-impl PumpkinBlock for RedstoneBlock {
+impl BlockBehaviour for RedstoneBlock {
     async fn get_weak_redstone_power(&self, _args: GetRedstonePowerArgs<'_>) -> u8 {
         15
     }

pumpkin/src/block/blocks/redstone/redstone_lamp.rs

@@ -1,10 +1,10 @@
-use crate::block::pumpkin_block::{OnNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs};
+use crate::block::{OnNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::BlockProperties;
 use pumpkin_macros::pumpkin_block;
 use pumpkin_world::{BlockStateId, tick::TickPriority, world::BlockFlags};
 
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::BlockBehaviour;
 
 use super::block_receives_redstone_power;
 
@@ -14,7 +14,7 @@ type RedstoneLampProperties = pumpkin_data::block_properties::RedstoneOreLikePro
 pub struct RedstoneLamp;
 
 #[async_trait]
-impl PumpkinBlock for RedstoneLamp {
+impl BlockBehaviour for RedstoneLamp {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = RedstoneLampProperties::default(args.block);
         props.lit = block_receives_redstone_power(args.world, args.position).await;

pumpkin/src/block/blocks/redstone/redstone_torch.rs

@@ -1,15 +1,15 @@
 use std::sync::Arc;
 
 use crate::block::BlockIsReplacing;
-use crate::block::pumpkin_block::CanPlaceAtArgs;
+use crate::block::CanPlaceAtArgs;
-use crate::block::pumpkin_block::EmitsRedstonePowerArgs;
+use crate::block::EmitsRedstonePowerArgs;
-use crate::block::pumpkin_block::GetRedstonePowerArgs;
+use crate::block::GetRedstonePowerArgs;
-use crate::block::pumpkin_block::GetStateForNeighborUpdateArgs;
+use crate::block::GetStateForNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnNeighborUpdateArgs;
+use crate::block::OnNeighborUpdateArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::OnScheduledTickArgs;
+use crate::block::OnScheduledTickArgs;
-use crate::block::pumpkin_block::OnStateReplacedArgs;
+use crate::block::OnStateReplacedArgs;
-use crate::block::pumpkin_block::PlacedArgs;
+use crate::block::PlacedArgs;
 use crate::entity::EntityBase;
 use async_trait::async_trait;
 use pumpkin_data::Block;
@@ -27,7 +27,7 @@ use pumpkin_world::world::BlockFlags;
 type RWallTorchProps = pumpkin_data::block_properties::FurnaceLikeProperties;
 type RTorchProps = pumpkin_data::block_properties::RedstoneOreLikeProperties;
 
-use crate::block::pumpkin_block::{BlockMetadata, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata};
 use crate::world::World;
 
 use super::get_redstone_power;
@@ -45,7 +45,7 @@ impl BlockMetadata for RedstoneTorchBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for RedstoneTorchBlock {
+impl BlockBehaviour for RedstoneTorchBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let world = args.world;
         let block = args.block;

pumpkin/src/block/blocks/redstone/redstone_wire.rs

@@ -12,13 +12,13 @@ use pumpkin_util::math::position::BlockPos;
 use pumpkin_world::BlockStateId;
 use pumpkin_world::world::{BlockAccessor, BlockFlags};
 
-use crate::block::pumpkin_block::{
+use crate::block::registry::BlockActionResult;
+use crate::block::{
     BrokenArgs, CanPlaceAtArgs, GetRedstonePowerArgs, GetStateForNeighborUpdateArgs,
     OnNeighborUpdateArgs, OnPlaceArgs, PlacedArgs, PrepareArgs,
 };
-use crate::block::registry::BlockActionResult;
 use crate::{
-    block::pumpkin_block::{NormalUseArgs, PumpkinBlock},
+    block::{BlockBehaviour, NormalUseArgs},
     world::World,
 };
 
@@ -31,7 +31,7 @@ type RedstoneWireProperties = RedstoneWireLikeProperties;
 pub struct RedstoneWireBlock;
 
 #[async_trait]
-impl PumpkinBlock for RedstoneWireBlock {
+impl BlockBehaviour for RedstoneWireBlock {
     async fn can_place_at(&self, args: CanPlaceAtArgs<'_>) -> bool {
         can_place_at(args.block_accessor, args.position).await
     }

pumpkin/src/block/blocks/redstone/repeater.rs

@@ -12,12 +12,12 @@ use pumpkin_world::{BlockStateId, tick::TickPriority};
 
 use crate::{
     block::{
-        pumpkin_block::{
-            CanPlaceAtArgs, EmitsRedstonePowerArgs, GetRedstonePowerArgs,
-            GetStateForNeighborUpdateArgs, NormalUseArgs, OnNeighborUpdateArgs, OnPlaceArgs,
-            OnScheduledTickArgs, OnStateReplacedArgs, PlacedArgs, PlayerPlacedArgs, PumpkinBlock,
-        },
         registry::BlockActionResult,
+        {
+            BlockBehaviour, CanPlaceAtArgs, EmitsRedstonePowerArgs, GetRedstonePowerArgs,
+            GetStateForNeighborUpdateArgs, NormalUseArgs, OnNeighborUpdateArgs, OnPlaceArgs,
+            OnScheduledTickArgs, OnStateReplacedArgs, PlacedArgs, PlayerPlacedArgs,
+        },
     },
     world::World,
 };
@@ -30,7 +30,7 @@ type RepeaterProperties = pumpkin_data::block_properties::RepeaterLikeProperties
 pub struct RepeaterBlock;
 
 #[async_trait]
-impl PumpkinBlock for RepeaterBlock {
+impl BlockBehaviour for RepeaterBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let state_id = RedstoneGateBlock::on_place(self, args.player, args.block).await;
 

pumpkin/src/block/blocks/redstone/target_block.rs

@@ -1,13 +1,13 @@
 use async_trait::async_trait;
 use pumpkin_macros::pumpkin_block;
 
-use crate::block::pumpkin_block::{EmitsRedstonePowerArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, EmitsRedstonePowerArgs};
 
 #[pumpkin_block("minecraft:target")]
 pub struct TargetBlock;
 
 #[async_trait]
-impl PumpkinBlock for TargetBlock {
+impl BlockBehaviour for TargetBlock {
     async fn emits_redstone_power(&self, _args: EmitsRedstonePowerArgs<'_>) -> bool {
         true
     }

pumpkin/src/block/blocks/redstone/tripwire.rs

@@ -11,9 +11,9 @@ use pumpkin_util::math::{boundingbox::BoundingBox, position::BlockPos};
 use pumpkin_world::{BlockStateId, tick::TickPriority, world::BlockFlags};
 
 use crate::{
-    block::pumpkin_block::{
+    block::{
-        BrokenArgs, GetStateForNeighborUpdateArgs, OnEntityCollisionArgs, OnPlaceArgs,
+        BlockBehaviour, BrokenArgs, GetStateForNeighborUpdateArgs, OnEntityCollisionArgs,
-        OnScheduledTickArgs, OnStateReplacedArgs, PlacedArgs, PumpkinBlock,
+        OnPlaceArgs, OnScheduledTickArgs, OnStateReplacedArgs, PlacedArgs,
     },
     world::World,
 };
@@ -27,7 +27,7 @@ type TripwireHookProperties = pumpkin_data::block_properties::TripwireHookLikePr
 pub struct TripwireBlock;
 
 #[async_trait]
-impl PumpkinBlock for TripwireBlock {
+impl BlockBehaviour for TripwireBlock {
     async fn on_entity_collision(&self, args: OnEntityCollisionArgs<'_>) {
         let mut props = TripwireProperties::from_state_id(args.state.id, args.block);
         if props.powered {

pumpkin/src/block/blocks/redstone/tripwire_hook.rs

@@ -16,10 +16,10 @@ use pumpkin_world::{
 use rand::{Rng, rng};
 
 use crate::{
-    block::pumpkin_block::{
+    block::{
-        CanPlaceAtArgs, EmitsRedstonePowerArgs, GetRedstonePowerArgs,
+        BlockBehaviour, CanPlaceAtArgs, EmitsRedstonePowerArgs, GetRedstonePowerArgs,
         GetStateForNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs, OnStateReplacedArgs,
-        PlayerPlacedArgs, PumpkinBlock,
+        PlayerPlacedArgs,
     },
     world::World,
 };
@@ -31,7 +31,7 @@ type TripwireHookProperties = pumpkin_data::block_properties::TripwireHookLikePr
 pub struct TripwireHookBlock;
 
 #[async_trait]
-impl PumpkinBlock for TripwireHookBlock {
+impl BlockBehaviour for TripwireHookBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = TripwireHookProperties::default(args.block);
         props.powered = false;

pumpkin/src/block/blocks/shulker_box.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::{BlockMetadata, OnPlaceArgs, PlacedArgs};
+use crate::block::{BlockMetadata, OnPlaceArgs, PlacedArgs};
 use crate::block::{
-    pumpkin_block::{NormalUseArgs, PumpkinBlock},
     registry::BlockActionResult,
+    {BlockBehaviour, NormalUseArgs},
 };
 use async_trait::async_trait;
 use pumpkin_data::block_properties::BlockProperties;
@@ -54,7 +54,7 @@ impl BlockMetadata for ShulkerBoxBlock {
 type EndRodLikeProperties = pumpkin_data::block_properties::EndRodLikeProperties;
 
 #[async_trait]
-impl PumpkinBlock for ShulkerBoxBlock {
+impl BlockBehaviour for ShulkerBoxBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         if let Some(block_entity) = args.world.get_block_entity(args.position).await {
             if let Some(inventory) = block_entity.get_inventory() {

pumpkin/src/block/blocks/signs.rs

@@ -7,10 +7,10 @@ use pumpkin_data::tag::get_tag_values;
 use pumpkin_macros::pumpkin_block_from_tag;
 use pumpkin_world::block::entities::sign::SignBlockEntity;
 
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::PlacedArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::PlayerPlacedArgs;
+use crate::block::PlacedArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::PlayerPlacedArgs;
 use crate::entity::EntityBase;
 
 type SignProperties = pumpkin_data::block_properties::OakSignLikeProperties;
@@ -19,7 +19,7 @@ type SignProperties = pumpkin_data::block_properties::OakSignLikeProperties;
 pub struct SignBlock;
 
 #[async_trait]
-impl PumpkinBlock for SignBlock {
+impl BlockBehaviour for SignBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> u16 {
         let mut sign_props = SignProperties::default(args.block);
         sign_props.waterlogged = args.replacing.water_source();

pumpkin/src/block/blocks/skull_block.rs

@@ -1,5 +1,5 @@
 use crate::block::blocks::redstone::block_receives_redstone_power;
-use crate::block::pumpkin_block::{BlockMetadata, OnNeighborUpdateArgs, OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, BlockMetadata, OnNeighborUpdateArgs, OnPlaceArgs};
 use crate::entity::EntityBase;
 use async_trait::async_trait;
 use pumpkin_data::block_properties::BlockProperties;
@@ -29,7 +29,7 @@ impl BlockMetadata for SkullBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for SkullBlock {
+impl BlockBehaviour for SkullBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = SkeletonSkullLikeProperties::default(args.block);
         props.rotation = args.player.get_entity().get_rotation_16();

pumpkin/src/block/blocks/slabs.rs

@@ -7,10 +7,10 @@ use pumpkin_data::tag::get_tag_values;
 use pumpkin_macros::pumpkin_block_from_tag;
 use pumpkin_world::BlockStateId;
 
+use crate::block::BlockBehaviour;
 use crate::block::BlockIsReplacing;
-use crate::block::pumpkin_block::CanUpdateAtArgs;
+use crate::block::CanUpdateAtArgs;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnPlaceArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
 
 type SlabProperties = pumpkin_data::block_properties::ResinBrickSlabLikeProperties;
 
@@ -18,7 +18,7 @@ type SlabProperties = pumpkin_data::block_properties::ResinBrickSlabLikeProperti
 pub struct SlabBlock;
 
 #[async_trait]
-impl PumpkinBlock for SlabBlock {
+impl BlockBehaviour for SlabBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         if let BlockIsReplacing::Itself(state_id) = args.replacing {
             let mut slab_props = SlabProperties::from_state_id(state_id, args.block);

pumpkin/src/block/blocks/smoker.rs

@@ -1,4 +1,4 @@
-use crate::block::pumpkin_block::{OnPlaceArgs, PumpkinBlock};
+use crate::block::{BlockBehaviour, OnPlaceArgs};
 use async_trait::async_trait;
 use pumpkin_data::block_properties::{BlockProperties, FurnaceLikeProperties};
 use pumpkin_macros::pumpkin_block;
@@ -8,7 +8,7 @@ use pumpkin_world::BlockStateId;
 pub struct SmokerBlock;
 
 #[async_trait]
-impl PumpkinBlock for SmokerBlock {
+impl BlockBehaviour for SmokerBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut props = FurnaceLikeProperties::default(args.block);
         props.facing = args

pumpkin/src/block/blocks/stairs.rs

@@ -12,9 +12,9 @@ use pumpkin_util::math::position::BlockPos;
 use pumpkin_world::BlockStateId;
 use pumpkin_world::world::BlockFlags;
 
-use crate::block::pumpkin_block::OnNeighborUpdateArgs;
+use crate::block::BlockBehaviour;
-use crate::block::pumpkin_block::OnPlaceArgs;
+use crate::block::OnNeighborUpdateArgs;
-use crate::block::pumpkin_block::PumpkinBlock;
+use crate::block::OnPlaceArgs;
 use crate::world::World;
 
 type StairsProperties = pumpkin_data::block_properties::OakStairsLikeProperties;
@@ -23,7 +23,7 @@ type StairsProperties = pumpkin_data::block_properties::OakStairsLikeProperties;
 pub struct StairBlock;
 
 #[async_trait]
-impl PumpkinBlock for StairBlock {
+impl BlockBehaviour for StairBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         let mut stair_props = StairsProperties::default(args.block);
         stair_props.waterlogged = args.replacing.water_source();

pumpkin/src/block/blocks/sugar_cane.rs

@@ -12,8 +12,8 @@ use pumpkin_world::BlockStateId;
 use pumpkin_world::tick::TickPriority;
 use pumpkin_world::world::{BlockAccessor, BlockFlags};
 
-use crate::block::pumpkin_block::{
+use crate::block::{
-    CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnScheduledTickArgs, PumpkinBlock,
+    BlockBehaviour, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnScheduledTickArgs,
     RandomTickArgs,
 };
 
@@ -21,7 +21,7 @@ use crate::block::pumpkin_block::{
 pub struct SugarCaneBlock;
 
 #[async_trait]
-impl PumpkinBlock for SugarCaneBlock {
+impl BlockBehaviour for SugarCaneBlock {
     async fn on_scheduled_tick(&self, args: OnScheduledTickArgs<'_>) {
         if !can_place_at(args.world.as_ref(), args.position).await {
             args.world

pumpkin/src/block/blocks/tnt.rs

@@ -1,10 +1,10 @@
 use pumpkin_data::item::Item;
 use std::sync::Arc;
 
-use crate::block::pumpkin_block::{
-    ExplodeArgs, OnNeighborUpdateArgs, PlacedArgs, PumpkinBlock, UseWithItemArgs,
-};
 use crate::block::registry::BlockActionResult;
+use crate::block::{
+    BlockBehaviour, ExplodeArgs, OnNeighborUpdateArgs, PlacedArgs, UseWithItemArgs,
+};
 use crate::entity::Entity;
 use crate::entity::tnt::TNTEntity;
 use crate::world::World;
@@ -52,7 +52,7 @@ const DEFAULT_FUSE: u32 = 80;
 const DEFAULT_POWER: f32 = 4.0;
 
 #[async_trait]
-impl PumpkinBlock for TNTBlock {
+impl BlockBehaviour for TNTBlock {
     async fn use_with_item(&self, args: UseWithItemArgs<'_>) -> BlockActionResult {
         let item = args.item_stack.lock().await.item;
         if item != &Item::FLINT_AND_STEEL || item == &Item::FIRE_CHARGE {

pumpkin/src/block/blocks/torches.rs

@@ -11,8 +11,8 @@ use pumpkin_world::world::BlockAccessor;
 type WallTorchProps = pumpkin_data::block_properties::WallTorchLikeProperties;
 // Normal tourches don't have properties
 
-use crate::block::pumpkin_block::{
+use crate::block::{
-    BlockMetadata, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs, PumpkinBlock,
+    BlockBehaviour, BlockMetadata, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, OnPlaceArgs,
 };
 
 pub struct TorchBlock;
@@ -33,7 +33,7 @@ impl BlockMetadata for TorchBlock {
 }
 
 #[async_trait]
-impl PumpkinBlock for TorchBlock {
+impl BlockBehaviour for TorchBlock {
     async fn on_place(&self, args: OnPlaceArgs<'_>) -> BlockStateId {
         if args.direction == BlockDirection::Down {
             let support_block = args.world.get_block_state(&args.position.down()).await;

pumpkin/src/block/blocks/trapdoor.rs

@@ -1,6 +1,6 @@
 use crate::block::blocks::redstone::block_receives_redstone_power;
-use crate::block::pumpkin_block::{NormalUseArgs, OnNeighborUpdateArgs, OnPlaceArgs, PumpkinBlock};
 use crate::block::registry::BlockActionResult;
+use crate::block::{BlockBehaviour, NormalUseArgs, OnNeighborUpdateArgs, OnPlaceArgs};
 use crate::entity::player::Player;
 use crate::world::World;
 use async_trait::async_trait;
@@ -70,7 +70,7 @@ fn get_sound(block: &Block, open: bool) -> Sound {
 pub struct TrapDoorBlock;
 
 #[async_trait]
-impl PumpkinBlock for TrapDoorBlock {
+impl BlockBehaviour for TrapDoorBlock {
     async fn normal_use(&self, args: NormalUseArgs<'_>) -> BlockActionResult {
         if !can_open_trapdoor(args.block) {
             return BlockActionResult::Pass;