implemented bevy-ecs for better entities

Author: Stivais

Cargo.lock

@@ -24,6 +24,7 @@ glam = "0.30.5"
 enumset = "1.1.10"
 fstr = { path = "crates/fstr" }
 include_dir = "0.7.4"
+bevy_ecs = "0.18.0"
 
 [profile.dev.package."*"]
 opt-level = 3

Cargo.toml

@@ -17,3 +17,4 @@ replays = { path = "../replays" }
 glam = "0.30.8"
 enumset = "1.1.10"
 slotmap = "1.0.7"
+bevy_ecs = "0.18.0"

server/Cargo.toml

@@ -46,7 +46,7 @@ pub enum Particle {
     BlockDust = 38,
     Droplet = 39,
     ItemTake = 40,
-    MobAppearance = 41,
+    MobAppear = 41,
 }
 
 impl PacketSerializable for Particle {

server/src/constants/particle.rs

@@ -4,17 +4,21 @@ use bytes::BytesMut;
 #[derive(Debug, Copy, Clone)]
 pub enum Sound {
     EnderDragonHit,
+    RandomExplode,
     ZombieRemedy,
     FireIgnite,
+    DonkeyHit,
     NoteHat,
 }
 
 impl Sound {
     fn get_sound(&self) -> &'static str {
         match self {
             Sound::EnderDragonHit => "mob.enderdragon.hit",
+            Sound::RandomExplode => "random.explode",
             Sound::ZombieRemedy => "mob.zombie.remedy",
             Sound::FireIgnite => "fire.ignite",
+            Sound::DonkeyHit => "mob.horse.donkey.hit",
             Sound::NoteHat => "note.hat",
         }
     }

server/src/constants/sounds.rs

@@ -1,41 +1,35 @@
 use crate::constants::EntityVariant;
-use crate::entity::entity::EntityBase;
+use crate::entity::entity::MinecraftEntity;
 use crate::entity::entity_metadata::{EntityMetadata, PlayerMetadata};
 use crate::network::binary::var_int::VarInt;
 use crate::network::packets::packet_buffer::PacketBuffer;
 use crate::network::protocol::play::clientbound::{DestroyEntites, EntityRotate, EntityTeleport, EntityYawRotate, PlayerData, PlayerListItem, SpawnMob, SpawnPlayer};
 use crate::{GameProfile, GameProfileProperty, Player, WorldExtension};
+use bevy_ecs::component::Mutable;
+use bevy_ecs::prelude::Component;
 use fstr::FString;
 use std::collections::HashMap;
 use uuid::Uuid;
 
-pub trait EntityAppearance<W: WorldExtension> {
-    fn initialize(&self, entity: &mut EntityBase<W>);
+pub trait EntityAppearance<W: WorldExtension + 'static>: Component<Mutability = Mutable> + Sized {
 
-    fn destroy(&self, entity: &mut EntityBase<W>, packet: &mut DestroyEntites);
+    fn enter_player_view(&self, entity: &MinecraftEntity<W>, player: &mut Player<W::Player>);
 
-    fn enter_player_view(&self, entity: &mut EntityBase<W>, player: &mut Player<W::Player>);
+    fn leave_player_view(&self, entity: &MinecraftEntity<W>, player: &mut Player<W::Player>);
 
-    fn leave_player_view(&self, entity: &mut EntityBase<W>, player: &mut Player<W::Player>);
+    fn update_position(&self, entity: &MinecraftEntity<W>, packet_buffer: &mut PacketBuffer);
 
-    fn update_position(&self, entity: &mut EntityBase<W>, chunk_buffer: &mut PacketBuffer);
-
-    fn update_rotation(&self, entity: &mut EntityBase<W>, chunk_buffer: &mut PacketBuffer);
+    fn destroy(&self, entity: &MinecraftEntity<W>, packet: &mut DestroyEntites);
 }
 
+#[derive(Component)]
 pub struct MobAppearance {
     pub variant: EntityVariant,
     pub metadata: EntityMetadata,
 }
 
-impl<W: WorldExtension> EntityAppearance<W> for MobAppearance {
-    fn initialize(&self, _: &mut EntityBase<W>) {}
-
-    fn destroy(&self, entity_base: &mut EntityBase<W>, packet: &mut DestroyEntites) {
-        packet.entities.push(VarInt(entity_base.id))
-    }
-
-    fn enter_player_view(&self, entity: &mut EntityBase<W>, player: &mut Player<W::Player>) {
+impl<W: WorldExtension + 'static> EntityAppearance<W> for MobAppearance {
+    fn enter_player_view(&self, entity: &MinecraftEntity<W>, player: &mut Player<W::Player>) {
         player.write_packet(&SpawnMob {
             entity_id: entity.id,
             entity_variant: self.variant,
@@ -53,41 +47,25 @@ impl<W: WorldExtension> EntityAppearance<W> for MobAppearance {
         player.write_packet(&EntityYawRotate {
             entity_id: entity.id,
             yaw: entity.yaw,
-        })
+        });
     }
 
-    fn leave_player_view(&self, entity: &mut EntityBase<W>, player: &mut Player<W::Player>) {
+    fn leave_player_view(&self, entity: &MinecraftEntity<W>, player: &mut Player<W::Player>) {
         player.write_packet(&DestroyEntites {
             entities: vec![VarInt(entity.id)],
         })
     }
 
-    fn update_position(&self, entity: &mut EntityBase<W>, packet_buffer: &mut PacketBuffer) {
-        packet_buffer.write_packet(&EntityTeleport {
-            entity_id: entity.id,
-            pos_x: entity.position.x,
-            pos_y: entity.position.y,
-            pos_z: entity.position.z,
-            yaw: entity.yaw,
-            pitch: entity.pitch,
-            on_ground: false,
-        })
+    fn update_position(&self, entity: &MinecraftEntity<W>, packet_buffer: &mut PacketBuffer) {
+        update_position(entity, packet_buffer)
     }
 
-    fn update_rotation(&self, entity: &mut EntityBase<W>, packet_buffer: &mut PacketBuffer) {
-        packet_buffer.write_packet(&EntityRotate {
-            entity_id: entity.id,
-            yaw: entity.yaw,
-            pitch: entity.pitch,
-            on_ground: false,
-        });
-        packet_buffer.write_packet(&EntityYawRotate {
-            entity_id: entity.id,
-            yaw: entity.yaw,
-        });
+    fn destroy(&self, entity: &MinecraftEntity<W>, packet: &mut DestroyEntites) {
+        packet.entities.push(VarInt(entity.id))
     }
 }
 
+#[derive(Component)]
 pub struct PlayerAppearance {
     name: &'static str,
     metadata: PlayerMetadata,
@@ -97,7 +75,6 @@ pub struct PlayerAppearance {
 }
 
 impl PlayerAppearance {
-
     pub fn new(
         name: &'static str,
         metadata: PlayerMetadata,
@@ -114,14 +91,8 @@ impl PlayerAppearance {
     }
 }
 
-impl<W: WorldExtension> EntityAppearance<W> for PlayerAppearance {
-    fn initialize(&self, _: &mut EntityBase<W>) {}
-
-    fn destroy(&self, entity: &mut EntityBase<W>, packet: &mut DestroyEntites) {
-        packet.entities.push(VarInt(entity.id))
-    }
-
-    fn enter_player_view(&self, entity: &mut EntityBase<W>, player: &mut Player<W::Player>) {
+impl<W: WorldExtension + 'static> EntityAppearance<W> for PlayerAppearance {
+    fn enter_player_view(&self, entity: &MinecraftEntity<W>, player: &mut Player<W::Player>) {
         player.write_packet(&PlayerListItem {
             action: VarInt(0),
             players: &[PlayerData {
@@ -157,39 +128,38 @@ impl<W: WorldExtension> EntityAppearance<W> for PlayerAppearance {
         });
         player.write_packet(&EntityYawRotate {
             entity_id: entity.id,
-            yaw: entity.yaw,
+            yaw: entity.yaw
         });
         player.add_delayed_profile_remove(self.uuid);
     }
 
-    fn leave_player_view(&self, entity: &mut EntityBase<W>, player: &mut Player<W::Player>) {
+    fn leave_player_view(&self, entity: &MinecraftEntity<W>, player: &mut Player<W::Player>) {
         player.write_packet(&DestroyEntites {
             entities: vec![VarInt(entity.id)],
         })
     }
 
-    fn update_position(&self, entity: &mut EntityBase<W>, packet_buffer: &mut PacketBuffer) {
-        packet_buffer.write_packet(&EntityTeleport {
-            entity_id: entity.id,
-            pos_x: entity.position.x,
-            pos_y: entity.position.y,
-            pos_z: entity.position.z,
-            yaw: entity.yaw,
-            pitch: entity.pitch,
-            on_ground: false,
-        })
+    fn update_position(&self, entity: &MinecraftEntity<W>, packet_buffer: &mut PacketBuffer) {
+        update_position(entity, packet_buffer)
     }
 
-    fn update_rotation(&self, entity: &mut EntityBase<W>, packet_buffer: &mut PacketBuffer) {
-        packet_buffer.write_packet(&EntityRotate {
-            entity_id: entity.id,
-            yaw: entity.yaw,
-            pitch: entity.pitch,
-            on_ground: false,
-        });
-        packet_buffer.write_packet(&EntityYawRotate {
-            entity_id: entity.id,
-            yaw: entity.yaw,
-        });
+    fn destroy(&self, entity: &MinecraftEntity<W>, packet: &mut DestroyEntites) {
+        packet.entities.push(VarInt(entity.id))
     }
 }
+
+fn update_position<W : WorldExtension>(entity: &MinecraftEntity<W>, buffer: &mut PacketBuffer) {
+    buffer.write_packet(&EntityTeleport {
+        entity_id: entity.id,
+        pos_x: entity.position.x,
+        pos_y: entity.position.y,
+        pos_z: entity.position.z,
+        yaw: entity.yaw,
+        pitch: entity.pitch,
+        on_ground: false,
+    });
+    buffer.write_packet(&EntityYawRotate {
+        entity_id: entity.id,
+        yaw: entity.yaw,
+    });
+}

server/src/entity/entity_appearance.rs …c/entity/components/entity_appearance.rsserver/src/entity/entity_appearance.rs renamed to server/src/entity/components/entity_appearance.rs server/src/entity/entity_appearance.rs renamed to server/src/entity/components/entity_appearance.rs

@@ -0,0 +1,16 @@
+use crate::entity::entity::MinecraftEntity;
+use crate::WorldExtension;
+use bevy_ecs::component::{Component, Mutable};
+use bevy_ecs::world::World;
+
+// could maybe use a macro to provide custom query options somehow?
+pub trait EntityBehaviour<W : WorldExtension + 'static>: Component<Mutability = Mutable> + Sized {
+    fn tick(entity: &mut MinecraftEntity<W>, component: &mut Self);
+
+    fn query(world: &mut World) {
+        let mut query = world.query::<(&mut MinecraftEntity<W>, &mut Self)>();
+        for (mut entity, mut component) in query.iter_mut(world) {
+            Self::tick(&mut *entity, &mut *component);
+        }
+    }
+}

server/src/entity/components/entity_behaviour.rs

@@ -0,0 +1,16 @@
+use crate::{Player, WorldExtension};
+use bevy_ecs::component::Component;
+use bevy_ecs::world::EntityWorldMut;
+
+#[derive(Component)]
+pub struct Interactable<W: WorldExtension> {
+    pub callback: fn(EntityWorldMut, player: &mut Player<W::Player>)
+}
+
+impl<W: WorldExtension> Interactable<W> {
+    pub fn new(callback: fn(EntityWorldMut, player: &mut Player<W::Player>)) -> Self {
+        Self {
+            callback,
+        }
+    }
+}

server/src/entity/components/interactable.rs

@@ -0,0 +1,8 @@
+pub mod entity_behaviour;
+pub mod entity_appearance;
+pub mod interactable;
+
+pub use entity_appearance::EntityAppearance;
+pub use entity_appearance::MobAppearance;
+pub use entity_behaviour::EntityBehaviour;
+pub use interactable::Interactable;

server/src/entity/components/mod.rs

@@ -0,0 +1,102 @@
+use crate::entity::components::{EntityAppearance, EntityBehaviour};
+use crate::entity::entity::MinecraftEntity;
+use crate::WorldExtension;
+use bevy_ecs::bundle::Bundle;
+use bevy_ecs::entity::Entity;
+use bevy_ecs::world::{EntityRef, EntityWorldMut, World};
+use std::collections::{HashMap, HashSet};
+use std::marker::PhantomData;
+
+pub type MCEntityId = i32;
+
+#[derive(Default)]
+struct Systems {
+    pre: HashSet<fn(&mut World)>,
+    post: HashSet<fn(&mut World)>,
+}
+
+pub struct Entities<W: WorldExtension> {
+    ecs: World,
+    tick_systems: Systems,
+
+    current_entity_id: MCEntityId,
+    id_to_entities: HashMap<MCEntityId, Entity>,
+
+    phantom: PhantomData<W>
+}
+
+impl<W: WorldExtension + 'static> Entities<W> {
+
+    pub fn new() -> Self {
+        Self {
+            ecs: World::new(),
+            tick_systems: Default::default(),
+
+            current_entity_id: 0,
+            id_to_entities: Default::default(),
+
+            phantom: Default::default(),
+        }
+    }
+
+    pub fn tick(&mut self) {
+        for system in self.tick_systems.pre.iter() {
+            system(&mut self.ecs)
+        }
+        for system in self.tick_systems.post.iter() {
+            system(&mut self.ecs)
+        }
+    }
+
+    pub fn register_tick_system(&mut self, callback: fn(&mut World)) {
+        self.tick_systems.pre.insert(callback);
+    }
+
+    pub fn register_behaviour<T: EntityBehaviour<W>>(&mut self) {
+        self.tick_systems.pre.insert(T::query);
+    }
+
+    // maybe rename, since this is what also ticks mc entity
+    pub(crate) fn register_appearance_update<T: EntityAppearance<W>>(&mut self) {
+        self.tick_systems.post.insert(|world| {
+            let mut query = world.query::<(&mut MinecraftEntity<W>, &T)>();
+            for (mut entity, appearance) in query.iter_mut(world) {
+                entity.update(appearance);
+            }
+        });
+    }
+
+    pub fn mc_id_to_entity(&self, id: MCEntityId) -> Option<&Entity> {
+        self.id_to_entities.get(&id)
+    }
+
+    pub fn get_entity(&'_ self, entity: Entity) -> EntityRef<'_> {
+        self.ecs.entity(entity)
+    }
+
+    pub fn get_entity_mut(&'_ mut self, entity: Entity) -> EntityWorldMut<'_> {
+        self.ecs.entity_mut(entity)
+    }
+
+    pub const fn next_entity_id(&mut self) -> MCEntityId {
+        self.current_entity_id += 1;
+        self.current_entity_id
+    }
+
+    pub fn spawn<B: Bundle>(&mut self, entity: B) -> Entity {
+        let entity = self.ecs.spawn(entity);
+        if let Some(base) = entity.get::<MinecraftEntity<W>>() {
+            let mc_id = base.id;
+            self.id_to_entities.insert(mc_id, entity.id());
+        };
+        entity.id()
+    }
+
+    pub fn despawn(&mut self, entity: Entity) {
+        let entity = self.ecs.entity_mut(entity);
+        if let Some(base) = entity.get::<MinecraftEntity<W>>() {
+            self.id_to_entities.remove(&base.id);
+        }
+        entity.despawn();
+    }
+}