Broadcast item in player's main hand

caelunshun · caelunshun · commit bdf76ecafabe · 2019-08-07T12:39:19.000-06:00
diff --git a/core/src/inventory.rs b/core/src/inventory.rs
@@ -22,6 +22,15 @@ pub const SLOT_OFFHAND: SlotIndex = 45;
 pub const SLOT_INVENTORY_OFFSET: SlotIndex = 9;
 pub const SLOT_HOTBAR_OFFSET: SlotIndex = 36;
 
+pub const HOTBAR_SIZE: SlotIndex = 9;
+
+pub const SLOT_ENTITY_EQUIPMENT_MAIN_HAND: SlotIndex = 0;
+pub const SLOT_ENTITY_EQUIPMENT_OFF_HAND: SlotIndex = 1;
+pub const SLOT_ENTITY_EQUIPMENT_BOOTS: SlotIndex = 2;
+pub const SLOT_ENTITY_EQUIPMENT_LEGGINGS: SlotIndex = 3;
+pub const SLOT_ENTITY_EQUIPMENT_CHESTPLATE: SlotIndex = 4;
+pub const SLOT_ENTITY_EQUIPMENT_HELMET: SlotIndex = 5;
+
 /// The various types of inventories ("windows").
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum InventoryType {
diff --git a/core/src/network/packet/implementation.rs b/core/src/network/packet/implementation.rs
@@ -1482,6 +1482,13 @@ pub struct EntityHeadLook {
     pub head_yaw: u8,
 }
 
+#[derive(Default, AsAny, new, Packet, Clone)]
+pub struct EntityEquipment {
+    pub entity_id: VarInt,
+    pub slot: VarInt,
+    pub item: Slot,
+}
+
 // TODO Select Advancement Tab
 // TODO World Border
 
diff --git a/core/src/network/packet/mod.rs b/core/src/network/packet/mod.rs
@@ -513,6 +513,11 @@ lazy_static! {
             PacketType::EntityHeadLook,
         );
 
+        m.insert(
+            PacketId(0x42, PacketDirection::Clientbound, PacketStage::Play),
+            PacketType::EntityEquipment,
+        );
+
         m.insert(
             PacketId(0x49, PacketDirection::Clientbound, PacketStage::Play),
             PacketType::SpawnPosition,
diff --git a/server/src/main.rs b/server/src/main.rs
@@ -256,6 +256,16 @@ fn init_world<'a, 'b>(
             "creative_inventory",
             &["network"],
         )
+        .with(
+            player::HeldItemChangeSystem,
+            "held_item_change",
+            &["network"],
+        )
+        .with(
+            player::HeldItemBroadcastSystem::default(),
+            "held_item_broadcast",
+            &["held_item_change", "creative_inventory"],
+        )
         .build();
 
     dispatcher.setup(&mut world);
diff --git a/server/src/player/broadcast.rs b/server/src/player/broadcast.rs
@@ -1,8 +1,12 @@
 use crate::entity::{EntityComponent, PlayerComponent};
 use crate::joinhandler::PlayerJoinEvent;
 use crate::network::{send_packet_to_player, NetworkComponent};
+use crate::player::InventoryComponent;
 use feather_core::entitymeta::{EntityMetadata, MetaEntry};
-use feather_core::network::packet::implementation::{PlayerInfo, PlayerInfoAction, SpawnPlayer};
+use feather_core::inventory::SLOT_ENTITY_EQUIPMENT_MAIN_HAND;
+use feather_core::network::packet::implementation::{
+    EntityEquipment, PlayerInfo, PlayerInfoAction, SpawnPlayer,
+};
 use feather_core::Gamemode;
 use shrev::EventChannel;
 use specs::SystemData;
@@ -29,11 +33,12 @@ impl<'a> System<'a> for JoinBroadcastSystem {
         ReadStorage<'a, EntityComponent>,
         ReadStorage<'a, PlayerComponent>,
         ReadStorage<'a, NetworkComponent>,
+        ReadStorage<'a, InventoryComponent>,
         Entities<'a>,
     );
 
     fn run(&mut self, data: Self::SystemData) {
-        let (join_events, entity_comps, player_comps, net_comps, entities) = data;
+        let (join_events, entity_comps, player_comps, net_comps, inventories, entities) = data;
 
         for event in join_events.read(&mut self.reader.as_mut().unwrap()) {
             // Broadcast join
@@ -56,14 +61,22 @@ impl<'a> System<'a> for JoinBroadcastSystem {
             let net_comp = net_comps.get(event.player).unwrap();
 
             // Send existing players to new player
-            for (entity_comp, player_comp, entity) in
-                (&entity_comps, &player_comps, &entities).join()
+            for (entity_comp, player_comp, entity, inventory) in
+                (&entity_comps, &player_comps, &entities, &inventories).join()
             {
                 if entity != event.player {
                     let (player_info, spawn_player) =
                         get_player_initialization_packets(entity_comp, player_comp, entity);
                     send_packet_to_player(net_comp, player_info);
                     send_packet_to_player(net_comp, spawn_player);
+
+                    let slot = inventory.item_at(inventory.held_item);
+                    let entity_equipment = EntityEquipment::new(
+                        entity.id() as i32,
+                        SLOT_ENTITY_EQUIPMENT_MAIN_HAND as i32,
+                        slot.cloned(),
+                    );
+                    send_packet_to_player(net_comp, entity_equipment);
                 }
             }
         }
diff --git a/server/src/player/inventory.rs b/server/src/player/inventory.rs
@@ -1,26 +1,35 @@
 use crate::disconnect_player;
 use crate::entity::PlayerComponent;
-use crate::network::PacketQueue;
-use feather_core::inventory::{Inventory, InventoryType};
+use crate::network::{send_packet_to_all_players, NetworkComponent, PacketQueue};
+use feather_core::inventory::{
+    Inventory, InventoryType, SlotIndex, HOTBAR_SIZE, SLOT_ENTITY_EQUIPMENT_MAIN_HAND,
+    SLOT_HOTBAR_OFFSET,
+};
 use feather_core::network::cast_packet;
-use feather_core::network::packet::implementation::CreativeInventoryAction;
+use feather_core::network::packet::implementation::{
+    CreativeInventoryAction, EntityEquipment, HeldItemChangeServerbound,
+};
 use feather_core::network::packet::PacketType;
 use feather_core::Gamemode;
+use shrev::EventChannel;
 use specs::storage::BTreeStorage;
-use specs::System;
-use specs::{Component, LazyUpdate, Read, ReadStorage, WriteStorage};
+use specs::SystemData;
+use specs::{Component, Entities, LazyUpdate, Read, ReadStorage, ReaderId, World, WriteStorage};
+use specs::{Entity, System, Write};
 use std::ops::{Deref, DerefMut};
 
 /// Component for storing a player's inventory.
 #[derive(Clone, Debug)]
 pub struct InventoryComponent {
     inventory: Inventory,
+    pub held_item: SlotIndex,
 }
 
 impl InventoryComponent {
     pub fn new() -> Self {
         Self {
             inventory: Inventory::new(InventoryType::Player, 46),
+            held_item: 0,
         }
     }
 }
@@ -49,19 +58,26 @@ impl Component for InventoryComponent {
     type Storage = BTreeStorage<Self>;
 }
 
+/// Event which is triggered when a player updates
+/// their held item.
+pub struct HeldItemUpdateEvent {
+    pub player: Entity,
+}
+
 /// System for handling Creative Inventory Action packets.
 pub struct CreativeInventorySystem;
 
 impl<'a> System<'a> for CreativeInventorySystem {
     type SystemData = (
         WriteStorage<'a, InventoryComponent>,
         ReadStorage<'a, PlayerComponent>,
+        Write<'a, EventChannel<HeldItemUpdateEvent>>,
         Read<'a, PacketQueue>,
         Read<'a, LazyUpdate>,
     );
 
     fn run(&mut self, data: Self::SystemData) {
-        let (mut inventories, players, packet_queue, lazy) = data;
+        let (mut inventories, players, mut events, packet_queue, lazy) = data;
 
         let packets = packet_queue.for_packet(PacketType::CreativeInventoryAction);
 
@@ -96,8 +112,91 @@ impl<'a> System<'a> for CreativeInventorySystem {
                     inventory.clear_item_at(packet.slot as usize);
                 }
             }
+
+            // If the updates slot was the player's held item,
+            // we need to broadcast the equipment update
+            if inventory.held_item == packet.slot as usize {
+                let event = HeldItemUpdateEvent { player };
+                events.single_write(event);
+            }
+        }
+    }
+}
+
+/// System for handling Held Item Change packets.
+pub struct HeldItemChangeSystem;
+
+impl<'a> System<'a> for HeldItemChangeSystem {
+    type SystemData = (
+        WriteStorage<'a, InventoryComponent>,
+        Write<'a, EventChannel<HeldItemUpdateEvent>>,
+        Read<'a, PacketQueue>,
+        Read<'a, LazyUpdate>,
+    );
+
+    fn run(&mut self, data: Self::SystemData) {
+        let (mut inventories, mut events, packet_queue, lazy) = data;
+
+        let packets = packet_queue.for_packet(PacketType::HeldItemChangeServerbound);
+
+        for (player, packet) in packets {
+            let packet = cast_packet::<HeldItemChangeServerbound>(&*packet);
+
+            if packet.slot as usize >= HOTBAR_SIZE {
+                disconnect_player(player, "Hotbar index out of bounds".to_string(), &lazy);
+                continue;
+            }
+
+            let inventory = inventories.get_mut(player).unwrap();
+            inventory.held_item = packet.slot as usize;
+
+            // Trigger event
+            let event = HeldItemUpdateEvent { player };
+            events.single_write(event);
+        }
+    }
+}
+
+/// System for broadcasting held item updates.
+#[derive(Default)]
+pub struct HeldItemBroadcastSystem {
+    reader: Option<ReaderId<HeldItemUpdateEvent>>,
+}
+
+impl<'a> System<'a> for HeldItemBroadcastSystem {
+    type SystemData = (
+        ReadStorage<'a, NetworkComponent>,
+        ReadStorage<'a, InventoryComponent>,
+        Read<'a, EventChannel<HeldItemUpdateEvent>>,
+        Entities<'a>,
+    );
+
+    fn run(&mut self, data: Self::SystemData) {
+        let (networks, inventories, events, entities) = data;
+
+        for event in events.read(&mut self.reader.as_mut().unwrap()) {
+            let inv = inventories.get(event.player).unwrap();
+            let item = inv.item_at(SLOT_HOTBAR_OFFSET + inv.held_item).cloned();
+
+            let packet = EntityEquipment::new(
+                event.player.id() as i32,
+                SLOT_ENTITY_EQUIPMENT_MAIN_HAND as i32,
+                item,
+            );
+
+            send_packet_to_all_players(&networks, &entities, packet, Some(event.player));
         }
     }
+
+    fn setup(&mut self, world: &mut World) {
+        Self::SystemData::setup(world);
+
+        self.reader = Some(
+            world
+                .fetch_mut::<EventChannel<HeldItemUpdateEvent>>()
+                .register_reader(),
+        );
+    }
 }
 
 #[cfg(test)]
@@ -118,6 +217,8 @@ mod tests {
 
         t::receive_packet(&player, &w, packet);
 
+        let mut event_reader = t::reader(&w);
+
         d.dispatch(&w);
         w.maintain();
 
@@ -127,6 +228,15 @@ mod tests {
         let inv = inv_storage.get(player.entity).unwrap();
         assert_eq!(inv.item_at(0).unwrap(), &ItemStack::new(Item::IronSword, 1));
 
+        // Confirm that event was triggered
+        {
+            let channel = w.fetch::<EventChannel<HeldItemUpdateEvent>>();
+            let events = channel.read(&mut event_reader).collect::<Vec<_>>();
+            assert_eq!(events.len(), 1);
+            let first = events.first().unwrap();
+            assert_eq!(first.player, player.entity);
+        }
+
         drop(inv_storage);
 
         let packet = CreativeInventoryAction::new(0, None);
@@ -172,4 +282,72 @@ mod tests {
 
         t::assert_disconnected(&player);
     }
+
+    #[test]
+    fn test_held_item_change_system() {
+        let (mut w, mut d) = t::init_world();
+
+        let player = t::add_player(&mut w);
+
+        let slot = 4;
+
+        let mut event_reader = t::reader(&w);
+
+        let packet = HeldItemChangeServerbound::new(slot);
+        t::receive_packet(&player, &w, packet);
+
+        d.dispatch(&w);
+        w.maintain();
+
+        let channel = w.fetch::<EventChannel<HeldItemUpdateEvent>>();
+        let events = channel.read(&mut event_reader).collect::<Vec<_>>();
+
+        assert_eq!(events.len(), 1);
+
+        let first = events.first().unwrap();
+        assert_eq!(first.player, player.entity);
+
+        let inventories = w.read_component::<InventoryComponent>();
+        let inv = inventories.get(player.entity).unwrap();
+
+        assert_eq!(inv.held_item, slot as usize);
+    }
+
+    #[test]
+    fn test_held_item_change_system_out_of_bounds() {
+        let (mut w, mut d) = t::init_world();
+
+        let player = t::add_player(&mut w);
+
+        let slot = 9;
+
+        let packet = HeldItemChangeServerbound::new(slot);
+        t::receive_packet(&player, &w, packet);
+
+        d.dispatch(&w);
+        w.maintain();
+
+        t::assert_disconnected(&player); // Slot out of bounds
+    }
+
+    #[test]
+    fn test_held_item_broadcast_system() {
+        let (mut w, mut d) = t::init_world();
+
+        let player = t::add_player(&mut w);
+        let player2 = t::add_player(&mut w);
+
+        let event = HeldItemUpdateEvent {
+            player: player.entity,
+        };
+
+        w.fetch_mut::<EventChannel<HeldItemUpdateEvent>>()
+            .single_write(event);
+
+        d.dispatch(&w);
+        w.maintain();
+
+        t::assert_packet_received(&player2, PacketType::EntityEquipment);
+        t::assert_packet_not_received(&player, PacketType::EntityEquipment);
+    }
 }
diff --git a/server/src/player/mod.rs b/server/src/player/mod.rs
@@ -27,4 +27,7 @@ pub use movement::{
 
 pub use animation::{AnimationBroadcastSystem, PlayerAnimationEvent, PlayerAnimationSystem};
 
-pub use inventory::{CreativeInventorySystem, InventoryComponent};
+pub use inventory::{
+    CreativeInventorySystem, HeldItemBroadcastSystem, HeldItemChangeSystem, HeldItemUpdateEvent,
+    InventoryComponent,
+};
