Block breaking progress sent to client

Author: koskja

feather/common/src/block_break.rs

@@ -1,29 +1,35 @@
-use base::{ValidBlockPosition, ItemStack};
-use ecs::{SystemExecutor, SysResult, EntityBuilder};
+use base::{ItemStack, ValidBlockPosition};
+use ecs::{EntityBuilder, SysResult, SystemExecutor};
 use quill_common::entity_init::EntityInit;
 
+pub struct DestroyStateChange(pub ValidBlockPosition, pub u8);
+
 use crate::{Game, World};
 
 pub type BlockBreaker = Option<ActiveBlockBreaker>;
+#[derive(Clone, Copy)]
 pub struct ActiveBlockBreaker {
     pub position: ValidBlockPosition,
     pub drop_item: bool,
+    pub total_ticks: u32,
     pub ticks_remaining: u32,
 }
 impl ActiveBlockBreaker {
-    pub fn tick(&mut self) -> bool {
+    pub fn tick(&mut self) -> (bool, bool) {
+        let before = self.destroy_stage();
         self.ticks_remaining = self.ticks_remaining.saturating_sub(1);
-        self.ticks_remaining == 0
+        let after = self.destroy_stage();
+        (self.ticks_remaining == 0, before != after)
     }
     pub fn break_block(self, game: &mut Game) -> SysResult {
         let target_block = match game.block(self.position) {
             Some(b) => b,
-            None => anyhow::bail!("cannot break unloaded block")
+            None => anyhow::bail!("cannot break unloaded block"),
         };
         game.break_block(self.position);
         if let Some(_item_drop) = base::Item::from_name(target_block.kind().name()) {
             if !self.drop_item {
-                return Ok(())
+                return Ok(());
             }
             let mut item_entity = EntityBuilder::new();
             crate::entities::item::build_default(&mut item_entity);
@@ -32,35 +38,63 @@ impl ActiveBlockBreaker {
         }
         Ok(())
     }
-    pub fn new_player(_world: &mut World, block_pos: ValidBlockPosition, _mainhand: Option<&ItemStack>, _offhand: Option<&ItemStack>) -> Option<Self> {
+    pub fn new_player(
+        _world: &mut World,
+        block_pos: ValidBlockPosition,
+        _mainhand: Option<&ItemStack>,
+        _offhand: Option<&ItemStack>,
+    ) -> Option<Self> {
         // TODO
         Some(Self {
             position: block_pos,
             drop_item: true,
+            total_ticks: 20,
             ticks_remaining: 20,
         })
     }
+    pub fn destroy_stage(&self) -> u8 {
+        9 - (self.ticks_remaining as f32 / self.total_ticks as f32 * 9.0).round() as u8
+    }
 }
 
 pub fn register(systems: &mut SystemExecutor<Game>) {
     systems.add_system(process_block_breaking);
 }
 
 fn process_block_breaking(game: &mut Game) -> SysResult {
-    let  mut break_queue = vec![];
+    let mut break_queue = vec![];
+    let mut update_queue = vec![];
     for (entity, breaker) in game.ecs.query::<&mut BlockBreaker>().iter() {
         if let Some(active) = breaker {
-            if active.tick() {
+            let (break_block, update_stage) = active.tick();
+            if update_stage {
+                update_queue.push(entity);
+            }
+            if break_block {
                 break_queue.push(entity);
             }
         }
     }
+    for entity in update_queue {
+        let breaker = { game.ecs.get_mut::<BlockBreaker>(entity).unwrap().unwrap() };
+        game.ecs.insert_entity_event(
+            entity,
+            DestroyStateChange(breaker.position, breaker.destroy_stage()),
+        )?;
+    }
     for entity in break_queue.into_iter() {
         // Set block breakers to None
         let breaker = {
-            game.ecs.get_mut::<BlockBreaker>(entity)?.take().unwrap()
+            game.ecs
+                .get_mut::<BlockBreaker>(entity)
+                .unwrap()
+                .take()
+                .unwrap()
         };
+        game.ecs
+            .insert_entity_event(entity, DestroyStateChange(breaker.position, 10))
+            .unwrap();
         breaker.break_block(game)?;
     }
     Ok(())
-}
+}

feather/server/src/client.rs

@@ -20,7 +20,8 @@ use common::{
 use libcraft_items::InventorySlot;
 use packets::server::{Particle, SetSlot, SpawnLivingEntity, UpdateLight, WindowConfirmation};
 use protocol::packets::server::{
-    EntityPosition, EntityPositionAndRotation, EntityTeleport, HeldItemChange, PlayerAbilities, PlayerDiggingStatus, AcknowledgePlayerDigging, BlockBreakAnimation,
+    AcknowledgePlayerDigging, BlockBreakAnimation, EntityPosition, EntityPositionAndRotation,
+    EntityTeleport, HeldItemChange, PlayerAbilities, PlayerDiggingStatus,
 };
 use protocol::{
     packets::{
@@ -602,7 +603,13 @@ impl Client {
         self.send_packet(HeldItemChange { slot });
     }
 
-    pub fn acknowledge_player_digging(&self, position: ValidBlockPosition, block: BlockId, status: PlayerDiggingStatus, successful: bool) {
+    pub fn acknowledge_player_digging(
+        &self,
+        position: ValidBlockPosition,
+        block: BlockId,
+        status: PlayerDiggingStatus,
+        successful: bool,
+    ) {
         self.send_packet(AcknowledgePlayerDigging {
             position,
             block,
@@ -611,9 +618,14 @@ impl Client {
         })
     }
 
-    pub fn block_break_animation(&self, entity_id: i32, position: ValidBlockPosition, destroy_stage: u8) {
+    pub fn block_break_animation(
+        &self,
+        entity_id: u32,
+        position: ValidBlockPosition,
+        destroy_stage: u8,
+    ) {
         self.send_packet(BlockBreakAnimation {
-            entity_id,
+            entity_id: i32::from_le_bytes(entity_id.to_le_bytes()),
             position,
             destroy_stage,
         })

feather/server/src/packet_handlers/interaction.rs

@@ -1,7 +1,7 @@
 use crate::{ClientId, NetworkId, Server};
-use base::Gamemode;
 use base::inventory::{SLOT_HOTBAR_OFFSET, SLOT_OFFHAND};
-use common::block_break::{BlockBreaker, ActiveBlockBreaker};
+use base::Gamemode;
+use common::block_break::{ActiveBlockBreaker, BlockBreaker, DestroyStateChange};
 use common::entities::player::HotbarSlot;
 use common::interactable::InteractableRegistry;
 use common::{Game, Window};
@@ -122,31 +122,63 @@ pub fn handle_player_digging(
     log::trace!("Got player digging with status {:?}", packet.status);
     match packet.status {
         PlayerDiggingStatus::StartDigging => {
-            if matches!(*game.ecs.get::<Gamemode>(player)?, Gamemode::Creative | Gamemode::Spectator) {
+            if matches!(
+                *game.ecs.get::<Gamemode>(player)?,
+                Gamemode::Creative | Gamemode::Spectator
+            ) {
                 game.break_block(packet.position);
             } else {
                 let mut breaker = game.ecs.get_mut::<BlockBreaker>(player)?;
                 let window = game.ecs.get::<Window>(player)?;
                 let hotbar_slot = game.ecs.get::<HotbarSlot>(player)?.get();
                 let main = window.item(SLOT_HOTBAR_OFFSET + hotbar_slot)?;
                 let offh = window.item(SLOT_OFFHAND)?;
-                let _ = breaker.insert(ActiveBlockBreaker::new_player(&mut game.world, packet.position, main.item_stack(), offh.item_stack()).unwrap());
+                let _ = breaker.insert(
+                    ActiveBlockBreaker::new_player(
+                        &mut game.world,
+                        packet.position,
+                        main.item_stack(),
+                        offh.item_stack(),
+                    )
+                    .unwrap(),
+                );
             }
 
             Ok(())
-        },
+        }
         PlayerDiggingStatus::CancelDigging => {
-            game.ecs.get_mut::<BlockBreaker>(player)?.take();
+            let breaker = game.ecs.get_mut::<BlockBreaker>(player)?.take();
+            if let Some(s) = breaker {
+                game.ecs
+                    .insert_entity_event(player, DestroyStateChange(s.position, 10))?;
+            }
+
             let client = server.clients.get(*game.ecs.get(player)?).unwrap();
-            let block = match game.block(packet.position) { Some(s)=>s,None=>return Ok(())};
-            client.acknowledge_player_digging(packet.position, block, protocol::packets::server::PlayerDiggingStatus::Cancelled, false);
+            let block = match game.block(packet.position) {
+                Some(s) => s,
+                None => return Ok(()),
+            };
+            client.acknowledge_player_digging(
+                packet.position,
+                block,
+                protocol::packets::server::PlayerDiggingStatus::Cancelled,
+                false,
+            );
             Ok(())
-        },
+        }
         PlayerDiggingStatus::FinishDigging => {
             let success = game.ecs.get::<BlockBreaker>(player)?.is_some();
             let client = server.clients.get(*game.ecs.get(player)?).unwrap();
-            let block = match game.block(packet.position) { Some(s)=>s,None=>return Ok(())};
-            client.acknowledge_player_digging(packet.position, block, protocol::packets::server::PlayerDiggingStatus::Finished, success);
+            let block = match game.block(packet.position) {
+                Some(s) => s,
+                None => return Ok(()),
+            };
+            client.acknowledge_player_digging(
+                packet.position,
+                block,
+                protocol::packets::server::PlayerDiggingStatus::Finished,
+                success,
+            );
             Ok(())
         }
         PlayerDiggingStatus::SwapItemInHand => {
@@ -174,7 +206,6 @@ pub fn handle_player_digging(
         PlayerDiggingStatus::DropItemStack => Ok(()),
         PlayerDiggingStatus::DropItem => Ok(()),
         PlayerDiggingStatus::ShootArrow => Ok(()),
-        
     }
 }
 

feather/server/src/systems/block.rs

@@ -15,15 +15,25 @@
 
 use ahash::AHashMap;
 use base::{chunk::SECTION_VOLUME, position, ChunkPosition, CHUNK_WIDTH};
-use common::{events::BlockChangeEvent, Game};
+use common::{block_break::DestroyStateChange, events::BlockChangeEvent, Game};
 use ecs::{SysResult, SystemExecutor};
 
 use crate::Server;
 
 pub fn register(systems: &mut SystemExecutor<Game>) {
     systems
         .group::<Server>()
-        .add_system(broadcast_block_changes);
+        .add_system(broadcast_block_changes)
+        .add_system(broadcast_block_destroy_stage_change);
+}
+
+fn broadcast_block_destroy_stage_change(game: &mut Game, server: &mut Server) -> SysResult {
+    for (entity, event) in game.ecs.query::<&DestroyStateChange>().iter() {
+        server.broadcast_nearby_with(event.0.position(), |client| {
+            client.block_break_animation(entity.id(), event.0, event.1);
+        });
+    }
+    Ok(())
 }
 
 fn broadcast_block_changes(game: &mut Game, server: &mut Server) -> SysResult {