First commit

Gamemode hardcoded to survival for testing

Author: koskja

feather/common/src/block_break.rs

@@ -0,0 +1,66 @@
+use base::{ValidBlockPosition, ItemStack};
+use ecs::{SystemExecutor, SysResult, EntityBuilder};
+use quill_common::entity_init::EntityInit;
+
+use crate::{Game, World};
+
+pub type BlockBreaker = Option<ActiveBlockBreaker>;
+pub struct ActiveBlockBreaker {
+    pub position: ValidBlockPosition,
+    pub drop_item: bool,
+    pub ticks_remaining: u32,
+}
+impl ActiveBlockBreaker {
+    pub fn tick(&mut self) -> bool {
+        self.ticks_remaining = self.ticks_remaining.saturating_sub(1);
+        self.ticks_remaining == 0
+    }
+    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 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,
+            ticks_remaining: 20,
+        })
+    }
+}
+
+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![];
+    for (entity, breaker) in game.ecs.query::<&mut BlockBreaker>().iter() {
+        if let Some(active) = breaker {
+            if active.tick() {
+                break_queue.push(entity);
+            }
+        }
+    }
+    for entity in break_queue.into_iter() {
+        // Set block breakers to None
+        let breaker = {
+            game.ecs.get_mut::<BlockBreaker>(entity)?.take().unwrap()
+        };
+        breaker.break_block(game)?;
+    }
+    Ok(())
+}

feather/common/src/lib.rs

@@ -32,12 +32,15 @@ pub mod entities;
 
 pub mod interactable;
 
+pub mod block_break;
+
 /// Registers gameplay systems with the given `Game` and `SystemExecutor`.
 pub fn register(game: &mut Game, systems: &mut SystemExecutor<Game>) {
     view::register(game, systems);
     chunk::loading::register(game, systems);
     chunk::entities::register(systems);
     interactable::register(game);
+    block_break::register(systems);
 
     game.add_entity_spawn_callback(entities::add_entity_components);
 }

feather/server/src/client.rs

@@ -20,7 +20,7 @@ use common::{
 use libcraft_items::InventorySlot;
 use packets::server::{Particle, SetSlot, SpawnLivingEntity, UpdateLight, WindowConfirmation};
 use protocol::packets::server::{
-    EntityPosition, EntityPositionAndRotation, EntityTeleport, HeldItemChange, PlayerAbilities,
+    EntityPosition, EntityPositionAndRotation, EntityTeleport, HeldItemChange, PlayerAbilities, PlayerDiggingStatus, AcknowledgePlayerDigging, BlockBreakAnimation,
 };
 use protocol::{
     packets::{
@@ -602,6 +602,23 @@ impl Client {
         self.send_packet(HeldItemChange { slot });
     }
 
+    pub fn acknowledge_player_digging(&self, position: ValidBlockPosition, block: BlockId, status: PlayerDiggingStatus, successful: bool) {
+        self.send_packet(AcknowledgePlayerDigging {
+            position,
+            block,
+            status,
+            successful,
+        })
+    }
+
+    pub fn block_break_animation(&self, entity_id: i32, position: ValidBlockPosition, destroy_stage: u8) {
+        self.send_packet(BlockBreakAnimation {
+            entity_id,
+            position,
+            destroy_stage,
+        })
+    }
+
     fn register_entity(&self, network_id: NetworkId) {
         self.sent_entities.borrow_mut().insert(network_id);
     }

feather/server/src/packet_handlers/interaction.rs

@@ -1,5 +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 common::entities::player::HotbarSlot;
 use common::interactable::InteractableRegistry;
 use common::{Game, Window};
@@ -119,8 +121,32 @@ pub fn handle_player_digging(
 ) -> SysResult {
     log::trace!("Got player digging with status {:?}", packet.status);
     match packet.status {
-        PlayerDiggingStatus::StartDigging | PlayerDiggingStatus::CancelDigging => {
-            game.break_block(packet.position);
+        PlayerDiggingStatus::StartDigging => {
+            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());
+            }
+
+            Ok(())
+        },
+        PlayerDiggingStatus::CancelDigging => {
+            game.ecs.get_mut::<BlockBreaker>(player)?.take();
+            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);
+            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);
             Ok(())
         }
         PlayerDiggingStatus::SwapItemInHand => {
@@ -145,7 +171,10 @@ pub fn handle_player_digging(
 
             Ok(())
         }
-        _ => Ok(()),
+        PlayerDiggingStatus::DropItemStack => Ok(()),
+        PlayerDiggingStatus::DropItem => Ok(()),
+        PlayerDiggingStatus::ShootArrow => Ok(()),
+        
     }
 }
 

feather/server/src/systems/player_join.rs

@@ -1,3 +1,4 @@
+use common::block_break::BlockBreaker;
 use libcraft_items::InventorySlot;
 use log::debug;
 
@@ -108,7 +109,7 @@ fn accept_new_player(game: &mut Game, server: &mut Server, client_id: ClientId)
             Position::default().chunk(),
             server.options.view_distance,
         ))
-        .add(gamemode)
+        .add(Gamemode::Survival)
         .add(previous_gamemode)
         .add(Name::new(client.username()))
         .add(client.uuid())
@@ -123,6 +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(abilities.walk_speed)
         .add(abilities.fly_speed)
         .add(abilities.is_flying)

libcraft/items/src/inventory_slot.rs

@@ -188,6 +188,20 @@ impl InventorySlot {
             InventorySlot::Empty => None,
         }
     }
+
+    pub fn item_stack(&self) -> Option<&ItemStack> {
+        match self {
+            InventorySlot::Filled(f) => Some(f),
+            InventorySlot::Empty => None,
+        }
+    }
+
+    pub fn item_stack_mut(&mut self) -> Option<&mut ItemStack> {
+        match self {
+            InventorySlot::Filled(f) => Some(f),
+            InventorySlot::Empty => None,
+        }
+    }
 }
 
 #[cfg(test)]