Correct Interactive Block Behavior

pumpkin-core/src/math/position.rs

@@ -5,7 +5,7 @@ use crate::math::vector2::Vector2;
 use num_traits::Euclid;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 /// Aka Block Position
 pub struct WorldPosition(pub Vector3<i32>);
 

pumpkin-inventory/src/lib.rs

@@ -94,6 +94,13 @@ pub trait Container: Sync + Send {
 
     fn all_slots_ref(&self) -> Vec<Option<&ItemStack>>;
 
+    fn clear_all_slots(&mut self) {
+        let all_slots = self.all_slots();
+        for stack in all_slots {
+            *stack = None;
+        }
+    }
+
     fn all_combinable_slots(&self) -> Vec<Option<&ItemStack>> {
         self.all_slots_ref()
     }

pumpkin-inventory/src/open_container.rs

@@ -5,8 +5,10 @@ use pumpkin_world::block::block_registry::Block;
 use pumpkin_world::item::ItemStack;
 use std::sync::Arc;
 use tokio::sync::Mutex;
+
 pub struct OpenContainer {
     // TODO: unique id should be here
+    // TODO: should this be uuid?
     players: Vec<i32>,
     container: Arc<Mutex<Box<dyn Container>>>,
     location: Option<WorldPosition>,
@@ -54,6 +56,18 @@ impl OpenContainer {
         }
     }
 
+    pub fn is_location(&self, try_position: WorldPosition) -> bool {
+        if let Some(location) = self.location {
+            location == try_position
+        } else {
+            false
+        }
+    }
+
+    pub async fn clear_all_slots(&self) {
+        self.container.lock().await.clear_all_slots();
+    }
+
     pub fn all_player_ids(&self) -> Vec<i32> {
         self.players.clone()
     }

pumpkin/src/block/block_manager.rs

@@ -2,6 +2,7 @@ use crate::block::pumpkin_block::{BlockMetadata, PumpkinBlock};
 use crate::entity::player::Player;
 use crate::server::Server;
 use pumpkin_core::math::position::WorldPosition;
+use pumpkin_inventory::OpenContainer;
 use pumpkin_world::block::block_registry::Block;
 use pumpkin_world::item::item_registry::Item;
 use std::collections::HashMap;
@@ -34,7 +35,7 @@ impl BlockManager {
     ) {
         let pumpkin_block = self.get_pumpkin_block(block);
         if let Some(pumpkin_block) = pumpkin_block {
-            pumpkin_block.on_use(player, location, server).await;
+            pumpkin_block.on_use(block, player, location, server).await;
         }
     }
 
@@ -49,7 +50,7 @@ impl BlockManager {
         let pumpkin_block = self.get_pumpkin_block(block);
         if let Some(pumpkin_block) = pumpkin_block {
             return pumpkin_block
-                .on_use_with_item(player, location, item, server)
+                .on_use_with_item(block, player, location, item, server)
                 .await;
         }
         BlockActionResult::Continue
@@ -64,7 +65,9 @@ impl BlockManager {
     ) {
         let pumpkin_block = self.get_pumpkin_block(block);
         if let Some(pumpkin_block) = pumpkin_block {
-            pumpkin_block.on_placed(player, location, server).await;
+            pumpkin_block
+                .on_placed(block, player, location, server)
+                .await;
         }
     }
 
@@ -77,7 +80,9 @@ impl BlockManager {
     ) {
         let pumpkin_block = self.get_pumpkin_block(block);
         if let Some(pumpkin_block) = pumpkin_block {
-            pumpkin_block.on_broken(player, location, server).await;
+            pumpkin_block
+                .on_broken(block, player, location, server)
+                .await;
         }
     }
 
@@ -87,10 +92,13 @@ impl BlockManager {
         player: &Player,
         location: WorldPosition,
         server: &Server,
+        container: &mut OpenContainer,
     ) {
         let pumpkin_block = self.get_pumpkin_block(block);
         if let Some(pumpkin_block) = pumpkin_block {
-            pumpkin_block.on_close(player, location, server).await;
+            pumpkin_block
+                .on_close(block, player, location, server, container)
+                .await;
         }
     }
 

pumpkin/src/block/blocks/chest.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use pumpkin_core::math::position::WorldPosition;
 use pumpkin_inventory::{Chest, OpenContainer, WindowType};
 use pumpkin_macros::{pumpkin_block, sound};
-use pumpkin_world::{block::block_registry::get_block, item::item_registry::Item};
+use pumpkin_world::{block::block_registry::Block, item::item_registry::Item};
 
 use crate::{
     block::{block_manager::BlockActionResult, pumpkin_block::PumpkinBlock},
@@ -15,8 +15,15 @@ pub struct ChestBlock;
 
 #[async_trait]
 impl PumpkinBlock for ChestBlock {
-    async fn on_use<'a>(&self, player: &Player, _location: WorldPosition, server: &Server) {
-        self.open_chest_block(player, _location, server).await;
+    async fn on_use<'a>(
+        &self,
+        block: &Block,
+        player: &Player,
+        _location: WorldPosition,
+        server: &Server,
+    ) {
+        self.open_chest_block(block, player, _location, server)
+            .await;
         player
             .world()
             .play_block_sound(sound!("block.chest.open"), _location)
@@ -25,46 +32,60 @@ impl PumpkinBlock for ChestBlock {
 
     async fn on_use_with_item<'a>(
         &self,
+        block: &Block,
         player: &Player,
         _location: WorldPosition,
         _item: &Item,
         server: &Server,
     ) -> BlockActionResult {
-        self.open_chest_block(player, _location, server).await;
+        self.open_chest_block(block, player, _location, server)
+            .await;
         BlockActionResult::Consume
     }
 
-    async fn on_close<'a>(&self, player: &Player, _location: WorldPosition, _server: &Server) {
+    async fn on_broken<'a>(
+        &self,
+        block: &Block,
+        player: &Player,
+        location: WorldPosition,
+        server: &Server,
+    ) {
+        super::standard_on_destroy_with_container(block, player, location, server).await;
+    }
+
+    async fn on_close<'a>(
+        &self,
+        _block: &Block,
+        player: &Player,
+        _location: WorldPosition,
+        _server: &Server,
+        _container: &OpenContainer,
+    ) {
         player
             .world()
             .play_block_sound(sound!("block.chest.close"), _location)
             .await;
+        // TODO: send entity updates close
     }
 }
 
 impl ChestBlock {
     pub async fn open_chest_block(
         &self,
+        block: &Block,
         player: &Player,
         location: WorldPosition,
         server: &Server,
     ) {
-        let entity_id = player.entity_id();
-        // TODO: This should be a unique identifier for the each block container
-        player.open_container.store(Some(2));
-        {
-            let mut open_containers = server.open_containers.write().await;
-            if let Some(chest) = open_containers.get_mut(&2) {
-                chest.add_player(entity_id);
-            } else {
-                let open_container = OpenContainer::new_empty_container::<Chest>(
-                    entity_id,
-                    Some(location),
-                    get_block("minecraft:chest").cloned(),
-                );
-                open_containers.insert(2, open_container);
-            }
-        }
-        player.open_container(server, WindowType::Generic9x3).await;
+        // TODO: shouldn't Chest and window type be constrained together to avoid errors?
+        super::standard_open_container::<Chest>(
+            block,
+            player,
+            location,
+            server,
+            WindowType::Generic9x3,
+        )
+        .await;
+        // TODO: send entity updates open
     }
 }

pumpkin/src/block/blocks/crafting_table.rs

@@ -6,52 +6,112 @@ use async_trait::async_trait;
 use pumpkin_core::math::position::WorldPosition;
 use pumpkin_inventory::{CraftingTable, OpenContainer, WindowType};
 use pumpkin_macros::pumpkin_block;
-use pumpkin_world::{block::block_registry::get_block, item::item_registry::Item};
+use pumpkin_world::{block::block_registry::Block, item::item_registry::Item};
 
 #[pumpkin_block("minecraft:crafting_table")]
 pub struct CraftingTableBlock;
 
 #[async_trait]
 impl PumpkinBlock for CraftingTableBlock {
-    async fn on_use<'a>(&self, player: &Player, _location: WorldPosition, server: &Server) {
-        self.open_crafting_screen(player, _location, server).await;
+    async fn on_use<'a>(
+        &self,
+        block: &Block,
+        player: &Player,
+        _location: WorldPosition,
+        server: &Server,
+    ) {
+        self.open_crafting_screen(block, player, _location, server)
+            .await;
     }
 
     async fn on_use_with_item<'a>(
         &self,
+        block: &Block,
         player: &Player,
         _location: WorldPosition,
         _item: &Item,
         server: &Server,
     ) -> BlockActionResult {
-        self.open_crafting_screen(player, _location, server).await;
+        self.open_crafting_screen(block, player, _location, server)
+            .await;
         BlockActionResult::Consume
     }
+
+    async fn on_broken<'a>(
+        &self,
+        block: &Block,
+        player: &Player,
+        location: WorldPosition,
+        server: &Server,
+    ) {
+        super::standard_on_destroy_with_container(block, player, location, server).await;
+    }
+
+    async fn on_close<'a>(
+        &self,
+        _block: &Block,
+        player: &Player,
+        _location: WorldPosition,
+        _server: &Server,
+        container: &OpenContainer,
+    ) {
+        let entity_id = player.entity_id();
+
+        for player_id in container.all_player_ids() {
+            if entity_id == player_id {
+                container.clear_all_slots().await;
+            }
+        }
+
+        // TODO: should re-add all items to player or drop?
+    }
 }
 
 impl CraftingTableBlock {
     pub async fn open_crafting_screen(
         &self,
+        block: &Block,
         player: &Player,
         location: WorldPosition,
         server: &Server,
     ) {
         //TODO: Adjust /craft command to real crafting table
         let entity_id = player.entity_id();
-        player.open_container.store(Some(1));
-        {
-            let mut open_containers = server.open_containers.write().await;
-            if let Some(ender_chest) = open_containers.get_mut(&1) {
+        let mut open_containers = server.open_containers.write().await;
+        let mut id_to_use = -1;
+
+        for (id, container) in open_containers.iter() {
+            if let Some(a_block) = container.get_block() {
+                if a_block.id == block.id && container.all_player_ids().is_empty() {
+                    id_to_use = *id as i64;
+                }
+            }
+        }
+
+        if id_to_use == -1 {
+            let new_id = server.new_container_id();
+
+            log::info!("New ct ID: {}", new_id);
+
+            let open_container = OpenContainer::new_empty_container::<CraftingTable>(
+                entity_id,
+                Some(location),
+                Some(block.clone()),
+            );
+
+            open_containers.insert(new_id.into(), open_container);
+
+            player.open_container.store(Some(new_id.into()));
+        } else {
+            log::info!("Using previous ct ID: {}", id_to_use);
+            if let Some(ender_chest) = open_containers.get_mut(&(id_to_use as u64)) {
                 ender_chest.add_player(entity_id);
-            } else {
-                let open_container = OpenContainer::new_empty_container::<CraftingTable>(
-                    entity_id,
-                    Some(location),
-                    get_block("minecraft:crafting_table").cloned(),
-                );
-                open_containers.insert(1, open_container);
+                player
+                    .open_container
+                    .store(Some(id_to_use.try_into().unwrap()));
             }
         }
+        drop(open_containers);
         player
             .open_container(server, WindowType::CraftingTable)
             .await;