Refactor Entity

pumpkin/src/entity/mod.rs

@@ -1 +1,195 @@
+use std::sync::Arc;
+
+use pumpkin_core::math::{
+    get_section_cord, position::WorldPosition, vector2::Vector2, vector3::Vector3,
+};
+use pumpkin_entity::{entity_type::EntityType, pose::EntityPose, EntityId};
+use pumpkin_protocol::{
+    client::play::{CSetEntityMetadata, Metadata},
+    VarInt,
+};
+
+use crate::{client::Client, world::World};
+
 pub mod player;
+
+pub struct Entity {
+    pub entity_id: EntityId,
+    pub entity_type: EntityType,
+    pub pos: Vector3<f64>,
+    pub block_pos: WorldPosition,
+    pub chunk_pos: Vector2<i32>,
+
+    pub sneaking: bool,
+    pub sprinting: bool,
+    pub fall_flying: bool,
+    pub velocity: Vector3<f64>,
+
+    // Should be not trusted
+    pub on_ground: bool,
+
+    pub yaw: f32,
+    pub head_yaw: f32,
+    pub pitch: f32,
+    // TODO: Change this in diffrent poses
+    pub standing_eye_height: f32,
+    pub pose: EntityPose,
+}
+
+// TODO: Remove client: &mut Client, world: Arc<tokio::sync::Mutex<World>> bs
+impl Entity {
+    pub fn new(entity_id: EntityId, entity_type: EntityType, standing_eye_height: f32) -> Self {
+        Self {
+            entity_id,
+            entity_type,
+            on_ground: false,
+            pos: Vector3::new(0.0, 0.0, 0.0),
+            block_pos: WorldPosition(Vector3::new(0, 0, 0)),
+            chunk_pos: Vector2::new(0, 0),
+            sneaking: false,
+            sprinting: false,
+            fall_flying: false,
+            yaw: 0.0,
+            head_yaw: 0.0,
+            pitch: 0.0,
+            velocity: Vector3::new(0.0, 0.0, 0.0),
+            standing_eye_height,
+            pose: EntityPose::Standing,
+        }
+    }
+
+    pub fn set_pos(&mut self, x: f64, y: f64, z: f64) {
+        if self.pos.x != x || self.pos.y != y || self.pos.z != z {
+            self.pos = Vector3::new(x, y, z);
+            let i = x.floor() as i32;
+            let j = y.floor() as i32;
+            let k = z.floor() as i32;
+
+            let block_pos = self.block_pos.0;
+            if i != block_pos.x || j != block_pos.y || k != block_pos.z {
+                self.block_pos = WorldPosition(Vector3::new(i, j, k));
+
+                if get_section_cord(i) != self.chunk_pos.x
+                    || get_section_cord(k) != self.chunk_pos.z
+                {
+                    self.chunk_pos =
+                        Vector2::new(get_section_cord(block_pos.x), get_section_cord(block_pos.z));
+                }
+            }
+        }
+    }
+
+    pub fn knockback(&mut self, strength: f64, x: f64, z: f64) {
+        // This has some vanilla magic
+        let mut x = x;
+        let mut z = z;
+        while x * x + z * z < 1.0E-5 {
+            x = (rand::random::<f64>() - rand::random::<f64>()) * 0.01;
+            z = (rand::random::<f64>() - rand::random::<f64>()) * 0.01;
+        }
+
+        let var8 = Vector3::new(x, 0.0, z).normalize() * strength;
+        let var7 = self.velocity;
+        self.velocity = Vector3::new(
+            var7.x / 2.0 - var8.x,
+            if self.on_ground {
+                (var7.y / 2.0 + strength).min(0.4)
+            } else {
+                var7.y
+            },
+            var7.z / 2.0 - var8.z,
+        );
+    }
+
+    pub async fn set_sneaking(
+        &mut self,
+        client: &mut Client,
+        world: Arc<tokio::sync::Mutex<World>>,
+        sneaking: bool,
+    ) {
+        assert!(self.sneaking != sneaking);
+        self.sneaking = sneaking;
+        self.set_flag(client, world, Self::SNEAKING_FLAG_INDEX, sneaking)
+            .await;
+        // if sneaking {
+        //     self.set_pose(EntityPose::Crouching).await;
+        // } else {
+        //     self.set_pose(EntityPose::Standing).await;
+        // }
+    }
+
+    pub async fn set_sprinting(
+        &mut self,
+        client: &mut Client,
+        world: Arc<tokio::sync::Mutex<World>>,
+        sprinting: bool,
+    ) {
+        assert!(self.sprinting != sprinting);
+        self.sprinting = sprinting;
+        self.set_flag(client, world, Self::SPRINTING_FLAG_INDEX, sprinting)
+            .await;
+    }
+
+    pub fn check_fall_flying(&self) -> bool {
+        !self.on_ground
+    }
+
+    pub async fn set_fall_flying(
+        &mut self,
+        client: &mut Client,
+        world: Arc<tokio::sync::Mutex<World>>,
+        fall_flying: bool,
+    ) {
+        assert!(self.fall_flying != fall_flying);
+        self.fall_flying = fall_flying;
+        self.set_flag(client, world, Self::FALL_FLYING_FLAG_INDEX, fall_flying)
+            .await;
+    }
+
+    pub const ON_FIRE_FLAG_INDEX: u32 = 0;
+    pub const SNEAKING_FLAG_INDEX: u32 = 1;
+    pub const SPRINTING_FLAG_INDEX: u32 = 3;
+    pub const SWIMMING_FLAG_INDEX: u32 = 4;
+    pub const INVISIBLE_FLAG_INDEX: u32 = 5;
+    pub const GLOWING_FLAG_INDEX: u32 = 6;
+    pub const FALL_FLYING_FLAG_INDEX: u32 = 7;
+    async fn set_flag(
+        &mut self,
+        client: &mut Client,
+        world: Arc<tokio::sync::Mutex<World>>,
+        index: u32,
+        value: bool,
+    ) {
+        let mut b = 0i8;
+        if value {
+            b |= 1 << index;
+        } else {
+            b &= !(1 << index);
+        }
+        let packet = CSetEntityMetadata::new(self.entity_id.into(), Metadata::new(0, 0.into(), b));
+        client.send_packet(&packet);
+        world
+            .lock()
+            .await
+            .broadcast_packet(&[client.token], &packet);
+    }
+
+    pub async fn set_pose(
+        &mut self,
+        client: &mut Client,
+        world: Arc<tokio::sync::Mutex<World>>,
+        pose: EntityPose,
+    ) {
+        self.pose = pose;
+        let pose = self.pose as i32;
+        let packet = CSetEntityMetadata::<VarInt>::new(
+            self.entity_id.into(),
+            Metadata::new(6, 20.into(), (pose).into()),
+        );
+        client.send_packet(&packet);
+        world
+            .lock()
+            .await
+            .broadcast_packet(&[client.token], &packet)
+    }
+}