Block breaking speed calculation

Author: koskja

feather/common/src/block_break.rs

@@ -1,5 +1,6 @@
 use base::{ItemStack, ValidBlockPosition};
 use ecs::{EntityBuilder, SysResult, SystemExecutor};
+use libcraft_items::EnchantmentKind;
 use quill_common::entity_init::EntityInit;
 
 pub struct DestroyStateChange(pub ValidBlockPosition, pub u8);
@@ -39,17 +40,63 @@ impl ActiveBlockBreaker {
         Ok(())
     }
     pub fn new_player(
-        _world: &mut World,
+        world: &mut World,
         block_pos: ValidBlockPosition,
-        _mainhand: Option<&ItemStack>,
-        _offhand: Option<&ItemStack>,
+        main_hand: Option<&ItemStack>,
     ) -> Option<Self> {
-        // TODO
+        let block = world.block_at(block_pos)?.kind();
+        if !block.diggable() {
+            return None;
+        }
+        let harvestable = match (block.harvest_tools(), main_hand) {
+            (None, None | Some(_)) => true,
+            (Some(_), None) => false,
+            (Some(tools), Some(tool)) => tools.contains(&tool.item()),
+        };
+        let dig_multiplier = block
+            .dig_multipliers()
+            .iter()
+            .find_map(|(item, speed)| {
+                main_hand
+                    .map(|e| {
+                        if e.item() == *item {
+                            Some(*speed)
+                        } else {
+                            None
+                        }
+                    })
+                    .flatten()
+            })
+            .unwrap_or(1.0);
+        let effi_level = main_hand
+            .map(ItemStack::metadata)
+            .flatten()
+            .map(|meta| {
+                meta.enchantments().iter().find_map(|ench| {
+                    if ench.kind() == EnchantmentKind::Efficiency {
+                        Some(ench.level())
+                    } else {
+                        None
+                    }
+                })
+            })
+            .flatten();
+        let effi_speed = effi_level.map(|level| level * level + 1).unwrap_or(0) as f32;
+        let damage = if harvestable {
+            (dig_multiplier + effi_speed) / block.hardness() / 30.0
+        } else {
+            1.0 / block.hardness() / 100.0
+        };
+        let ticks = if damage > 1.0 {
+            0
+        } else {
+            (1.0 / damage).ceil() as u32 - 4
+        };
         Some(Self {
             position: block_pos,
             drop_item: true,
-            total_ticks: 20,
-            ticks_remaining: 20,
+            total_ticks: ticks,
+            ticks_remaining: ticks,
         })
     }
     pub fn destroy_stage(&self) -> u8 {

feather/server/src/packet_handlers/interaction.rs

@@ -131,14 +131,12 @@ pub fn handle_player_digging(
                 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 main_hand = window.item(SLOT_HOTBAR_OFFSET + hotbar_slot)?;
                 let _ = breaker.insert(
                     ActiveBlockBreaker::new_player(
                         &mut game.world,
                         packet.position,
-                        main.item_stack(),
-                        offh.item_stack(),
+                        main_hand.item_stack(),
                     )
                     .unwrap(),
                 );

libcraft/items/src/item_stack.rs

@@ -324,6 +324,10 @@ impl ItemStack {
     pub fn stack_size(&self) -> u32 {
         self.item.stack_size()
     }
+
+    pub fn metadata(&self) -> Option<&ItemStackMeta> {
+        self.meta.as_ref()
+    }
 }
 
 /// An error type that may be returned when performing
@@ -355,6 +359,12 @@ impl ItemStackMeta {
             enchantments: vec![],
         }
     }
+    pub fn enchantments(&self) -> &[Enchantment] {
+        &self.enchantments
+    }
+    pub fn enchantments_mut(&mut self) -> &mut Vec<Enchantment> {
+        &mut self.enchantments
+    }
 }
 
 pub struct ItemStackBuilder {