Use an ECS (#52)

* add EntityData::kind

* start making metadata use hecs

* make entity codegen generate ecs stuff

* fix registry codegen

* get rid of worldhaver

it's not even used

* add bevy_ecs to deps

* rename Component to FormattedText

also start making the metadata use bevy_ecs but bevy_ecs doesn't let you query on Bundles so it's annoying

* generate metadata.rs correctly for bevy_ecs

* start switching more entity stuff to use ecs

* more ecs stuff for entity storage

* ok well it compiles but

it definitely doesn't work

* random fixes

* change a bunch of entity things to use the components

* some ecs stuff in az-client

* packet handler uses the ecs now

and other fun changes

i still need to make ticking use the ecs but that's tricker, i'm considering using bevy_ecs systems for those

bevy_ecs systems can't be async but the only async things in ticking is just sending packets which can just be done as a tokio task so that's not a big deal

* start converting some functions in az-client into systems

committing because i'm about to try something that might go horribly wrong

* start splitting client

i'm probably gonna change it so azalea entity ids are separate from minecraft entity ids next (so stuff like player ids can be consistent and we don't have to wait for the login packet)

* separate minecraft entity ids from azalea entity ids + more ecs stuff

i guess i'm using bevy_app now too huh
it's necessary for plugins and it lets us control the tick rate anyways so it's fine i think

i'm still not 100% sure how packet handling that interacts with the world will work, but i think if i can sneak the ecs world into there it'll be fine. Can't put packet handling in the schedule because that'd make it tick-bound, which it's not (technically it'd still work but it'd be wrong and anticheats might realize).

* packet handling

now it runs the schedule only when we get a tick or packet :smile:

also i systemified some more functions and did other random fixes so az-world and az-physics compile

making azalea-client use the ecs is almost done! all the hard parts are done now i hope, i just have to finish writing all the code so it actually works

* start figuring out how functions in Client will work

generally just lifetimes being annoying but i think i can get it all to work

* make writing packets work synchronously*

* huh az-client compiles

* start fixing stuff

* start fixing some packets

* make packet handler work

i still haven't actually tested any of this yet lol but in theory it should all work

i'll probably either actually test az-client and fix all the remaining issues or update the azalea crate next

ok also one thing that i'm not particularly happy with is how the packet handlers are doing ugly queries like
```rs
let local_player = ecs
    .query::<&LocalPlayer>()
    .get_mut(ecs, player_entity)
    .unwrap();
```
i think the right way to solve it would be by putting every packet handler in its own system but i haven't come up with a way to make that not be really annoying yet

* fix warnings

* ok what if i just have a bunch of queries and a single packet handler system

* simple example for azalea-client

* :bug:

* maybe fix deadlock idk

can't test it rn lmao

* make physicsstate its own component

* use the default plugins

* azalea compiles lol

* use systemstate for packet handler

* fix entities

basically moved some stuff from being in the world to just being components

* physics (ticking) works

* try to add a .entity_by function

still doesn't work because i want to make the predicate magic

* try to make entity_by work

well it does work but i couldn't figure out how to make it look not terrible. Will hopefully change in the future

* everything compiles

* start converting swarm to use builder

* continue switching swarm to builder and fix stuff

* make swarm use builder

still have to fix some stuff and make client use builder

* fix death event

* client builder

* fix some warnings

* document plugins a bit

* start trying to fix tests

* azalea-ecs

* azalea-ecs stuff compiles

* az-physics tests pass :tada:

* fix all the tests

* clippy on azalea-ecs-macros

* remove now-unnecessary trait_upcasting feature

* fix some clippy::pedantic warnings lol

* why did cargo fmt not remove the trailing spaces

* FIX ALL THE THINGS

* when i said 'all' i meant non-swarm bugs

* start adding task pool

* fix entity deduplication

* fix pathfinder not stopping

* fix some more random bugs

* fix panic that sometimes happens in swarms

* make pathfinder run in task

* fix some tests

* fix doctests and clippy

* deadlock

* fix systems running in wrong order

* fix non-swarm bots

5 files changed, 527 insertions, 391 deletions

diff --git a/azalea-physics/src/collision/discrete_voxel_shape.rs b/azalea-physics/src/collision/discrete_voxel_shape.rs
index 51d45316..4a329398 100755
--- a/azalea-physics/src/collision/discrete_voxel_shape.rs
+++ b/azalea-physics/src/collision/discrete_voxel_shape.rs
@@ -64,7 +64,7 @@ impl DiscreteVoxelShape {
     }
 
     pub fn for_all_boxes(&self, consumer: impl IntLineConsumer, swap: bool) {
-        BitSetDiscreteVoxelShape::for_all_boxes(self, consumer, swap)
+        BitSetDiscreteVoxelShape::for_all_boxes(self, consumer, swap);
     }
 }
 
diff --git a/azalea-physics/src/collision/mod.rs b/azalea-physics/src/collision/mod.rs
index 458303c5..7d934020 100644
--- a/azalea-physics/src/collision/mod.rs
+++ b/azalea-physics/src/collision/mod.rs
@@ -5,13 +5,15 @@ mod shape;
 mod world_collisions;
 
 use azalea_core::{Axis, Vec3, AABB, EPSILON};
-use azalea_world::entity::{Entity, EntityData};
-use azalea_world::{MoveEntityError, WeakWorld};
+use azalea_world::{
+    entity::{self},
+    MoveEntityError, World,
+};
 pub use blocks::BlockWithShape;
 pub use discrete_voxel_shape::*;
 pub use shape::*;
-use std::ops::Deref;
-use world_collisions::CollisionGetter;
+
+use self::world_collisions::get_block_collisions;
 
 pub enum MoverType {
     Own,
@@ -21,192 +23,170 @@ pub enum MoverType {
     Shulker,
 }
 
-pub trait HasCollision {
-    fn collide(&self, movement: &Vec3, entity: &EntityData) -> Vec3;
-}
+// private Vec3 collide(Vec3 var1) {
+//     AABB var2 = this.getBoundingBox();
+//     List var3 = this.level.getEntityCollisions(this,
+// var2.expandTowards(var1));     Vec3 var4 = var1.lengthSqr() == 0.0D ?
+// var1 : collideBoundingBox(this, var1, var2, this.level, var3);
+//     boolean var5 = var1.x != var4.x;
+//     boolean var6 = var1.y != var4.y;
+//     boolean var7 = var1.z != var4.z;
+//     boolean var8 = this.onGround || var6 && var1.y < 0.0D;
+//     if (this.maxUpStep > 0.0F && var8 && (var5 || var7)) {
+//        Vec3 var9 = collideBoundingBox(this, new Vec3(var1.x,
+// (double)this.maxUpStep, var1.z), var2, this.level, var3);        Vec3
+// var10 = collideBoundingBox(this, new Vec3(0.0D, (double)this.maxUpStep,
+// 0.0D), var2.expandTowards(var1.x, 0.0D, var1.z), this.level, var3);
+//        if (var10.y < (double)this.maxUpStep) {
+//           Vec3 var11 = collideBoundingBox(this, new Vec3(var1.x, 0.0D,
+// var1.z), var2.move(var10), this.level, var3).add(var10);           if
+// (var11.horizontalDistanceSqr() > var9.horizontalDistanceSqr()) {
+//              var9 = var11;
+//           }
+//        }
+
+//        if (var9.horizontalDistanceSqr() > var4.horizontalDistanceSqr()) {
+//           return var9.add(collideBoundingBox(this, new Vec3(0.0D, -var9.y +
+// var1.y, 0.0D), var2.move(var9), this.level, var3));        }
+//     }
+
+//     return var4;
+// }
+fn collide(movement: &Vec3, world: &World, physics: &entity::Physics) -> Vec3 {
+    let entity_bounding_box = physics.bounding_box;
+    // TODO: get_entity_collisions
+    // let entity_collisions = world.get_entity_collisions(self,
+    // entity_bounding_box.expand_towards(movement));
+    let entity_collisions = Vec::new();
+    if movement.length_sqr() == 0.0 {
+        *movement
+    } else {
+        collide_bounding_box(movement, &entity_bounding_box, world, entity_collisions)
+    }
 
-pub trait MovableEntity {
-    fn move_colliding(
-        &mut self,
-        mover_type: &MoverType,
-        movement: &Vec3,
-    ) -> Result<(), MoveEntityError>;
+    // TODO: stepping (for stairs and stuff)
+
+    // collided_movement
 }
 
-impl<D: Deref<Target = WeakWorld>> HasCollision for D {
-    // private Vec3 collide(Vec3 var1) {
-    //     AABB var2 = this.getBoundingBox();
-    //     List var3 = this.level.getEntityCollisions(this,
-    // var2.expandTowards(var1));     Vec3 var4 = var1.lengthSqr() == 0.0D ?
-    // var1 : collideBoundingBox(this, var1, var2, this.level, var3);
-    //     boolean var5 = var1.x != var4.x;
-    //     boolean var6 = var1.y != var4.y;
-    //     boolean var7 = var1.z != var4.z;
-    //     boolean var8 = this.onGround || var6 && var1.y < 0.0D;
-    //     if (this.maxUpStep > 0.0F && var8 && (var5 || var7)) {
-    //        Vec3 var9 = collideBoundingBox(this, new Vec3(var1.x,
-    // (double)this.maxUpStep, var1.z), var2, this.level, var3);        Vec3
-    // var10 = collideBoundingBox(this, new Vec3(0.0D, (double)this.maxUpStep,
-    // 0.0D), var2.expandTowards(var1.x, 0.0D, var1.z), this.level, var3);
-    //        if (var10.y < (double)this.maxUpStep) {
-    //           Vec3 var11 = collideBoundingBox(this, new Vec3(var1.x, 0.0D,
-    // var1.z), var2.move(var10), this.level, var3).add(var10);           if
-    // (var11.horizontalDistanceSqr() > var9.horizontalDistanceSqr()) {
-    //              var9 = var11;
-    //           }
-    //        }
-
-    //        if (var9.horizontalDistanceSqr() > var4.horizontalDistanceSqr()) {
-    //           return var9.add(collideBoundingBox(this, new Vec3(0.0D, -var9.y +
-    // var1.y, 0.0D), var2.move(var9), this.level, var3));        }
+/// Move an entity by a given delta, checking for collisions.
+pub fn move_colliding(
+    _mover_type: &MoverType,
+    movement: &Vec3,
+    world: &World,
+    position: &mut entity::Position,
+    physics: &mut entity::Physics,
+) -> Result<(), MoveEntityError> {
+    // TODO: do all these
+
+    // if self.no_physics {
+    //     return;
+    // };
+
+    // if (var1 == MoverType.PISTON) {
+    //     var2 = this.limitPistonMovement(var2);
+    //     if (var2.equals(Vec3.ZERO)) {
+    //        return;
     //     }
+    // }
 
-    //     return var4;
+    // if (this.stuckSpeedMultiplier.lengthSqr() > 1.0E-7D) {
+    //     var2 = var2.multiply(this.stuckSpeedMultiplier);
+    //     this.stuckSpeedMultiplier = Vec3.ZERO;
+    //     this.setDeltaMovement(Vec3.ZERO);
     // }
-    fn collide(&self, movement: &Vec3, entity: &EntityData) -> Vec3 {
-        let entity_bounding_box = entity.bounding_box;
-        // TODO: get_entity_collisions
-        // let entity_collisions = world.get_entity_collisions(self,
-        // entity_bounding_box.expand_towards(movement));
-        let entity_collisions = Vec::new();
-        if movement.length_sqr() == 0.0 {
-            *movement
-        } else {
-            collide_bounding_box(
-                Some(entity),
-                movement,
-                &entity_bounding_box,
-                self,
-                entity_collisions,
-            )
-        }
 
-        // TODO: stepping (for stairs and stuff)
+    // movement = this.maybeBackOffFromEdge(movement, moverType);
 
-        // collided_movement
-    }
-}
+    let collide_result = collide(movement, world, physics);
 
-impl<D: Deref<Target = WeakWorld>> MovableEntity for Entity<'_, D> {
-    /// Move an entity by a given delta, checking for collisions.
-    fn move_colliding(
-        &mut self,
-        _mover_type: &MoverType,
-        movement: &Vec3,
-    ) -> Result<(), MoveEntityError> {
-        // TODO: do all these
-
-        // if self.no_physics {
-        //     return;
-        // };
-
-        // if (var1 == MoverType.PISTON) {
-        //     var2 = this.limitPistonMovement(var2);
-        //     if (var2.equals(Vec3.ZERO)) {
-        //        return;
-        //     }
-        // }
-
-        // if (this.stuckSpeedMultiplier.lengthSqr() > 1.0E-7D) {
-        //     var2 = var2.multiply(this.stuckSpeedMultiplier);
-        //     this.stuckSpeedMultiplier = Vec3.ZERO;
-        //     this.setDeltaMovement(Vec3.ZERO);
-        // }
-
-        // movement = this.maybeBackOffFromEdge(movement, moverType);
-
-        let collide_result = { self.world.collide(movement, self) };
-
-        let move_distance = collide_result.length_sqr();
-
-        if move_distance > EPSILON {
-            // TODO: fall damage
-
-            let new_pos = {
-                let entity_pos = self.pos();
-                Vec3 {
-                    x: entity_pos.x + collide_result.x,
-                    y: entity_pos.y + collide_result.y,
-                    z: entity_pos.z + collide_result.z,
-                }
-            };
-
-            self.world.set_entity_pos(self.id, new_pos)?;
-        }
+    let move_distance = collide_result.length_sqr();
+
+    if move_distance > EPSILON {
+        // TODO: fall damage
+
+        let new_pos = {
+            Vec3 {
+                x: position.x + collide_result.x,
+                y: position.y + collide_result.y,
+                z: position.z + collide_result.z,
+            }
+        };
 
-        let x_collision = movement.x != collide_result.x;
-        let z_collision = movement.z != collide_result.z;
-        let horizontal_collision = x_collision || z_collision;
-        let vertical_collision = movement.y != collide_result.y;
-        let on_ground = vertical_collision && movement.y < 0.;
-        self.on_ground = on_ground;
+        **position = new_pos;
+    }
 
-        // TODO: minecraft checks for a "minor" horizontal collision here
+    let x_collision = movement.x != collide_result.x;
+    let z_collision = movement.z != collide_result.z;
+    let horizontal_collision = x_collision || z_collision;
+    let vertical_collision = movement.y != collide_result.y;
+    let on_ground = vertical_collision && movement.y < 0.;
+    physics.on_ground = on_ground;
 
-        let _block_pos_below = self.on_pos_legacy();
-        // let _block_state_below = self
-        //     .world
-        //     .get_block_state(&block_pos_below)
-        //     .expect("Couldn't get block state below");
+    // TODO: minecraft checks for a "minor" horizontal collision here
 
-        // self.check_fall_damage(collide_result.y, on_ground, block_state_below,
-        // block_pos_below);
+    let _block_pos_below = entity::on_pos_legacy(&world.chunks, position);
+    // let _block_state_below = self
+    //     .world
+    //     .get_block_state(&block_pos_below)
+    //     .expect("Couldn't get block state below");
 
-        // if self.isRemoved() { return; }
+    // self.check_fall_damage(collide_result.y, on_ground, block_state_below,
+    // block_pos_below);
 
-        if horizontal_collision {
-            let delta_movement = &self.delta;
-            self.delta = Vec3 {
-                x: if x_collision { 0. } else { delta_movement.x },
-                y: delta_movement.y,
-                z: if z_collision { 0. } else { delta_movement.z },
-            }
-        }
+    // if self.isRemoved() { return; }
 
-        if vertical_collision {
-            // blockBelow.updateEntityAfterFallOn(this.level, this);
-            // the default implementation of updateEntityAfterFallOn sets the y movement to
-            // 0
-            self.delta.y = 0.;
+    if horizontal_collision {
+        let delta_movement = &physics.delta;
+        physics.delta = Vec3 {
+            x: if x_collision { 0. } else { delta_movement.x },
+            y: delta_movement.y,
+            z: if z_collision { 0. } else { delta_movement.z },
         }
+    }
 
-        if on_ground {
-            // blockBelow.stepOn(this.level, blockPosBelow, blockStateBelow,
-            // this);
-        }
+    if vertical_collision {
+        // blockBelow.updateEntityAfterFallOn(this.level, this);
+        // the default implementation of updateEntityAfterFallOn sets the y movement to
+        // 0
+        physics.delta.y = 0.;
+    }
+
+    if on_ground {
+        // blockBelow.stepOn(this.level, blockPosBelow, blockStateBelow,
+        // this);
+    }
 
-        // sounds
+    // sounds
 
-        // this.tryCheckInsideBlocks();
+    // this.tryCheckInsideBlocks();
 
-        // float var25 = this.getBlockSpeedFactor();
-        // this.setDeltaMovement(this.getDeltaMovement().multiply((double)var25, 1.0D,
-        // (double)var25)); if (this.level.getBlockStatesIfLoaded(this.
-        // getBoundingBox().deflate(1.0E-6D)).noneMatch((var0) -> {
-        //    return var0.is(BlockTags.FIRE) || var0.is(Blocks.LAVA);
-        // })) {
-        //    if (this.remainingFireTicks <= 0) {
-        //       this.setRemainingFireTicks(-this.getFireImmuneTicks());
-        //    }
+    // float var25 = this.getBlockSpeedFactor();
+    // this.setDeltaMovement(this.getDeltaMovement().multiply((double)var25, 1.0D,
+    // (double)var25)); if (this.level.getBlockStatesIfLoaded(this.
+    // getBoundingBox().deflate(1.0E-6D)).noneMatch((var0) -> {
+    //    return var0.is(BlockTags.FIRE) || var0.is(Blocks.LAVA);
+    // })) {
+    //    if (this.remainingFireTicks <= 0) {
+    //       this.setRemainingFireTicks(-this.getFireImmuneTicks());
+    //    }
 
-        //    if (this.wasOnFire && (this.isInPowderSnow ||
-        // this.isInWaterRainOrBubble())) {       this.
-        // playEntityOnFireExtinguishedSound();    }
-        // }
+    //    if (this.wasOnFire && (this.isInPowderSnow ||
+    // this.isInWaterRainOrBubble())) {       this.
+    // playEntityOnFireExtinguishedSound();    }
+    // }
 
-        // if (this.isOnFire() && (this.isInPowderSnow || this.isInWaterRainOrBubble()))
-        // {    this.setRemainingFireTicks(-this.getFireImmuneTicks());
-        // }
+    // if (this.isOnFire() && (this.isInPowderSnow || this.isInWaterRainOrBubble()))
+    // {    this.setRemainingFireTicks(-this.getFireImmuneTicks());
+    // }
 
-        Ok(())
-    }
+    Ok(())
 }
 
 fn collide_bounding_box(
-    entity: Option<&EntityData>,
     movement: &Vec3,
     entity_bounding_box: &AABB,
-    world: &WeakWorld,
+    world: &World,
     entity_collisions: Vec<VoxelShape>,
 ) -> Vec3 {
     let mut collision_boxes: Vec<VoxelShape> = Vec::with_capacity(entity_collisions.len() + 1);
@@ -218,7 +198,7 @@ fn collide_bounding_box(
     // TODO: world border
 
     let block_collisions =
-        world.get_block_collisions(entity, entity_bounding_box.expand_towards(movement));
+        get_block_collisions(world, entity_bounding_box.expand_towards(movement));
     let block_collisions = block_collisions.collect::<Vec<_>>();
     collision_boxes.extend(block_collisions);
     collide_with_shapes(movement, *entity_bounding_box, &collision_boxes)
diff --git a/azalea-physics/src/collision/shape.rs b/azalea-physics/src/collision/shape.rs
index bb2ed2e5..cc184591 100755
--- a/azalea-physics/src/collision/shape.rs
+++ b/azalea-physics/src/collision/shape.rs
@@ -539,7 +539,7 @@ impl VoxelShape {
                     x_coords[var7 as usize],
                     y_coords[var8 as usize],
                     z_coords[var9 as usize],
-                )
+                );
             },
             true,
         );
diff --git a/azalea-physics/src/collision/world_collisions.rs b/azalea-physics/src/collision/world_collisions.rs
index 9e238bf9..c7b2a91b 100644
--- a/azalea-physics/src/collision/world_collisions.rs
+++ b/azalea-physics/src/collision/world_collisions.rs
@@ -1,34 +1,17 @@
+use super::Shapes;
 use crate::collision::{BlockWithShape, VoxelShape, AABB};
 use azalea_block::BlockState;
 use azalea_core::{ChunkPos, ChunkSectionPos, Cursor3d, CursorIterationType, EPSILON};
-use azalea_world::entity::EntityData;
-use azalea_world::{Chunk, WeakWorld};
+use azalea_world::{Chunk, World};
 use parking_lot::RwLock;
 use std::sync::Arc;
 
-use super::Shapes;
-
-pub trait CollisionGetter {
-    fn get_block_collisions<'a>(
-        &'a self,
-        entity: Option<&EntityData>,
-        aabb: AABB,
-    ) -> BlockCollisions<'a>;
-}
-
-impl CollisionGetter for WeakWorld {
-    fn get_block_collisions<'a>(
-        &'a self,
-        entity: Option<&EntityData>,
-        aabb: AABB,
-    ) -> BlockCollisions<'a> {
-        BlockCollisions::new(self, entity, aabb)
-    }
+pub fn get_block_collisions(world: &World, aabb: AABB) -> BlockCollisions<'_> {
+    BlockCollisions::new(world, aabb)
 }
 
 pub struct BlockCollisions<'a> {
-    pub world: &'a WeakWorld,
-    // context: CollisionContext,
+    pub world: &'a World,
     pub aabb: AABB,
     pub entity_shape: VoxelShape,
     pub cursor: Cursor3d,
@@ -36,8 +19,7 @@ pub struct BlockCollisions<'a> {
 }
 
 impl<'a> BlockCollisions<'a> {
-    // TODO: the entity is stored in the context
-    pub fn new(world: &'a WeakWorld, _entity: Option<&EntityData>, aabb: AABB) -> Self {
+    pub fn new(world: &'a World, aabb: AABB) -> Self {
         let origin_x = (aabb.min_x - EPSILON) as i32 - 1;
         let origin_y = (aabb.min_y - EPSILON) as i32 - 1;
         let origin_z = (aabb.min_z - EPSILON) as i32 - 1;
@@ -75,7 +57,7 @@ impl<'a> BlockCollisions<'a> {
         //    return var7;
         // }
 
-        self.world.get_chunk(&chunk_pos)
+        self.world.chunks.get(&chunk_pos)
     }
 }
 
@@ -89,15 +71,14 @@ impl<'a> Iterator for BlockCollisions<'a> {
             }
 
             let chunk = self.get_chunk(item.pos.x, item.pos.z);
-            let chunk = match chunk {
-                Some(chunk) => chunk,
-                None => continue,
+            let Some(chunk) = chunk else {
+                continue
             };
 
             let pos = item.pos;
             let block_state: BlockState = chunk
                 .read()
-                .get(&(&pos).into(), self.world.min_y())
+                .get(&(&pos).into(), self.world.chunks.min_y)
                 .unwrap_or(BlockState::Air);
 
             // TODO: continue if self.only_suffocating_blocks and the block is not
diff --git a/azalea-physics/src/lib.rs b/azalea-physics/src/lib.rs
index 2409dff7..96bebd1a 100644
--- a/azalea-physics/src/lib.rs
+++ b/azalea-physics/src/lib.rs
@@ -5,24 +5,56 @@ pub mod collision;
 
 use azalea_block::{Block, BlockState};
 use azalea_core::{BlockPos, Vec3};
+use azalea_ecs::{
+    app::{App, Plugin},
+    entity::Entity,
+    event::{EventReader, EventWriter},
+    query::With,
+    schedule::{IntoSystemDescriptor, SystemSet},
+    system::{Query, Res},
+    AppTickExt,
+};
 use azalea_world::{
-    entity::{Entity, EntityData},
-    WeakWorld,
+    entity::{
+        metadata::Sprinting, move_relative, Attributes, Jumping, Physics, Position, WorldName,
+    },
+    Local, World, WorldContainer,
 };
-use collision::{MovableEntity, MoverType};
-use std::ops::Deref;
-
-pub trait HasPhysics {
-    fn travel(&mut self, acceleration: &Vec3);
-    fn ai_step(&mut self);
-
-    fn jump_from_ground(&mut self);
+use collision::{move_colliding, MoverType};
+
+pub struct PhysicsPlugin;
+impl Plugin for PhysicsPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_event::<ForceJumpEvent>()
+            .add_system(
+                force_jump_listener
+                    .label("force_jump_listener")
+                    .after("ai_step"),
+            )
+            .add_tick_system_set(
+                SystemSet::new()
+                    .with_system(ai_step.label("ai_step"))
+                    .with_system(
+                        travel
+                            .label("travel")
+                            .after("ai_step")
+                            .after("force_jump_listener"),
+                    ),
+            );
+    }
 }
 
-impl<D: Deref<Target = WeakWorld>> HasPhysics for Entity<'_, D> {
-    /// Move the entity with the given acceleration while handling friction,
-    /// gravity, collisions, and some other stuff.
-    fn travel(&mut self, acceleration: &Vec3) {
+/// Move the entity with the given acceleration while handling friction,
+/// gravity, collisions, and some other stuff.
+fn travel(
+    mut query: Query<(&mut Physics, &mut Position, &Attributes, &WorldName), With<Local>>,
+    world_container: Res<WorldContainer>,
+) {
+    for (mut physics, mut position, attributes, world_name) in &mut query {
+        let world_lock = world_container
+            .get(world_name)
+            .expect("All entities should be in a valid world");
+        let world = world_lock.read();
         // if !self.is_effective_ai() && !self.is_controlled_by_local_instance() {
         //     // this.calculateEntityAnimation(this, this instanceof FlyingAnimal);
         //     return;
@@ -37,24 +69,29 @@ impl<D: Deref<Target = WeakWorld>> HasPhysics for Entity<'_, D> {
 
         // TODO: elytra
 
-        let block_pos_below = get_block_pos_below_that_affects_movement(self);
+        let block_pos_below = get_block_pos_below_that_affects_movement(&position);
 
-        let block_state_below = self
-            .world
+        let block_state_below = world
+            .chunks
             .get_block_state(&block_pos_below)
             .unwrap_or(BlockState::Air);
         let block_below: Box<dyn Block> = block_state_below.into();
         let block_friction = block_below.behavior().friction;
 
-        let inertia = if self.on_ground {
+        let inertia = if physics.on_ground {
             block_friction * 0.91
         } else {
             0.91
         };
 
         // this applies the current delta
-        let mut movement =
-            handle_relative_friction_and_calculate_movement(self, acceleration, block_friction);
+        let mut movement = handle_relative_friction_and_calculate_movement(
+            block_friction,
+            &world,
+            &mut physics,
+            &mut position,
+            attributes,
+        );
 
         movement.y -= gravity;
 
@@ -66,96 +103,132 @@ impl<D: Deref<Target = WeakWorld>> HasPhysics for Entity<'_, D> {
 
         // if should_discard_friction(self) {
         if false {
-            self.delta = movement;
+            physics.delta = movement;
         } else {
-            self.delta = Vec3 {
+            physics.delta = Vec3 {
                 x: movement.x * inertia as f64,
                 y: movement.y * 0.98f64,
                 z: movement.z * inertia as f64,
             };
         }
     }
+}
 
-    /// applies air resistance, calls self.travel(), and some other random
-    /// stuff.
-    fn ai_step(&mut self) {
+/// applies air resistance, calls self.travel(), and some other random
+/// stuff.
+pub fn ai_step(
+    mut query: Query<
+        (Entity, &mut Physics, Option<&Jumping>),
+        With<Local>,
+        // TODO: ai_step should only run for players in loaded chunks
+        // With<LocalPlayerInLoadedChunk> maybe there should be an InLoadedChunk/InUnloadedChunk
+        // component?
+    >,
+    mut force_jump_events: EventWriter<ForceJumpEvent>,
+) {
+    for (entity, mut physics, jumping) in &mut query {
         // vanilla does movement interpolation here, doesn't really matter much for a
         // bot though
 
-        if self.delta.x.abs() < 0.003 {
-            self.delta.x = 0.;
+        if physics.delta.x.abs() < 0.003 {
+            physics.delta.x = 0.;
         }
-        if self.delta.y.abs() < 0.003 {
-            self.delta.y = 0.;
+        if physics.delta.y.abs() < 0.003 {
+            physics.delta.y = 0.;
         }
-        if self.delta.z.abs() < 0.003 {
-            self.delta.z = 0.;
+        if physics.delta.z.abs() < 0.003 {
+            physics.delta.z = 0.;
         }
 
-        if self.jumping {
-            // TODO: jumping in liquids and jump delay
+        if let Some(jumping) = jumping {
+            if **jumping {
+                // TODO: jumping in liquids and jump delay
 
-            if self.on_ground {
-                self.jump_from_ground();
+                if physics.on_ground {
+                    force_jump_events.send(ForceJumpEvent(entity));
+                }
             }
         }
 
-        self.xxa *= 0.98;
-        self.zza *= 0.98;
-
-        self.travel(&Vec3 {
-            x: self.xxa as f64,
-            y: self.yya as f64,
-            z: self.zza as f64,
-        });
-        // freezing
-        // pushEntities
-        // drowning damage
+        physics.xxa *= 0.98;
+        physics.zza *= 0.98;
+
+        // TODO: freezing, pushEntities, drowning damage (in their own systems,
+        // after `travel`)
     }
+}
 
-    fn jump_from_ground(&mut self) {
-        let jump_power: f64 = jump_power(self) as f64 + jump_boost_power(self);
-        let old_delta_movement = self.delta;
-        self.delta = Vec3 {
-            x: old_delta_movement.x,
-            y: jump_power,
-            z: old_delta_movement.z,
-        };
-        if self.metadata.sprinting {
-            let y_rot = self.y_rot * 0.017453292;
-            self.delta += Vec3 {
-                x: (-f32::sin(y_rot) * 0.2) as f64,
-                y: 0.,
-                z: (f32::cos(y_rot) * 0.2) as f64,
+/// Jump even if we aren't on the ground.
+pub struct ForceJumpEvent(pub Entity);
+
+fn force_jump_listener(
+    mut query: Query<(&mut Physics, &Position, &Sprinting, &WorldName)>,
+    world_container: Res<WorldContainer>,
+    mut events: EventReader<ForceJumpEvent>,
+) {
+    for event in events.iter() {
+        if let Ok((mut physics, position, sprinting, world_name)) = query.get_mut(event.0) {
+            let world_lock = world_container
+                .get(world_name)
+                .expect("All entities should be in a valid world");
+            let world = world_lock.read();
+
+            let jump_power: f64 = jump_power(&world, position) as f64 + jump_boost_power();
+            let old_delta_movement = physics.delta;
+            physics.delta = Vec3 {
+                x: old_delta_movement.x,
+                y: jump_power,
+                z: old_delta_movement.z,
             };
-        }
+            if **sprinting {
+                // sprint jumping gives some extra velocity
+                let y_rot = physics.y_rot * 0.017453292;
+                physics.delta += Vec3 {
+                    x: (-f32::sin(y_rot) * 0.2) as f64,
+                    y: 0.,
+                    z: (f32::cos(y_rot) * 0.2) as f64,
+                };
+            }
 
-        self.has_impulse = true;
+            physics.has_impulse = true;
+        }
     }
 }
 
-fn get_block_pos_below_that_affects_movement(entity: &EntityData) -> BlockPos {
+fn get_block_pos_below_that_affects_movement(position: &Position) -> BlockPos {
     BlockPos::new(
-        entity.pos().x.floor() as i32,
+        position.x.floor() as i32,
         // TODO: this uses bounding_box.min_y instead of position.y
-        (entity.pos().y - 0.5f64).floor() as i32,
-        entity.pos().z.floor() as i32,
+        (position.y - 0.5f64).floor() as i32,
+        position.z.floor() as i32,
     )
 }
 
-fn handle_relative_friction_and_calculate_movement<D: Deref<Target = WeakWorld>>(
-    entity: &mut Entity<D>,
-    acceleration: &Vec3,
+fn handle_relative_friction_and_calculate_movement(
     block_friction: f32,
+    world: &World,
+    physics: &mut Physics,
+    position: &mut Position,
+    attributes: &Attributes,
 ) -> Vec3 {
-    entity.move_relative(
-        get_friction_influenced_speed(&*entity, block_friction),
-        acceleration,
+    move_relative(
+        physics,
+        get_friction_influenced_speed(physics, attributes, block_friction),
+        &Vec3 {
+            x: physics.xxa as f64,
+            y: physics.yya as f64,
+            z: physics.zza as f64,
+        },
     );
     // entity.delta = entity.handle_on_climbable(entity.delta);
-    entity
-        .move_colliding(&MoverType::Own, &entity.delta.clone())
-        .expect("Entity should exist.");
+    move_colliding(
+        &MoverType::Own,
+        &physics.delta.clone(),
+        world,
+        position,
+        physics,
+    )
+    .expect("Entity should exist.");
     // let delta_movement = entity.delta;
     // ladders
     //   if ((entity.horizontalCollision || entity.jumping) && (entity.onClimbable()
@@ -164,16 +237,16 @@ fn handle_relative_friction_and_calculate_movement<D: Deref<Target = WeakWorld>>
     // Vec3(var3.x, 0.2D, var3.z);   }
     // TODO: powdered snow
 
-    entity.delta
+    physics.delta
 }
 
 // private float getFrictionInfluencedSpeed(float friction) {
 //     return this.onGround ? this.getSpeed() * (0.21600002F / (friction *
 // friction * friction)) : this.flyingSpeed; }
-fn get_friction_influenced_speed(entity: &EntityData, friction: f32) -> f32 {
+fn get_friction_influenced_speed(physics: &Physics, attributes: &Attributes, friction: f32) -> f32 {
     // TODO: have speed & flying_speed fields in entity
-    if entity.on_ground {
-        let speed: f32 = entity.attributes.speed.calculate() as f32;
+    if physics.on_ground {
+        let speed: f32 = attributes.speed.calculate() as f32;
         speed * (0.216f32 / (friction * friction * friction))
     } else {
         // entity.flying_speed
@@ -183,11 +256,11 @@ fn get_friction_influenced_speed(entity: &EntityData, friction: f32) -> f32 {
 
 /// Returns the what the entity's jump should be multiplied by based on the
 /// block they're standing on.
-fn block_jump_factor<D: Deref<Target = WeakWorld>>(entity: &Entity<D>) -> f32 {
-    let block_at_pos = entity.world.get_block_state(&entity.pos().into());
-    let block_below = entity
-        .world
-        .get_block_state(&get_block_pos_below_that_affects_movement(entity));
+fn block_jump_factor(world: &World, position: &Position) -> f32 {
+    let block_at_pos = world.chunks.get_block_state(&position.into());
+    let block_below = world
+        .chunks
+        .get_block_state(&get_block_pos_below_that_affects_movement(position));
 
     let block_at_pos_jump_factor = if let Some(block) = block_at_pos {
         Box::<dyn Block>::from(block).behavior().jump_factor
@@ -211,11 +284,11 @@ fn block_jump_factor<D: Deref<Target = WeakWorld>>(entity: &Entity<D>) -> f32 {
 // public double getJumpBoostPower() {
 //     return this.hasEffect(MobEffects.JUMP) ? (double)(0.1F *
 // (float)(this.getEffect(MobEffects.JUMP).getAmplifier() + 1)) : 0.0D; }
-fn jump_power<D: Deref<Target = WeakWorld>>(entity: &Entity<D>) -> f32 {
-    0.42 * block_jump_factor(entity)
+fn jump_power(world: &World, position: &Position) -> f32 {
+    0.42 * block_jump_factor(world, position)
 }
 
-fn jump_boost_power<D: Deref<Target = WeakWorld>>(_entity: &Entity<D>) -> f64 {
+fn jump_boost_power() -> f64 {
     // TODO: potion effects
     // if let Some(effects) = entity.effects() {
     //     if let Some(jump_effect) = effects.get(&Effect::Jump) {
@@ -231,131 +304,218 @@ fn jump_boost_power<D: Deref<Target = WeakWorld>>(_entity: &Entity<D>) -> f64 {
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
+
     use super::*;
-    use azalea_core::ChunkPos;
+    use azalea_core::{ChunkPos, ResourceLocation};
+    use azalea_ecs::{app::App, TickPlugin};
     use azalea_world::{
-        entity::{metadata, EntityMetadata},
-        Chunk, PartialWorld,
+        entity::{EntityBundle, MinecraftEntityId},
+        Chunk, EntityPlugin, PartialWorld,
     };
     use uuid::Uuid;
 
+    /// You need an app to spawn entities in the world and do updates.
+    fn make_test_app() -> App {
+        let mut app = App::new();
+        app.add_plugin(TickPlugin {
+            tick_interval: Duration::ZERO,
+        })
+        .add_plugin(PhysicsPlugin)
+        .add_plugin(EntityPlugin)
+        .init_resource::<WorldContainer>();
+        app
+    }
+
     #[test]
     fn test_gravity() {
-        let mut world = PartialWorld::default();
-
-        world.add_entity(
-            0,
-            EntityData::new(
-                Uuid::nil(),
-                Vec3 {
-                    x: 0.,
-                    y: 70.,
-                    z: 0.,
-                },
-                EntityMetadata::Player(metadata::Player::default()),
-            ),
-        );
-        let mut entity = world.entity_mut(0).unwrap();
-        // y should start at 70
-        assert_eq!(entity.pos().y, 70.);
-        entity.ai_step();
-        // delta is applied before gravity, so the first tick only sets the delta
-        assert_eq!(entity.pos().y, 70.);
-        assert!(entity.delta.y < 0.);
-        entity.ai_step();
-        // the second tick applies the delta to the position, so now it should go down
-        assert!(
-            entity.pos().y < 70.,
-            "Entity y ({}) didn't go down after physics steps",
-            entity.pos().y
+        let mut app = make_test_app();
+        let _world_lock = app.world.resource_mut::<WorldContainer>().insert(
+            ResourceLocation::new("minecraft:overworld").unwrap(),
+            384,
+            -64,
         );
+
+        let entity = app
+            .world
+            .spawn((
+                EntityBundle::new(
+                    Uuid::nil(),
+                    Vec3 {
+                        x: 0.,
+                        y: 70.,
+                        z: 0.,
+                    },
+                    azalea_registry::EntityKind::Zombie,
+                    ResourceLocation::new("minecraft:overworld").unwrap(),
+                ),
+                MinecraftEntityId(0),
+                Local,
+            ))
+            .id();
+        {
+            let entity_pos = *app.world.get::<Position>(entity).unwrap();
+            // y should start at 70
+            assert_eq!(entity_pos.y, 70.);
+        }
+        app.update();
+        {
+            let entity_pos = *app.world.get::<Position>(entity).unwrap();
+            // delta is applied before gravity, so the first tick only sets the delta
+            assert_eq!(entity_pos.y, 70.);
+            let entity_physics = app.world.get::<Physics>(entity).unwrap().clone();
+            assert!(entity_physics.delta.y < 0.);
+        }
+        app.update();
+        {
+            let entity_pos = *app.world.get::<Position>(entity).unwrap();
+            // the second tick applies the delta to the position, so now it should go down
+            assert!(
+                entity_pos.y < 70.,
+                "Entity y ({}) didn't go down after physics steps",
+                entity_pos.y
+            );
+        }
     }
     #[test]
     fn test_collision() {
-        let mut world = PartialWorld::default();
-        world
-            .set_chunk(&ChunkPos { x: 0, z: 0 }, Some(Chunk::default()))
-            .unwrap();
-        world.add_entity(
-            0,
-            EntityData::new(
-                Uuid::nil(),
-                Vec3 {
-                    x: 0.5,
-                    y: 70.,
-                    z: 0.5,
-                },
-                EntityMetadata::Player(metadata::Player::default()),
-            ),
+        let mut app = make_test_app();
+        let world_lock = app.world.resource_mut::<WorldContainer>().insert(
+            ResourceLocation::new("minecraft:overworld").unwrap(),
+            384,
+            -64,
+        );
+        let mut partial_world = PartialWorld::default();
+
+        partial_world.chunks.set(
+            &ChunkPos { x: 0, z: 0 },
+            Some(Chunk::default()),
+            &mut world_lock.write().chunks,
+        );
+        let entity = app
+            .world
+            .spawn((
+                EntityBundle::new(
+                    Uuid::nil(),
+                    Vec3 {
+                        x: 0.5,
+                        y: 70.,
+                        z: 0.5,
+                    },
+                    azalea_registry::EntityKind::Player,
+                    ResourceLocation::new("minecraft:overworld").unwrap(),
+                ),
+                MinecraftEntityId(0),
+                Local,
+            ))
+            .id();
+        let block_state = partial_world.chunks.set_block_state(
+            &BlockPos { x: 0, y: 69, z: 0 },
+            BlockState::Stone,
+            &mut world_lock.write().chunks,
         );
-        let block_state = world.set_block_state(&BlockPos { x: 0, y: 69, z: 0 }, BlockState::Stone);
         assert!(
             block_state.is_some(),
             "Block state should exist, if this fails that means the chunk wasn't loaded and the block didn't get placed"
         );
-        let mut entity = world.entity_mut(0).unwrap();
-        entity.ai_step();
-        // delta will change, but it won't move until next tick
-        assert_eq!(entity.pos().y, 70.);
-        assert!(entity.delta.y < 0.);
-        entity.ai_step();
-        // the second tick applies the delta to the position, but it also does collision
-        assert_eq!(entity.pos().y, 70.);
+        app.update();
+        {
+            let entity_pos = *app.world.get::<Position>(entity).unwrap();
+            // delta will change, but it won't move until next tick
+            assert_eq!(entity_pos.y, 70.);
+            let entity_physics = app.world.get::<Physics>(entity).unwrap().clone();
+            assert!(entity_physics.delta.y < 0.);
+        }
+        app.update();
+        {
+            let entity_pos = *app.world.get::<Position>(entity).unwrap();
+            // the second tick applies the delta to the position, but it also does collision
+            assert_eq!(entity_pos.y, 70.);
+        }
     }
 
     #[test]
     fn test_slab_collision() {
-        let mut world = PartialWorld::default();
-        world
-            .set_chunk(&ChunkPos { x: 0, z: 0 }, Some(Chunk::default()))
-            .unwrap();
-        world.add_entity(
-            0,
-            EntityData::new(
-                Uuid::nil(),
-                Vec3 {
-                    x: 0.5,
-                    y: 71.,
-                    z: 0.5,
-                },
-                EntityMetadata::Player(metadata::Player::default()),
-            ),
+        let mut app = make_test_app();
+        let world_lock = app.world.resource_mut::<WorldContainer>().insert(
+            ResourceLocation::new("minecraft:overworld").unwrap(),
+            384,
+            -64,
         );
-        let block_state = world.set_block_state(
+        let mut partial_world = PartialWorld::default();
+
+        partial_world.chunks.set(
+            &ChunkPos { x: 0, z: 0 },
+            Some(Chunk::default()),
+            &mut world_lock.write().chunks,
+        );
+        let entity = app
+            .world
+            .spawn((
+                EntityBundle::new(
+                    Uuid::nil(),
+                    Vec3 {
+                        x: 0.5,
+                        y: 71.,
+                        z: 0.5,
+                    },
+                    azalea_registry::EntityKind::Player,
+                    ResourceLocation::new("minecraft:overworld").unwrap(),
+                ),
+                MinecraftEntityId(0),
+                Local,
+            ))
+            .id();
+        let block_state = partial_world.chunks.set_block_state(
             &BlockPos { x: 0, y: 69, z: 0 },
             BlockState::StoneSlab_BottomFalse,
+            &mut world_lock.write().chunks,
         );
         assert!(
             block_state.is_some(),
             "Block state should exist, if this fails that means the chunk wasn't loaded and the block didn't get placed"
         );
-        let mut entity = world.entity_mut(0).unwrap();
         // do a few steps so we fall on the slab
         for _ in 0..20 {
-            entity.ai_step();
+            app.update();
         }
-        assert_eq!(entity.pos().y, 69.5);
+        let entity_pos = app.world.get::<Position>(entity).unwrap();
+        assert_eq!(entity_pos.y, 69.5);
     }
 
     #[test]
     fn test_top_slab_collision() {
-        let mut world = PartialWorld::default();
-        world
-            .set_chunk(&ChunkPos { x: 0, z: 0 }, Some(Chunk::default()))
-            .unwrap();
-        world.add_entity(
-            0,
-            EntityData::new(
-                Uuid::nil(),
-                Vec3 {
-                    x: 0.5,
-                    y: 71.,
-                    z: 0.5,
-                },
-                EntityMetadata::Player(metadata::Player::default()),
-            ),
+        let mut app = make_test_app();
+        let world_lock = app.world.resource_mut::<WorldContainer>().insert(
+            ResourceLocation::new("minecraft:overworld").unwrap(),
+            384,
+            -64,
+        );
+        let mut partial_world = PartialWorld::default();
+
+        partial_world.chunks.set(
+            &ChunkPos { x: 0, z: 0 },
+            Some(Chunk::default()),
+            &mut world_lock.write().chunks,
         );
-        let block_state = world.set_block_state(
+        let entity = app
+            .world
+            .spawn((
+                EntityBundle::new(
+                    Uuid::nil(),
+                    Vec3 {
+                        x: 0.5,
+                        y: 71.,
+                        z: 0.5,
+                    },
+                    azalea_registry::EntityKind::Player,
+                    ResourceLocation::new("minecraft:overworld").unwrap(),
+                ),
+                MinecraftEntityId(0),
+                Local,
+            ))
+            .id();
+        let block_state = world_lock.write().chunks.set_block_state(
             &BlockPos { x: 0, y: 69, z: 0 },
             BlockState::StoneSlab_TopFalse,
         );
@@ -363,33 +523,47 @@ mod tests {
             block_state.is_some(),
             "Block state should exist, if this fails that means the chunk wasn't loaded and the block didn't get placed"
         );
-        let mut entity = world.entity_mut(0).unwrap();
         // do a few steps so we fall on the slab
         for _ in 0..20 {
-            entity.ai_step();
+            app.update();
         }
-        assert_eq!(entity.pos().y, 70.);
+        let entity_pos = app.world.get::<Position>(entity).unwrap();
+        assert_eq!(entity_pos.y, 70.);
     }
 
     #[test]
     fn test_weird_wall_collision() {
-        let mut world = PartialWorld::default();
-        world
-            .set_chunk(&ChunkPos { x: 0, z: 0 }, Some(Chunk::default()))
-            .unwrap();
-        world.add_entity(
-            0,
-            EntityData::new(
-                Uuid::nil(),
-                Vec3 {
-                    x: 0.5,
-                    y: 73.,
-                    z: 0.5,
-                },
-                EntityMetadata::Player(metadata::Player::default()),
-            ),
+        let mut app = make_test_app();
+        let world_lock = app.world.resource_mut::<WorldContainer>().insert(
+            ResourceLocation::new("minecraft:overworld").unwrap(),
+            384,
+            -64,
+        );
+        let mut partial_world = PartialWorld::default();
+
+        partial_world.chunks.set(
+            &ChunkPos { x: 0, z: 0 },
+            Some(Chunk::default()),
+            &mut world_lock.write().chunks,
         );
-        let block_state = world.set_block_state(
+        let entity = app
+            .world
+            .spawn((
+                EntityBundle::new(
+                    Uuid::nil(),
+                    Vec3 {
+                        x: 0.5,
+                        y: 73.,
+                        z: 0.5,
+                    },
+                    azalea_registry::EntityKind::Player,
+                    ResourceLocation::new("minecraft:overworld").unwrap(),
+                ),
+                MinecraftEntityId(0),
+                Local,
+            ))
+            .id();
+        let block_state = world_lock.write().chunks.set_block_state(
             &BlockPos { x: 0, y: 69, z: 0 },
             BlockState::CobblestoneWall_LowLowLowFalseFalseLow,
         );
@@ -397,11 +571,12 @@ mod tests {
             block_state.is_some(),
             "Block state should exist, if this fails that means the chunk wasn't loaded and the block didn't get placed"
         );
-        let mut entity = world.entity_mut(0).unwrap();
         // do a few steps so we fall on the slab
         for _ in 0..20 {
-            entity.ai_step();
+            app.update();
         }
-        assert_eq!(entity.pos().y, 70.5);
+
+        let entity_pos = app.world.get::<Position>(entity).unwrap();
+        assert_eq!(entity_pos.y, 70.5);
     }
 }