hotbar syncing

Author: cyteon

build.rs

@@ -7,6 +7,7 @@ fn main() {
     load_packets();
     load_blocks();
     load_items();
+    load_item_to_block();
 }
 
 fn load_packets() {
@@ -126,4 +127,48 @@ fn load_items() {
 
     let out_path = Path::new(&env::var("OUT_DIR").unwrap()).join("items.rs");
     fs::write(out_path, out).unwrap();
+}
+
+fn load_item_to_block() {
+    let manifest = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let blocks_json_path = Path::new(&manifest).join("src/assets/blocks.json");
+    let items_json_path = Path::new(&manifest).join("src/assets/items.json");
+
+    let block_bytes = fs::read(&blocks_json_path).expect("Failed to read blocks.json");
+    let item_bytes = fs::read(&items_json_path).expect("Failed to read items.json");
+
+    let blocks: HashMap<String, serde_json::Value> =
+        serde_json::from_slice(&block_bytes).expect("Failed to parse blocks.json");
+    let items: HashMap<String, serde_json::Value> =
+        serde_json::from_slice(&item_bytes).expect("Failed to parse items.json");
+    
+    let mut out = String::new();
+    out.push_str("pub fn item_to_block(item_id: i32) -> Option<u16> {\n");
+    out.push_str("    match item_id {\n");
+
+    for (ik, iv) in items["entries"].as_object().unwrap() {
+        if let Some(block) = blocks.get(ik) {
+            let default_state = block["states"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|state| state["default"].as_bool().unwrap_or(false))
+                .expect("Block is missing a default state");
+
+            out.push_str(
+                &format!(
+                    "        {} => Some({}),\n",
+                    iv["protocol_id"].as_u64().unwrap(),
+                    default_state["id"].as_u64().unwrap()
+                )
+            );
+        }
+    }
+
+    out.push_str("        _ => None,\n");
+    out.push_str("    }\n");
+    out.push_str("}\n");
+
+    let out_path = Path::new(&env::var("OUT_DIR").unwrap()).join("item_to_block.rs");
+    fs::write(out_path, out).unwrap();
 }

src/net/packet.rs

@@ -23,6 +23,7 @@ pub enum ClientPacket {
     ChatCommand(std::io::Cursor<Vec<u8>>), // 0x06 in play
     ChatMessage(std::io::Cursor<Vec<u8>>), // 0x08 in play
     PlayerAction(std::io::Cursor<Vec<u8>>), // 0x28 in play
+    SetCarriedItem(std::io::Cursor<Vec<u8>>), // 0x34 in play
     UseItemOn(std::io::Cursor<Vec<u8>>), // 0x3F in play
     SetPlayerPositionAndRotation(std::io::Cursor<Vec<u8>>), // 0x1E in play
     PlayerInput(std::io::Cursor<Vec<u8>>), // 0x2A in play
@@ -159,6 +160,10 @@ pub async fn read_packet<R: AsyncReadExt + Unpin>(stream: &mut R, state: &Protoc
                 play::serverbound::MOVE_PLAYER_ROT => {
                     Ok(Some(ClientPacket::SetPlayerRotation(cursor)))
                 },
+
+                play::serverbound::SET_CARRIED_ITEM => {
+                    Ok(Some(ClientPacket::SetCarriedItem(cursor)))
+                },
 
                 _ => Ok(None)
             }

src/net/packets/serverbound/mod.rs

@@ -10,4 +10,5 @@ pub mod chat_message;
 pub mod set_player_position_and_rotation;
 pub mod player_input;
 pub mod set_player_rotation;
-pub mod chat_command;
+pub mod chat_command;
+pub mod set_carried_item;

src/net/packets/serverbound/player_input.rs

@@ -1,8 +1,7 @@
 use tokio::io::AsyncReadExt;
 use crate::types::player::Player;
 
-pub async fn read_player_input
-<R: AsyncReadExt + Unpin>(
+pub async fn read_player_input<R: AsyncReadExt + Unpin>(
     stream: &mut R, player: &mut Player
 ) -> anyhow::Result<()> {
     let flags = stream.read_u8().await?;

src/net/packets/serverbound/set_carried_item.rs

@@ -0,0 +1,11 @@
+use tokio::io::AsyncReadExt;
+use crate::types::player::Player;
+
+pub async fn read_set_carried_item<R: AsyncReadExt + Unpin>(
+    stream: &mut R, player: &mut Player
+) -> anyhow::Result<()> {
+    let slot = stream.read_i16().await?;
+    player.current_slot = slot;
+
+    Ok(())
+}

src/net/packets/serverbound/use_item_on.rs

@@ -2,7 +2,7 @@ use tokio::io::AsyncReadExt;
 
 use crate::{net::codec::{read_position, read_var}, types::player::Player, world::get_region};
 
-pub async fn read_use_item_on<R: AsyncReadExt + Unpin>(stream: &mut R, _player: &mut Player) -> anyhow::Result<()> {
+pub async fn read_use_item_on<R: AsyncReadExt + Unpin>(stream: &mut R, player: &mut Player) -> anyhow::Result<()> {
     let _hand = read_var(stream).await?;
     let (x, y, z) = read_position(stream).await?;
 
@@ -28,8 +28,15 @@ pub async fn read_use_item_on<R: AsyncReadExt + Unpin>(stream: &mut R, _player:
         _ => {}
     }
 
-    // todo: replace stone placeholder
-    let block_id = crate::types::blocks::STONE;
+    let block_id = if let Some(Some(item_stack)) = player.inventory.get(player.current_slot as usize + 36) {
+        if let Some(block_id) = crate::types::items::item_to_block(item_stack.item_id) {
+            block_id
+        } else {
+            return Ok(());
+        }
+    } else {
+        return Ok(());
+    };
 
     let chunk_pos = (bx.div_euclid(16), bz.div_euclid(16));
     let region_pos = (chunk_pos.0.div_euclid(32), chunk_pos.1.div_euclid(32));
@@ -41,7 +48,7 @@ pub async fn read_use_item_on<R: AsyncReadExt + Unpin>(stream: &mut R, _player:
 
     if let Some(chunk) = region_lock.chunks.iter_mut().find(|chunk| chunk.x == chunk_pos.0 && chunk.z == chunk_pos.1) {
         if let Some(section) = chunk.sections.iter_mut().find(|section| section.y == section_y) {
-            section.set_block((bx & 15) as u8, (by & 15) as u8, (bz & 15) as u8, block_id);
+            section.set_block((bx & 15) as u8, (by & 15) as u8, (bz & 15) as u8, block_id as u16);
         }
     }
 

src/server/state/play.rs

@@ -35,7 +35,8 @@ use crate::{
                 set_player_position_and_rotation::read_set_player_position_and_rotation,
                 set_player_rotation::read_set_player_rotation,
                 use_item_on::read_use_item_on,
-                chat_command::read_chat_command
+                chat_command::read_chat_command,
+                set_carried_item::read_set_carried_item
             }
         }
     }, 
@@ -384,6 +385,13 @@ pub async fn play(socket: EncryptedStream<TcpStream>, player: Player) -> anyhow:
                         read_set_player_rotation(&mut cursor, &mut player).await?;
                     }
 
+                    ClientPacket::SetCarriedItem(mut cursor) => {
+                        let players_locked = PLAYERS.read().await;
+                        let mut player = players_locked.get(&uuid).unwrap().lock().await;
+
+                        read_set_carried_item(&mut cursor, &mut player).await?;
+                    }
+
                     _ => { }
                 }
             },

src/types/items.rs

@@ -3,4 +3,6 @@ pub use items::*;
 #[allow(unused)]
 mod items {
     include!(concat!(env!("OUT_DIR"), "/items.rs"));
-}
+}
+
+include!(concat!(env!("OUT_DIR"), "/item_to_block.rs"));

src/types/player.rs

@@ -31,6 +31,7 @@ pub struct Player {
     pub uuid: String,
     pub username: String,
     pub inventory: [Option<ItemStack>; 45],
+    pub current_slot: i16,
 
     pub shared_secret: Option<Vec<u8>>,
     pub textures: Option<String>,
@@ -64,6 +65,7 @@ impl Player {
             uuid,
             username: username.clone(),
             inventory: [None; 45],
+            current_slot: 0,
 
             shared_secret: None,
             textures: None,