feather-rs · kirawi · Mar 7, 2021 · Mar 7, 2021 · Mar 8, 2021 · Mar 8, 2021
diff --git a/feather/common/src/events.rs b/feather/common/src/events.rs
@@ -11,7 +11,7 @@ mod plugin_message;
 pub use block_change::BlockChangeEvent;
 pub use plugin_message::PluginMessageEvent;
 
-/// Triggered when a player joins the `Game`.
+/// Triggered when a player joins the game.
 #[derive(Debug)]
 pub struct PlayerJoinEvent;
 

diff --git a/feather/protocol/src/io.rs b/feather/protocol/src/io.rs
@@ -454,6 +454,7 @@ where
 
 pub type VarIntPrefixedVec<'a, T> = LengthPrefixedVec<'a, VarInt, T>;
 pub type ShortPrefixedVec<'a, T> = LengthPrefixedVec<'a, u16, T>;
+pub type IntPrefixedVec<'a, T> = LengthPrefixedVec<'a, i32, T>;
 
 /// A vector of bytes which consumes all remaining bytes in this packet.
 /// This is used by the plugin messaging packets, for one.

diff --git a/feather/protocol/src/packets.rs b/feather/protocol/src/packets.rs
@@ -5,6 +5,9 @@ macro_rules! user_type {
     (VarIntPrefixedVec <$inner:ident>) => {
         Vec<$inner>
     };
+    (IntPrefixedVec <$inner:ident>) => {
+        Vec<$inner>
+    };
     (ShortPrefixedVec <$inner:ident>) => {
         Vec<$inner>
     };
@@ -26,6 +29,9 @@ macro_rules! user_type_convert_to_writeable {
     (VarIntPrefixedVec <$inner:ident>, $e:expr) => {
         VarIntPrefixedVec::from($e.as_slice())
     };
+    (IntPrefixedVec <$inner:ident>, $e:expr) => {
+        IntPrefixedVec::from($e.as_slice())
+    };
     (ShortPrefixedVec <$inner:ident>, $e:expr) => {
         ShortPrefixedVec::from($e.as_slice())
     };
@@ -284,7 +290,9 @@ pub trait VariantOf<Enum> {
         Self: Sized;
 }
 
-use crate::io::{Angle, LengthInferredVecU8, Nbt, ShortPrefixedVec, VarInt, VarIntPrefixedVec};
+use crate::io::{
+    Angle, IntPrefixedVec, LengthInferredVecU8, Nbt, ShortPrefixedVec, VarInt, VarIntPrefixedVec,
+};
 use crate::Slot;
 use base::{BlockId, BlockPosition};
 use nbt::Blob;

diff --git a/feather/protocol/src/packets/server/play.rs b/feather/protocol/src/packets/server/play.rs
@@ -1166,7 +1166,9 @@ packets! {
     }
 
     EntityProperties {
-        __todo__ LengthInferredVecU8;
+        entity_id VarInt;
+        properties IntPrefixedVec<EntityProperty>;
+
     }
 
     EntityEffect {
@@ -1183,6 +1185,74 @@ packets! {
     }
 }
 
+def_enum! {
+    OperationKind (u8) {
+        0 = AddSubtract,
+        1 = AddSubtractPercent,
+        2 = MultiplyPercent
+    }
+}
+
+def_enum! {
+    EntityAttributeKind (String) {
+        "generic.max_health" = MaxHealth,
+        "generic.follow_range" = FollowRange,
+        "generic.knockback_resistance" = KnockbackResistance,
+        "generic.movement_speed" = MovementSpeed,
+        "generic.attack_damage" = AttackDamage,
+        "generic.attack_speed" = AttackSpeed,
+        "generic.attack_knockback" = AttackKnockback,
+        "generic.flying_speed" = FlyingSpeed,
+        "generic.armor" = Armor,
+        "generic.armor_toughness" = ArmorToughness,
+        "generic.luck" = Luck,
+        "horse.jump_strength" = HorseJumpStrength,
+        "zombie.spawn_reinforcements" = ZombieSpawnReinforcements,
+    }
+}
+
+impl EntityAttributeKind {
+    pub fn max_value(&self) -> f32 {
+        match &self {
+            EntityAttributeKind::MaxHealth => 1024.0,
+            EntityAttributeKind::FollowRange => 2048.0,
+            EntityAttributeKind::KnockbackResistance => 1.0,
+            EntityAttributeKind::MovementSpeed => 1024.0,
+            EntityAttributeKind::AttackDamage => 2048.0,
+            EntityAttributeKind::AttackSpeed => 1024.0,
+            EntityAttributeKind::AttackKnockback => 5.0,
+            EntityAttributeKind::FlyingSpeed => 1024.0,
+            EntityAttributeKind::Armor => 30.0,
+            EntityAttributeKind::ArmorToughness => 20.0,
+            EntityAttributeKind::Luck => 1024.0,
+            EntityAttributeKind::HorseJumpStrength => 2.0,
+            EntityAttributeKind::ZombieSpawnReinforcements => 1.0,
+        }
+    }
+
+    pub fn min_value(&self) -> f32 {
+        if let EntityAttributeKind::Luck = &self {
+            return -1024.0;
+        }
+
+        0.0
+    }
+}
+
+packets! {
+    AttributeModifier {
+        uuid Uuid;
+        amount f64;
+        operation OperationKind;
+    }
+
+    EntityProperty {
+        attribute EntityAttributeKind;
+        value f64;
+        modifiers VarIntPrefixedVec<AttributeModifier>
+    }
+}
+
 def_enum! {
     Recipe (String) {
         "minecraft:crafting_shapeless" = Shapeless {

diff --git a/feather/server/src/client.rs b/feather/server/src/client.rs
@@ -15,7 +15,9 @@ use common::{
     Window,
 };
 use flume::{Receiver, Sender};
-use packets::server::{Particle, SetSlot, SpawnLivingEntity, UpdateLight, WindowConfirmation};
+use packets::server::{
+    Particle, Respawn, SetSlot, SpawnLivingEntity, UpdateHealth, UpdateLight, WindowConfirmation,
+};
 use parking_lot::RwLock;
 use protocol::{
     packets::{
@@ -29,7 +31,7 @@ use protocol::{
     },
     ClientPlayPacket, Nbt, ProtocolVersion, ServerPlayPacket, Writeable,
 };
-use quill_common::components::OnGround;
+use quill_common::components::{Health, Hunger, OnGround};
 use uuid::Uuid;
 use vec_arena::Arena;
 
@@ -512,6 +514,32 @@ impl Client {
         self.set_slot(-1, item);
     }
 
+    pub fn update_status(&self, player_health: &Health, player_hunger: &Hunger) {
+        self.send_packet(UpdateHealth {
+            health: player_health.health as f32,
+            food: player_hunger.food as i32,
+            food_saturation: player_hunger.saturation as f32,
+        });
+    }
+
+    pub fn send_respawn(&self, gamemode: Gamemode, copy_metadata: bool) {
+        let dimension = nbt::Blob::from_reader(&mut Cursor::new(include_bytes!(
+            "../../../assets/dimension.nbt"
+        )))
+        .expect("dimension asset is malformed");
+
+        self.send_packet(Respawn {
+            dimension: Nbt(dimension),
+            world_name: "world".to_owned(),
+            hashed_seed: 0,
+            gamemode,
+            previous_gamemode: gamemode,
+            is_debug: false,
+            is_flat: false,
+            copy_metadata,
+        });
+    }
+
     pub fn send_player_model_flags(&self, netowrk_id: NetworkId, model_flags: u8) {
         let mut entity_metadata = EntityMetadata::new();
         entity_metadata.set(16, model_flags);

diff --git a/feather/server/src/packet_handlers.rs b/feather/server/src/packet_handlers.rs
@@ -16,6 +16,7 @@ use quill_common::components::Name;
 
 use crate::{NetworkId, Server};
 
+mod health;
 mod interaction;
 pub mod inventory;
 mod movement;
@@ -64,12 +65,15 @@ pub fn handle_packet(
             handle_interact_entity(game, server, packet, player_id)
         }
 
+        ClientPlayPacket::ClientStatus(packet) => {
+            health::handle_client_status(game, server, player_id, packet)
+        }
+
         ClientPlayPacket::ClientSettings(packet) => handle_client_settings(server, player, packet),
 
         ClientPlayPacket::TeleportConfirm(_)
         | ClientPlayPacket::QueryBlockNbt(_)
         | ClientPlayPacket::SetDifficulty(_)
-        | ClientPlayPacket::ClientStatus(_)
         | ClientPlayPacket::TabComplete(_)
         | ClientPlayPacket::WindowConfirmation(_)
         | ClientPlayPacket::ClickWindowButton(_)

diff --git a/feather/server/src/packet_handlers/health.rs b/feather/server/src/packet_handlers/health.rs
@@ -0,0 +1,40 @@
+use base::Gamemode;
+use common::Game;
+use ecs::{Entity, SysResult};
+use protocol::packets::client::ClientStatus;
+use quill_common::events::entity_special_event_kind;
+
+use crate::{ClientId, Server};
+
+pub fn handle_client_status(
+    game: &mut Game,
+    server: &mut Server,
+    player: Entity,
+    packet: ClientStatus,
+) -> SysResult {
+    match packet {
+        ClientStatus::PerformRespawn => {
+            let mut send_event = false;
+            {
+                let client_id = game.ecs.get::<ClientId>(player)?;
+                if let Some(client) = server.clients.get(*client_id) {
+                    let gamemode = game.ecs.get::<Gamemode>(player)?;
+                    client.send_respawn(*gamemode, false);
+
+                    send_event = true;
+                }
+            }
+
+            if send_event {
+                game.ecs.insert_entity_event(
+                    player,
+                    entity_special_event_kind::EntityResurrectionEvent,
+                )?;
+            }
+        }
+
+        ClientStatus::RequestStats => {}
+    }
+
+    Ok(())
+}
diff --git a/feather/server/src/systems.rs b/feather/server/src/systems.rs
@@ -3,6 +3,8 @@
 mod block;
 mod chat;
 mod entity;
+mod health;
+mod hunger;
 mod particle;
 mod player_join;
 mod player_leave;
@@ -35,6 +37,8 @@ pub fn register(server: Server, game: &mut Game, systems: &mut SystemExecutor<Ga
     entity::register(game, systems);
     chat::register(game, systems);
     particle::register(systems);
+    health::register(game, systems);
+    hunger::register(game, systems);
     plugin_message::register(systems);
 
     systems.group::<Server>().add_system(tick_clients);

diff --git a/feather/server/src/systems/health.rs b/feather/server/src/systems/health.rs
@@ -0,0 +1,109 @@
+use crate::{ClientId, Game, Server};
+use ecs::{SysResult, SystemExecutor};
+use quill_common::{
+    components::{Health, Hunger},
+    events::{
+        entity_damage_event_kind, entity_regen_event_kind, entity_special_event_kind,
+        EntityHealthEvent,
+    },
+};
+
+pub fn register(_game: &mut Game, systems: &mut SystemExecutor<Game>) {
+    systems
+        .group::<Server>()
+        .add_system(entity_resurrection)
+        .add_system(entity_suicide)
+        .add_system(player_eating_regen)
+        .add_system(player_hunger)
+        .add_system(health_events_handler);
+}
+
+// TODO: Implement for entities besides players.
+fn health_events_handler(game: &mut Game, server: &mut Server) -> SysResult {
+    for (entity, (event, health)) in game.ecs.query::<(&EntityHealthEvent, &mut Health)>().iter() {
+        match event {
+            EntityHealthEvent::Regen(amount) => health.heal(*amount),
+            EntityHealthEvent::Damage(amount) => health.harm(*amount),
+        }
+
+        if let Ok(client_id) = game.ecs.get::<ClientId>(entity) {
+            if let Some(client) = server.clients.get(*client_id) {
+                let hunger = game.ecs.entity(entity)?.get::<Hunger>()?;
+                client.update_status(&health, &hunger);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn entity_resurrection(game: &mut Game, _server: &mut Server) -> SysResult {
+    let mut events = Vec::new();
+
+    for (entity, (_, health)) in game
+        .ecs
+        .query::<(
+            &entity_special_event_kind::EntityResurrectionEvent,
+            &mut Health,
+        )>()
+        .iter()
+    {
+        events.push((entity, EntityHealthEvent::Regen(health.max_health)));
+    }
+
+    for (entity, event) in events {
+        game.ecs.insert_entity_event(entity, event)?;
+    }
+
+    Ok(())
+}
+
+fn entity_suicide(game: &mut Game, _server: &mut Server) -> SysResult {
+    let mut events = Vec::new();
+
+    for (entity, (_, health)) in game
+        .ecs
+        .query::<(&entity_special_event_kind::EntitySuicideEvent, &mut Health)>()
+        .iter()
+    {
+        events.push((entity, EntityHealthEvent::Damage(health.max_health)));
+    }
+
+    for (entity, event) in events {
+        game.ecs.insert_entity_event(entity, event)?;
+    }
+
+    Ok(())
+}
+
+fn player_eating_regen(game: &mut Game, _server: &mut Server) -> SysResult {
+    let mut events = Vec::new();
+
+    for (entity, _) in game.ecs.query::<&entity_regen_event_kind::Eating>().iter() {
+        events.push((entity, EntityHealthEvent::Regen(1)));
+    }
+
+    for (entity, event) in events {
+        game.ecs.insert_entity_event(entity, event)?;
+    }
+
+    Ok(())
+}
+
+fn player_hunger(game: &mut Game, _server: &mut Server) -> SysResult {
+    let mut events = Vec::new();
+
+    for (entity, _) in game
+        .ecs
+        .query::<&entity_damage_event_kind::Starvation>()
+        .iter()
+    {
+        events.push((entity, EntityHealthEvent::Damage(1)));
+    }
+
+    for (entity, event) in events {
+        game.ecs.insert_entity_event(entity, event)?;
+    }
+
+    Ok(())
+}