Fix mining animation

Greatly simplify code
Add an ad hoc gamemode changing system

Author: koskja

feather/common/src/block_break.rs

@@ -1,150 +1,74 @@
-use std::mem;
-
-use base::{BlockKind, ItemStack, ValidBlockPosition};
-use ecs::{EntityBuilder, SysResult, SystemExecutor};
+use anyhow::Context;
+use base::{inventory::SLOT_HOTBAR_OFFSET, BlockKind, ItemStack, ValidBlockPosition};
+use ecs::{Entity, SysResult, SystemExecutor};
 use libcraft_items::EnchantmentKind;
-use quill_common::{entities::Player, entity_init::EntityInit};
+use quill_common::components::Instabreak;
 
 pub struct DestroyStateChange(pub ValidBlockPosition, pub u8);
 
-use crate::{Game, World};
+use crate::{entities::player::HotbarSlot, Game, Window, World};
 
 // Comparing to 0.7 ensures good feeling in the client
 pub const BREAK_THRESHOLD: f32 = 0.7;
 
-#[derive(Clone)]
-pub enum BlockBreaker {
-    Active(ActiveBreaker),
-    Finished(FinishedBreaker),
-    Inactive,
-}
-impl BlockBreaker {
-    /// Create a new active instance pointing to `block_pos`. Calculates the time needed using `world.block_at(block_pos)` and `equipped_item`.
-    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)
-    }
-    /// If active, produces a `DestroyStateChange` event for the adequate position.
-    pub fn destroy_change_event(&self) -> Option<DestroyStateChange> {
-        Some(DestroyStateChange(self.position()?, self.destroy_stage()))
-    }
-    /// If active or finished, returns the pointed to position.
-    pub fn position(&self) -> Option<ValidBlockPosition> {
-        match self {
-            BlockBreaker::Active(a) => Some(a.position),
-            BlockBreaker::Finished(f) => Some(f.position),
-            BlockBreaker::Inactive => None,
-        }
-    }
-    /// If active, returns the underlying `ActiveBreaker`.
-    pub fn active(&self) -> Option<&ActiveBreaker> {
-        match self {
-            Self::Active(a) => Some(a),
-            _ => None,
-        }
-    }
-    /// If finished, returns the underlying `FinishedBreaker`.
-    pub fn finished(&self) -> Option<&FinishedBreaker> {
-        match self {
-            Self::Finished(f) => Some(f),
-            _ => None,
-        }
-    }
-    /// Progresses block breaking. Returns a (newly_finished, do_destry_state_change) tuple.
-    /// If this operation finishes block breaking, this turns `self` into `Self::Finished` with the same position.
-    pub fn tick(&mut self) -> (bool, bool) {
-        let (block_break, stage_update) = if let Self::Active(breaker) = self {
-            breaker.tick()
-        } else {
-            (false, false)
+pub fn start_digging(
+    game: &mut Game,
+    player: Entity,
+    position: ValidBlockPosition,
+) -> anyhow::Result<bool> {
+    if game.ecs.get::<Instabreak>(player)?.0 {
+        game.break_block(position);
+    } else {
+        let breaker = {
+            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)?;
+            ActiveBreaker::new(&mut game.world, position, main_hand.option_ref())
+                .context("Cannot mine this block")?
         };
-        if block_break {
-            let fin = match mem::take(self) {
-                Self::Active(a) => a.finish(),
-                _ => unreachable!(),
-            };
-            *self = Self::Finished(fin);
-        }
-        (block_break, stage_update)
-    }
-    /// Returns the block destroying progress in a range of 0 - 9. When inactive or finished, returns 10.
-    pub fn destroy_stage(&self) -> u8 {
-        match self {
-            BlockBreaker::Active(a) => a.destroy_stage(),
-            _ => 10,
-        }
-    }
-    /// Set `self` to `Self::Inactive`.
-    pub fn cancel(&mut self) {
-        *self = Self::Inactive;
-    }
-    /// Check if the breaker points to `pos`. Returns `true` when `self` is `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,
-        }
-    }
-    /// Attempts to finish breaking the target block, optionally turning `self` into `Self::Finished`.
-    pub fn try_finish(&mut self) -> Option<FinishedBreaker> {
-        let this = self.clone();
-        match this {
-            BlockBreaker::Active(a) => {
-                if a.can_break() {
-                    let fin = a.finish();
-                    *self = Self::Finished(fin.clone());
-                    Some(fin)
-                } else {
-                    None
-                }
-            }
-            BlockBreaker::Finished(f) => Some(f),
-            BlockBreaker::Inactive => None,
-        }
-    }
-}
-impl Default for BlockBreaker {
-    fn default() -> Self {
-        Self::Inactive
+        game.ecs.insert(player, breaker)?;
     }
+    Ok(true)
 }
-#[derive(Clone)]
-pub struct FinishedBreaker {
-    pub position: ValidBlockPosition,
-    pub drop_item: bool,
-    pub fake_finished: bool,
+pub fn cancel_digging(
+    game: &mut Game,
+    player: Entity,
+    position: ValidBlockPosition,
+) -> anyhow::Result<bool> {
+    if game.ecs.get::<ActiveBreaker>(player).is_err() {
+        return Ok(false);
+    }
+    game.ecs.remove::<ActiveBreaker>(player)?;
+    game.ecs
+        .insert_entity_event(player, DestroyStateChange(position, 10))?;
+    Ok(true)
 }
-impl FinishedBreaker {
-    /// Breaks the targeted block and spawns its drops. TODO: make drops work.
-    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"),
-        };
-        game.break_block(self.position);
-        if let Some(_item_drop) = base::Item::from_name(target_block.kind().name()) {
-            if !self.drop_item {
-                return Ok(());
-            }
-            let mut item_entity = EntityBuilder::new();
-            crate::entities::item::build_default(&mut item_entity);
-            let builder = game.create_entity_builder(self.position.position(), EntityInit::Item);
-            game.spawn_entity(builder);
-        }
-        Ok(())
-    }
+pub fn finish_digging(
+    game: &mut Game,
+    player: Entity,
+    position: ValidBlockPosition,
+) -> anyhow::Result<bool> {
+    if game.ecs.get::<Instabreak>(player)?.0 {
+        return Ok(true);
+    }
+    let success = if let Ok(breaker) = game.ecs.get::<ActiveBreaker>(player) {
+        breaker.can_break()
+    } else {
+        false
+    };
+    if success {
+        let pos = game.ecs.get::<ActiveBreaker>(player)?.position;
+        game.break_block(pos); // TODO: drop an item
+        game.ecs.remove::<ActiveBreaker>(player)?;
+    }
+    game.ecs
+        .insert_entity_event(player, DestroyStateChange(position, 10))?;
+    Ok(success)
 }
 #[derive(Clone)]
 pub struct ActiveBreaker {
     pub position: ValidBlockPosition,
     pub drop_item: bool,
-    pub fake_finished: bool,
     pub progress: f32,
     pub damage: f32,
 }
@@ -154,7 +78,7 @@ impl ActiveBreaker {
         self.progress += self.damage;
         let after = self.destroy_stage();
         let break_block = self.can_break();
-        let change_stage = before != after || break_block;
+        let change_stage = break_block || before != after;
         (break_block, change_stage)
     }
     /// Check if the block has been damaged enough to break.
@@ -175,21 +99,16 @@ impl ActiveBreaker {
             (Some(_), None) => false,
             (Some(tools), Some(tool)) => tools.contains(&tool.item()),
         };
-        let dig_multiplier = block
+        let dig_multiplier = block // TODO: calculate with Haste effect
             .dig_multipliers()
             .iter()
             .find_map(|(item, speed)| {
-                equipped_item
-                    .and_then(|e| {
-                        bool::then_some(e.item() == *item, *speed)
-                    })
+                equipped_item.and_then(|e| bool::then_some(e.item() == *item, *speed))
             })
             .unwrap_or(1.0);
         let effi_level = equipped_item
             .and_then(ItemStack::metadata)
-            .and_then(|meta| {
-                meta.get_enchantment_level(EnchantmentKind::Efficiency)
-            });
+            .and_then(|meta| meta.get_enchantment_level(EnchantmentKind::Efficiency));
         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
@@ -199,25 +118,16 @@ impl ActiveBreaker {
         Some(Self {
             position: block_pos,
             drop_item: true,
-            fake_finished: false,
-            progress: 0.0,
+            progress: damage,
             damage,
         })
     }
     /// Get the destroying progress.
     pub fn destroy_stage(&self) -> u8 {
-        if self.fake_finished {
-            10
-        } else {
-            (self.progress / BREAK_THRESHOLD * 9.0).round() as u8
-        }
+        (self.progress * 9.0).round() as u8
     }
-    pub fn finish(self) -> FinishedBreaker {
-        FinishedBreaker {
-            position: self.position,
-            drop_item: self.drop_item,
-            fake_finished: self.fake_finished,
-        }
+    pub fn destroy_change_event(&self) -> DestroyStateChange {
+        DestroyStateChange(self.position, self.destroy_stage())
     }
 }
 
@@ -226,36 +136,19 @@ pub fn register(systems: &mut SystemExecutor<Game>) {
 }
 
 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() {
-        let (break_block, update_stage) = breaker.tick();
+    for (entity, breaker) in game.ecs.query::<&mut ActiveBreaker>().iter() {
+        let (_, 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 && breaker.finished().unwrap().fake_finished
-            || game.ecs.get::<Player>(entity).is_err()
-        {
-            break_queue.push(entity);
-        }
     }
     for entity in update_queue {
         let event = game
             .ecs
-            .get_mut::<BlockBreaker>(entity)?
-            .destroy_change_event()
-            .unwrap();
+            .get_mut::<ActiveBreaker>(entity)?
+            .destroy_change_event();
         game.ecs.insert_entity_event(entity, event)?;
     }
-    for entity in break_queue.into_iter() {
-        let breaker = game
-            .ecs
-            .get::<BlockBreaker>(entity)?
-            .finished()
-            .unwrap()
-            .clone();
-        breaker.break_block(game)?;
-    }
     Ok(())
 }

feather/common/src/game.rs

@@ -1,11 +1,11 @@
 use std::{cell::RefCell, mem, rc::Rc, sync::Arc};
 
-use base::{BlockId, ChunkPosition, Position, Text, Title, ValidBlockPosition};
+use base::{BlockId, ChunkPosition, Gamemode, Position, Text, Title, ValidBlockPosition};
 use ecs::{
     Ecs, Entity, EntityBuilder, HasEcs, HasResources, NoSuchEntity, Resources, SysResult,
     SystemExecutor,
 };
-use quill_common::events::{EntityCreateEvent, EntityRemoveEvent, PlayerJoinEvent};
+use quill_common::events::{EntityCreateEvent, EntityRemoveEvent, GamemodeEvent, PlayerJoinEvent};
 use quill_common::{entities::Player, entity_init::EntityInit};
 
 use crate::{
@@ -230,6 +230,11 @@ impl Game {
     pub fn break_block(&mut self, pos: ValidBlockPosition) -> bool {
         self.set_block(pos, BlockId::air())
     }
+
+    pub fn set_gamemode(&mut self, player: Entity, new: Gamemode) -> SysResult {
+        self.ecs.insert_entity_event(player, GamemodeEvent(new))?;
+        Ok(())
+    }
 }
 
 impl HasResources for Game {

feather/server/src/packet_handlers.rs

@@ -1,4 +1,4 @@
-use base::{Position, Text};
+use base::{Gamemode, Position, Text};
 use common::{chat::ChatKind, Game};
 use ecs::{Entity, EntityRef, SysResult};
 use interaction::{
@@ -45,7 +45,7 @@ pub fn handle_packet(
 
         ClientPlayPacket::Animation(packet) => handle_animation(server, player, packet),
 
-        ClientPlayPacket::ChatMessage(packet) => handle_chat_message(game, player, packet),
+        ClientPlayPacket::ChatMessage(packet) => handle_chat_message(game, player_id, packet),
 
         ClientPlayPacket::PlayerDigging(packet) => {
             handle_player_digging(game, server, packet, player_id)
@@ -132,8 +132,16 @@ fn handle_animation(
     Ok(())
 }
 
-fn handle_chat_message(game: &Game, player: EntityRef, packet: client::ChatMessage) -> SysResult {
-    let name = player.get::<Name>()?;
+fn handle_chat_message(game: &mut Game, player: Entity, packet: client::ChatMessage) -> SysResult {
+    if let m @ ("c" | "s") = &*packet.message {
+        if m == "c" {
+            game.set_gamemode(player, Gamemode::Creative)?;
+        } else {
+            game.set_gamemode(player, Gamemode::Survival)?;
+        }
+    }
+
+    let name = game.ecs.get::<Name>(player)?;
     let message = Text::translate_with("chat.type.text", vec![name.to_string(), packet.message]);
     game.broadcast_chat(ChatKind::PlayerChat, message);
     Ok(())