feat(world): load items in container (without components)

andybrwr · andybrwr · commit 88114ca87440 · 2024-11-29T07:04:59.000-05:00
diff --git a/assets/more_registries.json b/assets/more_registries.json
diff --git a/src/net/cache.rs b/src/net/cache.rs
@@ -91,15 +91,15 @@ impl WorldCache {
                     .map(|container| {
                         (
                             (container.x, container.y, container.z),
-                            Container(Vec::new()),
+                            Container::try_from(container).expect("Failed to convert container from block entity NBT"),
                         )
                     })
                     .collect::<Vec<((i32, i32, i32), Container)>>()
             })
             .flatten()
             .collect();
 
-        info!("Containers: {:?}", containers);
+        debug!("Containers: {:?}", containers);
 
         let encoded = chunks
             .par_iter()
diff --git a/src/net/io.rs b/src/net/io.rs
@@ -130,6 +130,7 @@ impl NetIo {
         encoder.append_packet(packet)?;
         let bytes = encoder.take();
         trace!("raw packet is {} bytes", bytes.len());
+        trace!("{:?}", bytes.to_vec());
         let mut writer = self.write_half.lock().await;
         Ok(writer.write_all(&bytes).await?)
     }
diff --git a/src/net/player.rs b/src/net/player.rs
@@ -38,14 +38,14 @@ use uuid::Uuid;
 
 use crate::{
     protocol::{
-        datatypes::{Bounded, VarInt},
+        datatypes::{Bounded, Slot, VarInt},
         packets::{
             login::*,
             play::{
                 ConfirmTeleportS, GameEvent, GameEventC, Gamemode, KeepAliveC, LoginPlayC,
                 OpenScreenC, PlayerInfoUpdateC, PlayerStatus, SetBorderCenterC, SetBorderSizeC,
-                SetCenterChunkC, SetPlayerPositionAndRotationS, SetPlayerPositionS,
-                SetTickingStateC, StepTicksC, SynchronisePositionC, UseItemOnS,
+                SetCenterChunkC, SetContainerContentC, SetPlayerPositionAndRotationS,
+                SetPlayerPositionS, SetTickingStateC, StepTicksC, SynchronisePositionC, UseItemOnS,
             },
         },
         Frame, Packet, PacketState,
@@ -76,7 +76,7 @@ pub struct Player {
 
     entity: RwLock<Entity>,
 
-    next_window_id: AtomicU8,
+    next_window_id: Mutex<u8>,
     window: RwLock<Option<Window>>,
 }
 
@@ -113,7 +113,7 @@ impl SharedPlayer {
 
             entity: RwLock::new(Entity::default()),
 
-            next_window_id: AtomicU8::new(0),
+            next_window_id: Mutex::new(1),
             window: RwLock::new(None),
         }))
     }
@@ -570,7 +570,15 @@ impl SharedPlayer {
         match server.get_container(x, y, z) {
             None => (),
             Some(container) => {
-                let id = self.0.next_window_id.fetch_add(1, Ordering::Relaxed);
+                let id = {
+                    let mut next_window_id = self.0.next_window_id.lock().await;
+                    let id = *next_window_id;
+                    *next_window_id = next_window_id.wrapping_add(1);
+                    if *next_window_id == 0 {
+                        *next_window_id = 1;
+                    }
+                    id
+                };
 
                 let window = Window {
                     id,
@@ -580,6 +588,17 @@ impl SharedPlayer {
 
                 self.0.io.tx(&OpenScreenC::from(&window)).await?;
 
+                self.0
+                    .io
+                    .tx(&SetContainerContentC {
+                        window_id: id,
+                        // FIXME: track this correctly
+                        state_id: 0,
+                        slot_data: container.0,
+                        carried_item: Slot::default(),
+                    })
+                    .await?;
+
                 {
                     let mut sw = self.0.window.write().await;
                     *sw = Some(window);
diff --git a/src/protocol/datatypes/slot.rs b/src/protocol/datatypes/slot.rs
@@ -17,5 +17,92 @@
  * <https://www.gnu.org/licenses/>.
  */
 
+use crate::{protocol::Encode, server::registries::REGISTRIES, world::Item};
+
+use super::VarInt;
+
+#[derive(Debug, Clone)]
+pub struct Slot {
+    item_count: i8,
+    item_id: Option<i32>,
+    components_to_add: Option<Vec<Component>>,
+    components_to_remove: Option<Vec<i32>>,
+}
+
 #[derive(Debug, Clone)]
-pub struct Slot;
+pub enum Component {}
+
+impl From<Item> for Slot {
+    fn from(value: Item) -> Self {
+        let item_id = REGISTRIES
+            .item
+            .entries
+            .get(&value.id)
+            .expect("Couldn't find registry entry for item")
+            .protocol_id;
+
+        debug!("item id for {}: {item_id}", value.id);
+
+        Self {
+            item_count: value.count as i8,
+            item_id: Some(item_id),
+            components_to_add: None,
+            components_to_remove: None,
+        }
+    }
+}
+
+impl Default for Slot {
+    fn default() -> Self {
+        Self {
+            item_count: 0,
+            item_id: None,
+            components_to_add: None,
+            components_to_remove: None,
+        }
+    }
+}
+
+impl Encode for Slot {
+    fn encode(&self, mut w: impl std::io::Write) -> color_eyre::eyre::Result<()> {
+        self.item_count.encode(&mut w)?;
+
+        if self.item_count == 0 {
+            return Ok(());
+        }
+
+        if let Some(item_id) = self.item_id {
+            VarInt(item_id).encode(&mut w)?;
+
+            VarInt(
+                self.components_to_add
+                    .as_ref()
+                    .map(|v| v.len())
+                    .unwrap_or(0) as i32,
+            )
+            .encode(&mut w)?;
+
+            VarInt(
+                self.components_to_remove
+                    .as_ref()
+                    .map(|v| v.len())
+                    .unwrap_or(0) as i32,
+            )
+            .encode(&mut w)?;
+
+            if let Some(ref components_to_add) = self.components_to_add {
+                for _component in components_to_add {
+                    unimplemented!("Encoding components is not implemented");
+                }
+            }
+
+            if let Some(ref components_to_remove) = self.components_to_remove {
+                for _component in components_to_remove {
+                    unimplemented!("Encoding components is not implemented");
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/protocol/packets/play/container.rs b/src/protocol/packets/play/container.rs
@@ -19,7 +19,7 @@
 
 use crate::{
     protocol::{
-        datatypes::{TextComponent, VarInt},
+        datatypes::{Slot, TextComponent, VarInt},
         Encode, Packet,
     },
     server::window::{Window, WindowType},
@@ -56,3 +56,31 @@ impl From<&Window> for OpenScreenC {
         }
     }
 }
+
+#[derive(Debug)]
+pub struct SetContainerContentC {
+    pub window_id: u8,
+    pub state_id: i32,
+    pub slot_data: Vec<Slot>,
+    pub carried_item: Slot,
+}
+
+impl Packet for SetContainerContentC {
+    const ID: i32 = 0x13;
+}
+
+impl Encode for SetContainerContentC {
+    fn encode(&self, mut w: impl std::io::Write) -> color_eyre::eyre::Result<()> {
+        self.window_id.encode(&mut w)?;
+        VarInt(self.state_id).encode(&mut w)?;
+        VarInt(self.slot_data.len() as i32).encode(&mut w)?;
+
+        for slot in &self.slot_data {
+            slot.encode(&mut w)?;
+        }
+
+        self.carried_item.encode(&mut w)?;
+
+        Ok(())
+    }
+}
diff --git a/src/server/mod.rs b/src/server/mod.rs
@@ -17,6 +17,7 @@
  * <https://www.gnu.org/licenses/>.
  */
 
+pub mod registries;
 pub mod ticker;
 pub mod window;
 
diff --git a/src/server/registries.rs b/src/server/registries.rs
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2024 Andrew Brower.
+ * This file is part of Crawlspace.
+ *
+ * Crawlspace is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * Crawlspace is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License along with Crawlspace. If not, see
+ * <https://www.gnu.org/licenses/>.
+ */
+
+use std::{collections::HashMap, sync::LazyLock};
+
+use serde::Deserialize;
+
+pub static REGISTRIES: LazyLock<Registries> = LazyLock::new(|| {
+    serde_json::from_str(include_str!("../../assets/more_registries.json"))
+        .expect("more_registries.json should be parseable")
+});
+
+#[derive(Deserialize)]
+pub struct Registries {
+    #[serde(rename = "minecraft:item")]
+    pub item: ItemRegistry,
+}
+
+#[derive(Deserialize)]
+pub struct ItemRegistry {
+    pub default: String,
+    pub protocol_id: i32,
+    pub entries: HashMap<String, ItemRegistryEntry>,
+}
+
+#[derive(Deserialize)]
+pub struct ItemRegistryEntry {
+    pub protocol_id: i32,
+}
diff --git a/src/world/block_entity.rs b/src/world/block_entity.rs
@@ -19,6 +19,7 @@
 
 use color_eyre::eyre::{bail, Result};
 use fastnbt::Value;
+use serde::Deserialize;
 
 macro_rules! get_tag {
     ($data:expr, $tag_kind:path, $tag_name:literal) => {{
@@ -73,4 +74,32 @@ impl BlockEntity {
             raw_data,
         })
     }
+
+    pub fn try_get_items(&self) -> Result<Vec<Item>> {
+        match self.id.as_str() {
+            "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => {
+                let Value::Compound(ref data) = self.raw_data else {
+                    bail!(
+                        "try_get_items was called with raw_data that is not a compound: {:?}",
+                        self.raw_data
+                    );
+                };
+
+                let items = get_tag!(data, Value::List, "Items");
+                Ok(items
+                    .iter()
+                    .map(|i| fastnbt::from_value::<Item>(i).expect("Failed to parse item"))
+                    .collect())
+            }
+            id => bail!("try_get_items called on not a container ({id})"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Item {
+    #[serde(rename = "Slot")]
+    pub slot: i8,
+    pub id: String,
+    pub count: i32,
 }
diff --git a/src/world/container.rs b/src/world/container.rs
@@ -19,5 +19,39 @@
 
 use crate::protocol::datatypes::Slot;
 
+use super::BlockEntity;
+
 #[derive(Debug, Clone)]
 pub struct Container(pub Vec<Slot>);
+
+#[derive(Debug, thiserror::Error)]
+pub enum ContainerCreationError {
+    #[error("Block entity is not a container")]
+    NotAContainer,
+    #[error("Parse error: {0}")]
+    ParseError(color_eyre::eyre::Report),
+}
+
+impl TryFrom<BlockEntity> for Container {
+    type Error = ContainerCreationError;
+
+    fn try_from(value: BlockEntity) -> Result<Self, Self::Error> {
+        match value.id.as_str() {
+            "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => {
+                let items = value
+                    .try_get_items()
+                    .map_err(|e| ContainerCreationError::ParseError(e))?;
+
+                let mut slots = vec![Slot::default(); 27];
+
+                for item in items {
+                    let slot_index = item.slot as usize;
+                    slots[slot_index] = Slot::from(item);
+                }
+
+                Ok(Self(slots))
+            }
+            _ => Err(ContainerCreationError::NotAContainer),
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -130,6 +130,7 @@ impl NetIo {`
`130`	`130`	`encoder.append_packet(packet)?;`
`131`	`131`	`let bytes = encoder.take();`
`132`	`132`	`trace!("raw packet is {} bytes", bytes.len());`
	`133`	`+ trace!("{:?}", bytes.to_vec());`
`133`	`134`	`let mut writer = self.write_half.lock().await;`
`134`	`135`	`Ok(writer.write_all(&bytes).await?)`
`135`	`136`	`}`