WIP

Breaking blocks in survival works 90% of the time
Instamine and creative mostly untested
Time to mine blocks off by 20% for unknown reasons
 Netherite tools are not included in `BlockKind::harvest_tools`
 nor in `BlockKind::dig_multipliers`

Author: koskja

feather/common/src/block_break.rs

@@ -1,28 +1,106 @@
 use base::{ItemStack, ValidBlockPosition};
 use ecs::{EntityBuilder, SysResult, SystemExecutor};
 use libcraft_items::EnchantmentKind;
-use quill_common::entity_init::EntityInit;
+use quill_common::{entities::Player, 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,
+#[derive(Clone)]
+pub enum BlockBreaker {
+    Active(ActiveBreaker),
+    Finished(FinishedBreaker),
+    Inactive,
 }
-impl ActiveBlockBreaker {
+impl BlockBreaker {
+    pub fn new(
+        world: &mut World,
+        block_pos: ValidBlockPosition,
+        equipped_item: Option<&ItemStack>,
+    ) -> Self {
+        ActiveBreaker::new(world, block_pos, equipped_item)
+            .map(Self::Active)
+            .unwrap_or(Self::Inactive)
+    }
+    pub fn destroy_change_event(&self) -> Option<DestroyStateChange> {
+        Some(DestroyStateChange(self.position()?, self.destroy_stage()))
+    }
+    pub fn position(&self) -> Option<ValidBlockPosition> {
+        match self {
+            BlockBreaker::Active(a) => Some(a.position),
+            BlockBreaker::Finished(f) => Some(f.position),
+            BlockBreaker::Inactive => None,
+        }
+    }
+    pub fn active(&self) -> Option<&ActiveBreaker> {
+        match self {
+            Self::Active(a) => Some(a),
+            _ => None,
+        }
+    }
+    pub fn finished(&self) -> Option<&FinishedBreaker> {
+        match self {
+            Self::Finished(f) => Some(f),
+            _ => None,
+        }
+    }
     pub fn tick(&mut self) -> (bool, bool) {
-        let before = self.destroy_stage();
-        self.ticks_remaining = self.ticks_remaining.saturating_sub(1);
-        let after = self.destroy_stage();
-        (self.ticks_remaining == 0, before != after)
+        let (block_break, stage_update) = if let Self::Active(breaker) = self {
+            breaker.tick()
+        } else {
+            (false, false)
+        };
+        if block_break {
+            let fin = match self {
+                Self::Active(a) => a.clone().finish(),
+                _ => unreachable!(),
+            };
+            *self = Self::Finished(fin);
+        }
+        (block_break, stage_update)
     }
-    pub fn break_block(self, game: &mut Game) -> SysResult {
+    pub fn destroy_stage(&self) -> u8 {
+        match self {
+            BlockBreaker::Active(a) => a.destroy_stage(),
+            _ => 10,
+        }
+    }
+    pub fn cancel(&mut self) {
+        *self = Self::Inactive;
+    }
+    pub fn matches_position(&self, pos: ValidBlockPosition) -> bool {
+        match self {
+            BlockBreaker::Active(a) => a.position == pos,
+            BlockBreaker::Finished(f) => f.position == pos,
+            BlockBreaker::Inactive => true,
+        }
+    }
+    pub fn try_finish(&mut self) -> Option<FinishedBreaker> {
+        let this = self.clone();
+        match this {
+            BlockBreaker::Active(a) => {
+                if a.ticks_remaining == 1 {
+                    let fin = a.finish();
+                    *self = Self::Finished(fin.clone());
+                    Some(fin)
+                } else {
+                    None
+                }
+            }
+            BlockBreaker::Finished(f) => Some(f),
+            BlockBreaker::Inactive => None,
+        }
+    }
+}
+#[derive(Clone)]
+pub struct FinishedBreaker {
+    pub position: ValidBlockPosition,
+    pub drop_item: bool,
+    pub fake_finished: bool,
+}
+impl FinishedBreaker {
+    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"),
@@ -39,16 +117,34 @@ impl ActiveBlockBreaker {
         }
         Ok(())
     }
-    pub fn new_player(
+}
+#[derive(Clone)]
+pub struct ActiveBreaker {
+    pub position: ValidBlockPosition,
+    pub drop_item: bool,
+    pub fake_finished: bool,
+    pub total_ticks: u32,
+    pub ticks_remaining: u32,
+}
+impl ActiveBreaker {
+    pub fn tick(&mut self) -> (bool, bool) {
+        let before = self.destroy_stage();
+        self.ticks_remaining = self.ticks_remaining.saturating_sub(1);
+        let after = self.destroy_stage();
+        let break_block = self.ticks_remaining == 0;
+        let change_stage = before != after || break_block;
+        (break_block, change_stage)
+    }
+    pub fn new(
         world: &mut World,
         block_pos: ValidBlockPosition,
-        main_hand: Option<&ItemStack>,
+        equipped_item: Option<&ItemStack>,
     ) -> Option<Self> {
         let block = world.block_at(block_pos)?.kind();
         if !block.diggable() {
             return None;
         }
-        let harvestable = match (block.harvest_tools(), main_hand) {
+        let harvestable = match (block.harvest_tools(), equipped_item) {
             (None, None | Some(_)) => true,
             (Some(_), None) => false,
             (Some(tools), Some(tool)) => tools.contains(&tool.item()),
@@ -57,7 +153,7 @@ impl ActiveBlockBreaker {
             .dig_multipliers()
             .iter()
             .find_map(|(item, speed)| {
-                main_hand
+                equipped_item
                     .map(|e| {
                         if e.item() == *item {
                             Some(*speed)
@@ -68,7 +164,7 @@ impl ActiveBlockBreaker {
                     .flatten()
             })
             .unwrap_or(1.0);
-        let effi_level = main_hand
+        let effi_level = equipped_item
             .map(ItemStack::metadata)
             .flatten()
             .map(|meta| {
@@ -90,17 +186,37 @@ impl ActiveBlockBreaker {
         let ticks = if damage > 1.0 {
             0
         } else {
-            (1.0 / damage).ceil() as u32 - 4
+            (1.0 / damage / 1.2).ceil() as u32
         };
+        println!(
+            "Mining {} with {} takes {} ticks",
+            block.display_name(),
+            equipped_item
+                .map(|e| e.get_item().item().display_name())
+                .unwrap_or("bare hands"),
+            ticks
+        );
         Some(Self {
             position: block_pos,
             drop_item: true,
+            fake_finished: false,
             total_ticks: ticks,
             ticks_remaining: ticks,
         })
     }
     pub fn destroy_stage(&self) -> u8 {
-        9 - (self.ticks_remaining as f32 / self.total_ticks as f32 * 9.0).round() as u8
+        if self.fake_finished {
+            10
+        } else {
+            9 - (self.ticks_remaining as f32 / self.total_ticks as f32 * 9.0).round() as u8
+        }
+    }
+    pub fn finish(self) -> FinishedBreaker {
+        FinishedBreaker {
+            position: self.position,
+            drop_item: self.drop_item,
+            fake_finished: self.fake_finished,
+        }
     }
 }
 
@@ -112,35 +228,28 @@ fn process_block_breaking(game: &mut Game) -> SysResult {
     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 {
-            let (break_block, update_stage) = active.tick();
-            if update_stage {
-                update_queue.push(entity);
-            }
-            if break_block {
+        let (break_block, update_stage) = breaker.tick();
+        if update_stage {
+            update_queue.push(entity);
+        }
+        // Break block when client requests to finish in order to prevent desyncs
+        if break_block {
+            if breaker.finished().unwrap().fake_finished || !game.ecs.get::<Player>(entity).is_ok()
+            {
                 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()),
-        )?;
+        let event = game
+            .ecs
+            .get_mut::<BlockBreaker>(entity)?
+            .destroy_change_event()
+            .unwrap();
+        game.ecs.insert_entity_event(entity, event)?;
     }
     for entity in break_queue.into_iter() {
-        // Set block breakers to None
-        let breaker = {
-            game.ecs
-                .get_mut::<BlockBreaker>(entity)
-                .unwrap()
-                .take()
-                .unwrap()
-        };
-        game.ecs
-            .insert_entity_event(entity, DestroyStateChange(breaker.position, 10))
-            .unwrap();
+        let breaker = game.ecs.get::<BlockBreaker>(entity)?.finished().unwrap().clone();
         breaker.break_block(game)?;
     }
     Ok(())

feather/server/src/packet_handlers/interaction.rs

@@ -1,7 +1,7 @@
 use crate::{ClientId, NetworkId, Server};
 use base::inventory::{SLOT_HOTBAR_OFFSET, SLOT_OFFHAND};
 use base::Gamemode;
-use common::block_break::{ActiveBlockBreaker, BlockBreaker, DestroyStateChange};
+use common::block_break::{ActiveBreaker, BlockBreaker, DestroyStateChange};
 use common::entities::player::HotbarSlot;
 use common::interactable::InteractableRegistry;
 use common::{Game, Window};
@@ -120,6 +120,7 @@ pub fn handle_player_digging(
     player: Entity,
 ) -> SysResult {
     log::trace!("Got player digging with status {:?}", packet.status);
+    let client = server.clients.get(*game.ecs.get(player)?).unwrap();
     match packet.status {
         PlayerDiggingStatus::StartDigging => {
             if matches!(
@@ -132,26 +133,32 @@ pub fn handle_player_digging(
                 let window = game.ecs.get::<Window>(player)?;
                 let hotbar_slot = game.ecs.get::<HotbarSlot>(player)?.get();
                 let main_hand = window.item(SLOT_HOTBAR_OFFSET + hotbar_slot)?;
-                let _ = breaker.insert(
-                    ActiveBlockBreaker::new_player(
-                        &mut game.world,
-                        packet.position,
-                        main_hand.item_stack(),
-                    )
-                    .unwrap(),
+                *breaker = BlockBreaker::Active(
+                    ActiveBreaker::new(&mut game.world, packet.position, main_hand.item_stack())
+                        .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::Started,
+                true,
+            );
             Ok(())
         }
         PlayerDiggingStatus::CancelDigging => {
-            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 success = {
+                let mut breaker = game.ecs.get_mut::<BlockBreaker>(player)?;
+                let a = breaker.matches_position(packet.position);
+                breaker.cancel();
+                a
+            };
+            game.ecs
+                .insert_entity_event(player, DestroyStateChange(packet.position, 10))?;
             let block = match game.block(packet.position) {
                 Some(s) => s,
                 None => return Ok(()),
@@ -160,13 +167,33 @@ pub fn handle_player_digging(
                 packet.position,
                 block,
                 protocol::packets::server::PlayerDiggingStatus::Cancelled,
-                false,
+                success,
             );
             Ok(())
         }
         PlayerDiggingStatus::FinishDigging => {
-            let success = game.ecs.get::<BlockBreaker>(player)?.is_some();
-            let client = server.clients.get(*game.ecs.get(player)?).unwrap();
+            let mut finished = None;
+            let success = {
+                let mut breaker = game.ecs.get_mut::<BlockBreaker>(player)?;
+                let success = if let Some(f) = breaker.try_finish() {
+                    finished = Some(f);
+                    breaker.cancel();
+                    true
+                } else {
+                    if let BlockBreaker::Active(a) = &mut *breaker {
+                        a.fake_finished = true;
+                        println!("{} ticks remaining", a.ticks_remaining);
+                    }
+                    false
+                };
+                success && breaker.matches_position(packet.position)
+            };
+            if success {
+                println!("confirm");
+                finished.unwrap().break_block(game)?;
+            }
+            game.ecs
+                .insert_entity_event(player, DestroyStateChange(packet.position, 10))?;
             let block = match game.block(packet.position) {
                 Some(s) => s,
                 None => return Ok(()),

feather/server/src/systems/player_join.rs

@@ -124,7 +124,7 @@ fn accept_new_player(game: &mut Game, server: &mut Server, client_id: ClientId)
                 .map(|data| data.animal.health)
                 .unwrap_or(20.0),
         ))
-        .add(BlockBreaker::None)
+        .add(BlockBreaker::Inactive)
         .add(abilities.walk_speed)
         .add(abilities.fly_speed)
         .add(abilities.is_flying)