From 19fc75b0e1c2961723fe7dca7e55539ba9b21dcd Mon Sep 17 00:00:00 2001
From: Sergei Surovtsev <ssurovsev@gmail.com>
Date: Mon, 1 Jan 2024 14:12:19 +0300
Subject: [PATCH] refactoring

---
 src/components.rs | 106 ------------
 src/controls.rs   |   5 +-
 src/enemies.rs    | 411 ----------------------------------------------
 src/events.rs     | 116 +------------
 src/gameplay.rs   |   4 +-
 src/items.rs      | 264 -----------------------------
 src/ldtk.rs       |  98 +++++------
 src/main.rs       |  39 +----
 src/sprites.rs    |  52 +++++-
 9 files changed, 108 insertions(+), 987 deletions(-)
 delete mode 100644 src/enemies.rs
 delete mode 100644 src/items.rs

diff --git a/src/components.rs b/src/components.rs
index a682b58..5a52a1b 100644
--- a/src/components.rs
+++ b/src/components.rs
@@ -2,12 +2,6 @@ use bevy::prelude::*;
 use bevy_ecs_ldtk::prelude::*;
 use bevy_rapier2d::prelude::*;
 
-use crate::{
-    enemies::{create_mierda_bundle, Mierda},
-    items::{create_pizza_bundle, Pizza},
-    sprites::*,
-};
-
 #[derive(Clone, Debug, Default, Bundle, LdtkIntCell)]
 pub struct ColliderBundle {
     pub collider: Collider,
@@ -37,103 +31,3 @@ impl From<&EntityInstance> for ColliderBundle {
         }
     }
 }
-
-#[derive(Copy, Clone, Eq, PartialEq, Debug, Default, Component, Reflect)]
-pub struct Player {
-    pub health: u8,
-}
-
-#[derive(Default, Bundle)]
-pub struct PlayerBundle {
-    pub sprite_bundle: SpriteSheetBundle,
-    pub character_animation: CharacterAnimation,
-    pub animation_timer: AnimationTimer,
-    pub player: Player,
-    pub collider_bundle: ColliderBundle,
-    pub active_events: ActiveEvents,
-    // pub particle_system_bundle: ParticleSystemBundle,
-}
-
-#[derive(Copy, Clone, Eq, PartialEq, Debug, Default, Component)]
-pub struct Wall;
-
-#[derive(Clone, Debug, Default, Bundle, LdtkIntCell)]
-pub struct WallBundle {
-    wall: Wall,
-    sensor: Sensor,
-}
-
-impl FromWorld for PlayerSpritesheets {
-    fn from_world(world: &mut World) -> Self {
-        let world = world.cell();
-
-        let asset_server_world_borrow = world.get_resource::<AssetServer>();
-        let asset_server = asset_server_world_borrow.as_deref().unwrap();
-
-        let mut texture_atlasses_world_borrow = world.get_resource_mut::<Assets<TextureAtlas>>();
-        let texture_atlasses = texture_atlasses_world_borrow.as_deref_mut().unwrap();
-
-        let player_atlas_1 = load_texture_atlas(
-            PLAYER_ASSET_SHEET_1,
-            asset_server,
-            SHEET_1_COLUMNS,
-            SHEET_1_ROWS,
-            None,
-            64.,
-            texture_atlasses,
-        );
-
-        let player_atlas_2 = load_texture_atlas(
-            PLAYER_ASSET_SHEET_2,
-            asset_server,
-            SHEET_2_COLUMNS,
-            SHEET_2_ROWS,
-            None,
-            64. * 3.,
-            texture_atlasses,
-        );
-
-        let mierda_atlas = load_texture_atlas(
-            MIERDA_ASSET_SHEET,
-            asset_server,
-            5,
-            1,
-            None,
-            16.0,
-            texture_atlasses,
-        );
-
-        PlayerSpritesheets {
-            player_atlas_1,
-            player_atlas_2,
-            mierda_atlas,
-        }
-    }
-}
-
-pub(crate) fn fix_missing_ldtk_entities(
-    asset_server: Res<AssetServer>,
-    texture_atlasses: ResMut<Assets<TextureAtlas>>,
-    mut commands: Commands,
-    los_mierdas: Query<(Entity, &Mierda), Without<Collider>>,
-    los_pizzas: Query<(Entity, &Pizza), Without<Collider>>,
-) {
-    let asset_server = asset_server.into_inner();
-    let texture_atlasses = texture_atlasses.into_inner();
-
-    for (e, _) in los_mierdas.iter().filter(|(_, m)| !m.is_dummy) {
-        let bundle = create_mierda_bundle(asset_server, texture_atlasses, false);
-        commands.entity(e).insert((
-            bundle.collider_bundle,
-            bundle.direction_update_time,
-            Visibility::Visible,
-        ));
-    }
-
-    for (e, _) in los_pizzas.iter().filter(|(_, m)| !m.is_dummy) {
-        let bundle = create_pizza_bundle(asset_server, texture_atlasses, false);
-        commands
-            .entity(e)
-            .insert((bundle.collider_bundle, Visibility::Visible));
-    }
-}
diff --git a/src/controls.rs b/src/controls.rs
index c586c98..8a15b9b 100644
--- a/src/controls.rs
+++ b/src/controls.rs
@@ -2,7 +2,10 @@ use bevy::prelude::*;
 use bevy_rapier2d::prelude::*;
 use pecs::prelude::*;
 
-use crate::{components::*, events::*, sprites::*};
+use crate::{
+    entities::player::{Player, PlayerAttackEvent},
+    sprites::*,
+};
 
 pub fn controls(
     mut commands: Commands,
diff --git a/src/enemies.rs b/src/enemies.rs
deleted file mode 100644
index 53825d9..0000000
--- a/src/enemies.rs
+++ /dev/null
@@ -1,411 +0,0 @@
-use std::time::Duration;
-
-use bevy::prelude::*;
-use bevy_ecs_ldtk::prelude::*;
-use bevy_particle_systems::*;
-use bevy_rapier2d::prelude::Velocity;
-use bevy_rapier2d::prelude::*;
-use pecs::prelude::*;
-use rand::Rng;
-
-use crate::{
-    components::{ColliderBundle, Player},
-    events::PlayerHitEvent,
-    sprites::*,
-    utils::*,
-};
-
-// -----------
-// Compontents
-// -----------
-
-#[derive(Component, Clone, Default, Reflect)]
-pub struct DirectionUpdateTime {
-    /// track when the bomb should explode (non-repeating timer)
-    pub timer: Timer,
-}
-
-#[derive(Clone, PartialEq, Debug, Default, Component, Reflect)]
-pub struct Mierda {
-    pub move_direction: Vec2,
-    pub health: u8,
-    pub hit_at: Option<Timer>,
-    pub is_dummy: bool,
-}
-
-#[derive(Clone, Default, Bundle)]
-pub struct MierdaBundle {
-    pub sprite_bundle: SpriteSheetBundle,
-    pub mierda: Mierda,
-    pub collider_bundle: ColliderBundle,
-    pub direction_update_time: DirectionUpdateTime,
-}
-
-// ----
-// LDTK
-// ----
-
-impl LdtkEntity for MierdaBundle {
-    fn bundle_entity(
-        entity_instance: &EntityInstance,
-        _layer_instance: &LayerInstance,
-        _: Option<&Handle<Image>>,
-        _: Option<&TilesetDefinition>,
-        asset_server: &AssetServer,
-        texture_atlasses: &mut Assets<TextureAtlas>,
-    ) -> MierdaBundle {
-        let is_dummy = *entity_instance
-            .get_bool_field("is_dummy")
-            .expect("expected entity to have non-nullable name string field");
-        create_mierda_bundle(asset_server, texture_atlasses, is_dummy)
-    }
-}
-
-pub fn create_mierda_bundle(
-    asset_server: &AssetServer,
-    texture_atlasses: &mut Assets<TextureAtlas>,
-    is_dummy: bool,
-) -> MierdaBundle {
-    let rotation_constraints = LockedAxes::ROTATION_LOCKED;
-
-    let collider_bundle = ColliderBundle {
-        collider: Collider::cuboid(8., 8.),
-        rigid_body: RigidBody::Dynamic,
-        friction: Friction {
-            coefficient: 20.0,
-            combine_rule: CoefficientCombineRule::Min,
-        },
-        rotation_constraints,
-        ..Default::default()
-    };
-
-    let atlas_handle = load_texture_atlas(
-        MIERDA_ASSET_SHEET,
-        asset_server,
-        5,
-        1,
-        None,
-        16.,
-        texture_atlasses,
-    );
-
-    let sprite_bundle = SpriteSheetBundle {
-        texture_atlas: atlas_handle,
-        sprite: TextureAtlasSprite::new(4),
-        ..default()
-    };
-
-    let mierda = Mierda {
-        health: 100,
-        move_direction: Vec2 {
-            x: rand::random::<f32>() * 2.0 - 1.0,
-            y: rand::random::<f32>() * 2.0 - 1.0,
-        }
-        .normalize(),
-        hit_at: None,
-        is_dummy,
-    };
-
-    MierdaBundle {
-        sprite_bundle,
-        collider_bundle,
-        mierda,
-        direction_update_time: DirectionUpdateTime {
-            timer: Timer::new(Duration::from_secs(5), TimerMode::Once),
-        },
-    }
-}
-
-// ---------
-// Mierda AI
-// ---------
-
-pub fn mierda_activity(time: Res<Time>, mut los_mierdas: Query<(&mut Velocity, &mut Mierda)>) {
-    for (mut v, mut mierda) in los_mierdas.iter_mut().filter(|(_, m)| !m.is_dummy) {
-        let rotation_angle = time.elapsed_seconds().cos() * std::f32::consts::FRAC_PI_4;
-
-        if mierda.hit_at.is_some() {
-            let timer = mierda.hit_at.as_mut().unwrap();
-            timer.tick(time.delta());
-            if !timer.finished() {
-                continue;
-            } else {
-                mierda.hit_at = None;
-            }
-        }
-        v.linvel = Vec2::new(
-            mierda.move_direction.x * rotation_angle.cos()
-                - mierda.move_direction.y * rotation_angle.sin(),
-            mierda.move_direction.x * rotation_angle.sin()
-                + mierda.move_direction.y * rotation_angle.cos(),
-        ) * 30.0;
-    }
-}
-
-pub fn update_mierdas_move_direction(
-    time: Res<Time>,
-    player: Query<(&Transform, &Player)>,
-    mut los_mierdas: Query<(&Transform, &mut DirectionUpdateTime, &mut Mierda)>,
-) {
-    if player.iter().count() == 0 {
-        return;
-    }
-
-    let player_position = player.single().0.translation;
-
-    for (mierda_position, mut direction_update_timer, mut mierda) in
-        los_mierdas.iter_mut().filter(|(_, _, m)| !m.is_dummy)
-    {
-        direction_update_timer.timer.tick(time.delta());
-
-        if direction_update_timer.timer.finished() || mierda.move_direction == Vec2::ZERO {
-            let mierda_position = mierda_position.translation;
-            mierda.move_direction = Vec2::new(
-                player_position.x - mierda_position.x,
-                player_position.y - mierda_position.y,
-            )
-            .normalize_or_zero();
-        }
-    }
-}
-
-// ---------
-// Physics
-// ---------
-
-pub fn handle_player_mierda_collisions(
-    mut collision_events: EventReader<CollisionEvent>,
-    mut q_player: Query<(Entity, &mut Player)>,
-    q_los_mierdas: Query<(Entity, &mut Velocity, &Mierda)>,
-    mut ev_player_hit: EventWriter<PlayerHitEvent>,
-) {
-    for event in collision_events.iter() {
-        for (e, _) in q_player.iter_mut() {
-            if let CollisionEvent::Started(e1, e2, _) = event {
-                if !(e1.index() == e.index() || e2.index() == e.index()) {
-                    continue;
-                }
-
-                let other_entity = if e1.index() == e.index() { *e2 } else { *e1 };
-                if q_los_mierdas.get(other_entity).is_err() {
-                    continue;
-                }
-
-                ev_player_hit.send(PlayerHitEvent { entity: e });
-            }
-        }
-    }
-}
-
-pub fn handle_mierda_wall_collisions(
-    mut collision_events: EventReader<CollisionEvent>,
-    mut q_los_mierdas: Query<(Entity, &mut Velocity, &Mierda)>,
-) {
-    for event in collision_events.iter() {
-        for (e, mut v, _) in q_los_mierdas.iter_mut() {
-            if let CollisionEvent::Started(e1, e2, _) = event {
-                if e1.index() == e.index() || e2.index() == e.index() {
-                    v.linvel *= -1.;
-                }
-            }
-        }
-    }
-}
-
-// ------
-// Events
-// ------
-
-#[derive(Event, Clone)]
-pub struct MierdaHitEvent(pub Entity);
-
-#[derive(Event, Clone)]
-pub struct SpawnMierdaEvent {
-    pub count: u32,
-}
-
-// --------------
-// Event Handlers
-// --------------
-
-pub fn event_spawn_mierda(
-    mut commands: Commands,
-    mut ev_spawn_mierda: EventReader<SpawnMierdaEvent>,
-    level_selection: Res<LevelSelection>,
-    level_handles: Query<(Entity, &Handle<LdtkLevel>)>,
-    level_assets: Res<Assets<LdtkLevel>>,
-    los_mierdas: Query<(Entity, &Parent, &Mierda)>,
-    levels: Query<(Entity, &Handle<LdtkLevel>)>,
-    q_player_query: Query<(Entity, &Transform, &Player)>,
-) {
-    if q_player_query.iter().count() == 0 {
-        return;
-    }
-
-    let mut rng = rand::thread_rng();
-    let player_translation = q_player_query.single().1.translation;
-
-    for ev_spawn in ev_spawn_mierda.iter() {
-        for (_, level_handle) in level_handles.iter() {
-            let level = &level_assets.get(level_handle).unwrap().level;
-
-            if level_selection.is_match(&0, level) {
-                let (parent_entity, _) = levels
-                    .iter()
-                    .find(|(_, handle)| *handle == level_handle)
-                    .unwrap();
-
-                for _i in 0..ev_spawn.count {
-                    for (mierda_entity, mierda_parent, mierda) in los_mierdas.iter() {
-                        if !mierda.is_dummy {
-                            continue;
-                        }
-
-                        let mierda_parent = mierda_parent.get();
-
-                        if parent_entity != mierda_parent {
-                            continue;
-                        }
-
-                        let mut parent = commands.entity(mierda_parent);
-
-                        let mut new_entity: Option<Entity> = None;
-                        parent.with_children(|cm| {
-                            let ne = cm.spawn_empty().id();
-                            new_entity = Some(ne);
-                        });
-
-                        // generate random position
-
-                        let mut offset_position = Vec3::new(0.0, 0.0, 0.);
-                        let mut mierda_position = player_translation + offset_position;
-
-                        while (player_translation - mierda_position).length() < 50.0
-                            || mierda_position.x < 0.0 + 24.0
-                            || mierda_position.x > (level.px_wid as f32) - 24.0
-                            || mierda_position.y < 0.0 + 24.0
-                            || mierda_position.y > (level.px_hei as f32) - 24.0
-                        {
-                            let x = rng.gen_range(-100.0..100.0);
-                            let y = rng.gen_range(-100.0..100.0);
-
-                            offset_position = Vec3::new(x, y, 0.);
-                            mierda_position = player_translation + offset_position;
-                        }
-
-                        let transform = Transform::from_translation(mierda_position)
-                            .with_scale(Vec3::ONE * 0.5);
-
-                        let new_entity = new_entity.unwrap();
-                        commands.entity(new_entity).insert(Mierda {
-                            is_dummy: false,
-                            health: 100,
-                            move_direction: Vec2::ZERO,
-                            hit_at: None,
-                        });
-
-                        commands.add(CloneEntity {
-                            source: mierda_entity,
-                            destination: new_entity,
-                        });
-
-                        commands.entity(new_entity).insert(transform);
-                    }
-                }
-            }
-        }
-    }
-}
-
-pub fn event_mierda_hit(
-    mut commands: Commands,
-    q_player: Query<(&Transform, &Player)>,
-    mut los_mierdas: Query<(Entity, &Transform, &mut Velocity, &mut Mierda)>,
-    mut ev_mierda_hit: EventReader<MierdaHitEvent>,
-    // mut ev_mierda_spawn: EventWriter<SpawnMierdaEvent>,
-) {
-    for event in ev_mierda_hit.iter() {
-        for (player_transform, _) in q_player.iter() {
-            let player_position = player_transform.translation;
-
-            let (mierda_entity, mierda_transform, mut mierda_velocity, mut mierda) =
-                los_mierdas.get_mut(event.0).unwrap();
-            let mierda_position = mierda_transform.translation;
-            let vector_attack = (mierda_position - player_position).normalize();
-            mierda_velocity.linvel.x += vector_attack.x * 200.;
-            mierda_velocity.linvel.y += vector_attack.y * 200.;
-
-            let timer = Timer::new(std::time::Duration::from_millis(200), TimerMode::Once);
-            mierda.hit_at = Some(timer.clone());
-
-            commands.entity(mierda_entity).insert(FlashingTimer {
-                timer: timer.clone(),
-            });
-
-            // despawn mierda async
-            commands
-                .promise(|| (mierda_entity))
-                .then(asyn!(state => {
-                    state.asyn().timeout(0.3)
-                }))
-                .then(
-                    asyn!(state, mut commands: Commands, asset_server: Res<AssetServer>, q_mierdas: Query<(Entity, &GlobalTransform)> => {
-                                let mierda_transform = *q_mierdas.get(state.value).unwrap().1;
-                                commands.spawn((
-                                    ParticleSystemBundle {
-                                        transform: (mierda_transform).into(),
-                                        particle_system: ParticleSystem {
-                                            spawn_rate_per_second: 0.0.into(),
-                                            texture: ParticleTexture::Sprite(asset_server.load("px.png")),
-                                            max_particles: 1_00,
-                                            initial_speed: (0.0..10.0).into(),
-                                            scale: 1.0.into(),
-                                            velocity_modifiers: vec![
-                                                VelocityModifier::Drag(0.001.into()),
-                                                VelocityModifier::Vector(Vec3::new(0.0, -100.0, 0.0).into()),
-                                            ],
-                                            color: (Color::BLUE..Color::AQUAMARINE).into(),
-                                            bursts: vec![ParticleBurst {
-                                                time: 0.0,
-                                                count: 20,
-                                            }],
-                                            looping: false,
-                                            ..ParticleSystem::default()
-                                        },
-                                        ..default()
-                                    },
-                                    Playing,
-                                ));
-                                commands.entity(state.value).despawn_recursive();
-                            }),
-                );
-        }
-    }
-}
-
-// ---
-// Plugin
-// --
-
-pub struct EnemyPlugin;
-
-impl Plugin for EnemyPlugin {
-    fn build(&self, app: &mut App) {
-        app.register_ldtk_entity::<MierdaBundle>("Mierda")
-            // AI
-            .add_systems(Update, (mierda_activity, update_mierdas_move_direction))
-            // Event Handlers
-            .add_event::<MierdaHitEvent>()
-            .add_event::<SpawnMierdaEvent>()
-            // Event Handlers
-            .add_systems(
-                Update,
-                (
-                    handle_mierda_wall_collisions,
-                    handle_player_mierda_collisions,
-                    event_mierda_hit,
-                    event_spawn_mierda,
-                ),
-            );
-    }
-}
diff --git a/src/events.rs b/src/events.rs
index 66a4288..4f821fc 100644
--- a/src/events.rs
+++ b/src/events.rs
@@ -1,30 +1,6 @@
-
-
+use crate::ui::UIGameOver;
 use bevy::prelude::*;
 
-use bevy_particle_systems::*;
-
-
-
-
-
-use crate::{
-    components::Player,
-    enemies::{Mierda, MierdaHitEvent},
-    sprites::{AnimationDirection, CharacterAnimation},
-    ui::{self, UIGameOver},
-};
-
-#[derive(Event, Clone)]
-pub struct PlayerAttackEvent {
-    pub entity: Entity,
-}
-
-#[derive(Event, Clone)]
-pub struct PlayerHitEvent {
-    pub entity: Entity,
-}
-
 #[derive(Event, Clone)]
 pub struct GameOverEvent;
 
@@ -33,96 +9,6 @@ pub struct LevelChangeEvent {
     pub(crate) level_id: usize,
 }
 
-pub fn event_player_attack(
-    mut ev_player_attack: EventReader<PlayerAttackEvent>,
-    mut ev_mierda_hit: EventWriter<MierdaHitEvent>,
-    mut q_player: Query<(Entity, &Transform, &CharacterAnimation), With<Player>>,
-    mut los_mierdas: Query<(Entity, &Transform, &mut Mierda)>,
-) {
-    for ev in ev_player_attack.iter() {
-        let (_, transform, char_animation) = q_player.get_mut(ev.entity).unwrap();
-
-        let player_position = transform.translation;
-        let player_orientation = char_animation.direction;
-
-        // find all mierdas in range
-        for (entity, mierda_transform, _) in los_mierdas.iter_mut().filter(|(_, _, m)| !m.is_dummy)
-        {
-            let mierda_position = mierda_transform.translation;
-
-            let distance = player_position.distance(mierda_position);
-
-            if distance >= 75. {
-                continue;
-            }
-
-            // cause damage accrodign to player_orientation
-            let is_merda_attacked = match player_orientation {
-                AnimationDirection::Up => player_position.y < mierda_position.y,
-                AnimationDirection::Down => player_position.y > mierda_position.y,
-                AnimationDirection::Left => player_position.x > mierda_position.x,
-                AnimationDirection::Right => player_position.x < mierda_position.x,
-            };
-
-            if !is_merda_attacked {
-                continue;
-            }
-
-            ev_mierda_hit.send(MierdaHitEvent(entity));
-        }
-    }
-}
-
-pub fn event_player_hit(
-    mut commands: Commands,
-    mut ev_player_hit_reader: EventReader<PlayerHitEvent>,
-    mut ev_game_over: EventWriter<GameOverEvent>,
-    mut q_player: Query<(Entity, &GlobalTransform, &mut Player)>,
-    mut q_ui_healthbar: Query<(Entity, &mut Style, &ui::UIPlayerHealth)>,
-    asset_server: Res<AssetServer>,
-) {
-    for ev in ev_player_hit_reader.iter() {
-        let (_, player_transform, mut player) = q_player.get_mut(ev.entity).unwrap();
-
-        commands.spawn((
-            ParticleSystemBundle {
-                transform: (*player_transform).into(),
-                particle_system: ParticleSystem {
-                    spawn_rate_per_second: 0.0.into(),
-                    texture: ParticleTexture::Sprite(asset_server.load("px.png")),
-                    max_particles: 5_000,
-                    initial_speed: (0.0..300.0).into(),
-                    scale: 1.0.into(),
-                    velocity_modifiers: vec![
-                        VelocityModifier::Drag(0.001.into()),
-                        VelocityModifier::Vector(Vec3::new(0.0, -400.0, 0.0).into()),
-                    ],
-                    color: (Color::RED..Color::rgba(1.0, 0.0, 0.0, 0.0)).into(),
-                    bursts: vec![ParticleBurst {
-                        time: 0.0,
-                        count: 1000,
-                    }],
-                    looping: false,
-                    ..ParticleSystem::default()
-                },
-                ..default()
-            },
-            Playing,
-        ));
-
-        if player.health < 10 {
-            ev_game_over.send(GameOverEvent);
-            continue;
-        } else {
-            player.health -= 10;
-
-            for (_, mut style, _) in q_ui_healthbar.iter_mut() {
-                style.width = Val::Percent(player.health as f32);
-            }
-        }
-    }
-}
-
 pub fn event_game_over(
     mut ev_game_over: EventReader<GameOverEvent>,
     mut q_ui_game_over: Query<(&mut Visibility, &UIGameOver)>,
diff --git a/src/gameplay.rs b/src/gameplay.rs
index 1f85fd1..d21b79b 100644
--- a/src/gameplay.rs
+++ b/src/gameplay.rs
@@ -3,7 +3,9 @@ use std::time::Duration;
 use bevy::prelude::*;
 use rand::Rng;
 
-use crate::{enemies::SpawnMierdaEvent, events::*, items::SpawnPizzaEvent, ui::*};
+use crate::{
+    entities::enemies::SpawnMierdaEvent, entities::items::SpawnPizzaEvent, events::*, ui::*,
+};
 
 #[derive(Clone)]
 pub enum WaveEntry {
diff --git a/src/items.rs b/src/items.rs
deleted file mode 100644
index 3d399bd..0000000
--- a/src/items.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-#[derive(Clone, PartialEq, Debug, Default, Component, Reflect)]
-pub struct Pizza {
-    pub is_dummy: bool,
-}
-
-use std::cmp::min;
-
-use bevy::prelude::*;
-use bevy_ecs_ldtk::prelude::*;
-use bevy_rapier2d::prelude::*;
-use rand::Rng;
-
-use crate::{
-    components::{ColliderBundle, Player},
-    sprites::{load_texture_atlas, PIZZA_ASSET_SHEET},
-    ui,
-    utils::*,
-};
-
-#[derive(Clone, Default, Bundle)]
-pub struct PizzaBundle {
-    pub sprite_bundle: SpriteSheetBundle,
-    pub pizza: Pizza,
-    pub collider_bundle: ColliderBundle,
-    pub sensor: Sensor,
-}
-
-pub fn create_pizza_bundle(
-    asset_server: &AssetServer,
-    texture_atlasses: &mut Assets<TextureAtlas>,
-    is_dummy: bool,
-) -> PizzaBundle {
-    let rotation_constraints = LockedAxes::ROTATION_LOCKED;
-
-    let collider_bundle = ColliderBundle {
-        collider: Collider::cuboid(8., 8.),
-        rigid_body: RigidBody::Dynamic,
-        friction: Friction {
-            coefficient: 20.0,
-            combine_rule: CoefficientCombineRule::Min,
-        },
-        rotation_constraints,
-        ..Default::default()
-    };
-
-    let atlas_handle = load_texture_atlas(
-        PIZZA_ASSET_SHEET,
-        asset_server,
-        1,
-        1,
-        None,
-        16.,
-        texture_atlasses,
-    );
-
-    let sprite_bundle = SpriteSheetBundle {
-        texture_atlas: atlas_handle,
-        sprite: TextureAtlasSprite::new(0),
-        ..default()
-    };
-
-    PizzaBundle {
-        sprite_bundle,
-        collider_bundle,
-        pizza: Pizza { is_dummy },
-        sensor: Sensor {},
-    }
-}
-
-impl LdtkEntity for PizzaBundle {
-    fn bundle_entity(
-        entity_instance: &EntityInstance,
-        _layer_instance: &LayerInstance,
-        _: Option<&Handle<Image>>,
-        _: Option<&TilesetDefinition>,
-        asset_server: &AssetServer,
-        texture_atlasses: &mut Assets<TextureAtlas>,
-    ) -> PizzaBundle {
-        let is_dummy = *entity_instance
-            .get_bool_field("is_dummy")
-            .expect("expected entity to have non-nullable name string field");
-        create_pizza_bundle(asset_server, texture_atlasses, is_dummy)
-    }
-}
-
-// ------
-// Events
-// ------
-
-#[derive(Event, Clone)]
-pub struct PizzaStepOverEvent(pub Entity);
-
-#[derive(Event, Clone)]
-pub struct SpawnPizzaEvent {
-    pub(crate) count: u32,
-}
-
-// --------------
-// Event Handlers
-// --------------
-
-pub fn event_spawn_pizza(
-    mut commands: Commands,
-    mut ev_spawn_pizza: EventReader<SpawnPizzaEvent>,
-    level_selection: Res<LevelSelection>,
-    level_handles: Query<(Entity, &Handle<LdtkLevel>)>,
-    level_assets: Res<Assets<LdtkLevel>>,
-    los_pizzas: Query<(Entity, &Parent, &Pizza)>,
-    levels: Query<(Entity, &Handle<LdtkLevel>)>,
-    q_player_query: Query<(Entity, &Transform, &Player)>,
-) {
-    if q_player_query.iter().count() == 0 {
-        return;
-    }
-
-    let mut rng = rand::thread_rng();
-    let player_translation = q_player_query.single().1.translation;
-
-    for ev_spawn in ev_spawn_pizza.iter() {
-        for (_, level_handle) in level_handles.iter() {
-            let level = &level_assets.get(level_handle).unwrap().level;
-
-            if level_selection.is_match(&0, level) {
-                let (parent_entity, _) = levels
-                    .iter()
-                    .find(|(_, handle)| *handle == level_handle)
-                    .unwrap();
-
-                for _i in 0..ev_spawn.count {
-                    for (pizza_entity, mierda_parent, pizza) in los_pizzas.iter() {
-                        if !pizza.is_dummy {
-                            continue;
-                        }
-
-                        let pizza_parent = mierda_parent.get();
-
-                        if parent_entity != pizza_parent {
-                            continue;
-                        }
-
-                        let mut parent = commands.entity(pizza_parent);
-
-                        let mut new_entity: Option<Entity> = None;
-                        parent.with_children(|cm| {
-                            let ne = cm.spawn_empty().id();
-                            new_entity = Some(ne);
-                        });
-
-                        // generate random position
-
-                        let mut offset_position = Vec3::new(0.0, 0.0, 0.);
-                        let mut mierda_position = player_translation + offset_position;
-
-                        while (player_translation - mierda_position).length() < 50.0
-                            || mierda_position.x < 0.0 + 24.0
-                            || mierda_position.x > (level.px_wid as f32) - 24.0
-                            || mierda_position.y < 0.0 + 24.0
-                            || mierda_position.y > (level.px_hei as f32) - 24.0
-                        {
-                            let x = rng.gen_range(-100.0..100.0);
-                            let y = rng.gen_range(-100.0..100.0);
-
-                            offset_position = Vec3::new(x, y, 0.);
-                            mierda_position = player_translation + offset_position;
-                        }
-
-                        let transform = Transform::from_translation(mierda_position)
-                            .with_scale(Vec3::ONE * 0.5);
-
-                        let new_entity = new_entity.unwrap();
-                        commands
-                            .entity(new_entity)
-                            .insert(Pizza { is_dummy: false });
-
-                        commands.add(CloneEntity {
-                            source: pizza_entity,
-                            destination: new_entity,
-                        });
-
-                        commands.entity(new_entity).insert(transform);
-                    }
-                }
-            }
-        }
-    }
-}
-
-pub fn event_on_pizza_step_over(
-    mut commands: Commands,
-    mut er_pizza_step_over: EventReader<PizzaStepOverEvent>,
-    mut q_pizzas: Query<(Entity, &Pizza)>,
-    mut q_player: Query<(Entity, &mut Player)>,
-    mut q_ui_healthbar: Query<(Entity, &mut Style, &ui::UIPlayerHealth)>,
-) {
-    for e in er_pizza_step_over.iter() {
-        for (_, mut player) in q_player.iter_mut() {
-            player.health = min(player.health + 10, 100);
-
-            for (_, mut style, _) in q_ui_healthbar.iter_mut() {
-                style.width = Val::Percent(player.health as f32);
-            }
-        }
-
-        for (e_pizza, _) in q_pizzas.iter_mut() {
-            if e_pizza != e.0 {
-                continue;
-            }
-            commands.entity(e_pizza).despawn_recursive();
-        }
-    }
-}
-
-// -------
-// Physics
-// -------
-
-pub(crate) fn handle_player_pizza_collision(
-    mut collision_events: EventReader<CollisionEvent>,
-    mut q_pizzas: Query<(Entity, &Pizza)>,
-    q_player: Query<(Entity, &mut Player)>,
-    mut ev_pizza_step_over: EventWriter<PizzaStepOverEvent>,
-) {
-    for (player_entity, _) in q_player.iter() {
-        for event in collision_events.iter() {
-            for (e_pizza, _) in q_pizzas.iter_mut() {
-                if let CollisionEvent::Started(e1, e2, _) = event {
-                    if e1.index() == e_pizza.index() && e2.index() == player_entity.index() {
-                        ev_pizza_step_over.send(PizzaStepOverEvent(e_pizza));
-                        return;
-                    }
-
-                    if e2.index() == e_pizza.index() && e1.index() == player_entity.index() {
-                        ev_pizza_step_over.send(PizzaStepOverEvent(e_pizza));
-                        return;
-                    }
-                }
-            }
-        }
-    }
-}
-
-// ------
-// Plugin
-// ------
-
-pub struct ItemsPlugin;
-
-impl Plugin for ItemsPlugin {
-    fn build(&self, app: &mut App) {
-        app.register_ldtk_entity::<PizzaBundle>("Pizza")
-            // Event Handlers
-            .add_event::<SpawnPizzaEvent>()
-            .add_event::<PizzaStepOverEvent>()
-            // Event Handlers
-            .add_systems(
-                Update,
-                (
-                    handle_player_pizza_collision,
-                    event_on_pizza_step_over,
-                    event_spawn_pizza,
-                ),
-            );
-    }
-}
diff --git a/src/ldtk.rs b/src/ldtk.rs
index 2f37707..e1c4432 100644
--- a/src/ldtk.rs
+++ b/src/ldtk.rs
@@ -5,14 +5,24 @@ use bevy_ecs_ldtk::prelude::*;
 
 use bevy_rapier2d::prelude::*;
 
-use crate::components::*;
-use crate::enemies::*;
-use crate::events::*;
-use crate::items::*;
-use crate::sprites::*;
+use crate::{
+    entities::{enemies::*, items::*, player::Player},
+    events::*,
+};
 
 const ASPECT_RATIO: f32 = 16. / 9.;
 
+// Entities
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Default, Component)]
+pub struct Wall;
+
+#[derive(Clone, Debug, Default, Bundle, LdtkIntCell)]
+pub struct WallBundle {
+    wall: Wall,
+    sensor: Sensor,
+}
+
 pub fn update_level_selection(
     level_query: Query<(&Handle<LdtkLevel>, &Transform), Without<Player>>,
     player_query: Query<&GlobalTransform, With<Player>>,
@@ -267,56 +277,7 @@ pub fn spawn_wall_collision(
     }
 }
 
-impl LdtkEntity for PlayerBundle {
-    fn bundle_entity(
-        _entity_instance: &EntityInstance,
-        _layer_instance: &LayerInstance,
-        _: Option<&Handle<Image>>,
-        _: Option<&TilesetDefinition>,
-        asset_server: &AssetServer,
-        texture_atlasses: &mut Assets<TextureAtlas>,
-    ) -> PlayerBundle {
-        let rotation_constraints = LockedAxes::ROTATION_LOCKED;
-
-        let collider_bundle = ColliderBundle {
-            collider: Collider::cuboid(8., 26.),
-            rigid_body: RigidBody::Dynamic,
-            friction: Friction {
-                coefficient: 0.0,
-                combine_rule: CoefficientCombineRule::Min,
-            },
-            rotation_constraints,
-            ..Default::default()
-        };
-
-        let atlas_handle = load_texture_atlas(
-            PLAYER_ASSET_SHEET_1,
-            asset_server,
-            SHEET_1_COLUMNS,
-            SHEET_1_ROWS,
-            None,
-            64.,
-            texture_atlasses,
-        );
-
-        let sprite_bundle = SpriteSheetBundle {
-            texture_atlas: atlas_handle,
-            sprite: TextureAtlasSprite::new(0),
-            ..default()
-        };
-
-        PlayerBundle {
-            character_animation: CharacterAnimation { ..default() },
-            animation_timer: AnimationTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
-            sprite_bundle,
-            collider_bundle,
-            active_events: ActiveEvents::COLLISION_EVENTS,
-            player: Player { health: 100 },
-        }
-    }
-}
-
-pub(crate) fn hide_dummy_entities(
+pub fn hide_dummy_entities(
     mut commands: Commands,
     level_selection: Res<LevelSelection>,
     mut set: ParamSet<(
@@ -342,3 +303,30 @@ pub(crate) fn hide_dummy_entities(
         }
     }
 }
+
+pub fn fix_missing_ldtk_entities(
+    asset_server: Res<AssetServer>,
+    texture_atlasses: ResMut<Assets<TextureAtlas>>,
+    mut commands: Commands,
+    los_mierdas: Query<(Entity, &Mierda), Without<Collider>>,
+    los_pizzas: Query<(Entity, &Pizza), Without<Collider>>,
+) {
+    let asset_server = asset_server.into_inner();
+    let texture_atlasses = texture_atlasses.into_inner();
+
+    for (e, _) in los_mierdas.iter().filter(|(_, m)| !m.is_dummy) {
+        let bundle = create_mierda_bundle(asset_server, texture_atlasses, false);
+        commands.entity(e).insert((
+            bundle.collider_bundle,
+            bundle.direction_update_time,
+            Visibility::Visible,
+        ));
+    }
+
+    for (e, _) in los_pizzas.iter().filter(|(_, m)| !m.is_dummy) {
+        let bundle = create_pizza_bundle(asset_server, texture_atlasses, false);
+        commands
+            .entity(e)
+            .insert((bundle.collider_bundle, Visibility::Visible));
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 91e9e07..d59fb62 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,21 +5,18 @@ use bevy_ecs_ldtk::prelude::*;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 use bevy_particle_systems::*;
 use bevy_rapier2d::prelude::*;
-use items::{ItemsPlugin, Pizza};
 use pecs::prelude::*;
 
 use cutscene::*;
-use enemies::*;
 use loading::*;
 use menu::*;
 
 mod components;
 mod controls;
 mod cutscene;
-mod enemies;
+mod entities;
 mod events;
 mod gameplay;
-mod items;
 mod ldtk;
 mod loading;
 mod menu;
@@ -40,13 +37,6 @@ enum GameState {
 fn main() {
     let mut app = App::new();
 
-    {
-        let registry = app.world.resource_mut::<AppTypeRegistry>();
-        let mut wr = registry.write();
-        wr.register::<Mierda>();
-        wr.register::<Pizza>();
-    }
-
     app.add_state::<GameState>()
         .add_plugins(DefaultPlugins.set(ImagePlugin::default_nearest()))
         .add_plugins(LoadingPlugin)
@@ -58,7 +48,7 @@ fn main() {
         )
         .add_plugins(ParticleSystemPlugin)
         // Game Plugins
-        .add_plugins((EnemyPlugin, ItemsPlugin))
+        .add_plugins(entities::EntitiesPlugin)
         .add_systems(
             OnEnter(GameState::Gameplay),
             (spawn_game_world, ui::draw_ui),
@@ -69,7 +59,6 @@ fn main() {
             level_spawn_behavior: LevelSpawnBehavior::UseWorldTranslation {
                 load_level_neighbors: true,
             },
-            // level_spawn_behavior: LevelSpawnBehavior::UseZeroTranslation,
             set_clear_color: SetClearColor::FromLevelBackground,
             ..Default::default()
         })
@@ -82,27 +71,17 @@ fn main() {
             ),
         )
         .insert_resource(LevelSelection::Index(0))
-        .register_ldtk_int_cell::<components::WallBundle>(1)
-        .register_ldtk_entity::<components::PlayerBundle>("Player")
-        // Enemy AI
+        .register_ldtk_int_cell::<ldtk::WallBundle>(1)
+        // Housekeeping
         .add_systems(
             Update,
-            (
-                enemies::mierda_activity,
-                enemies::update_mierdas_move_direction,
-            ),
+            (ldtk::hide_dummy_entities, ldtk::fix_missing_ldtk_entities),
         )
-        // Housekeeping
+        // Sprites
         .add_systems(
             Update,
-            (
-                ldtk::hide_dummy_entities,
-                components::fix_missing_ldtk_entities,
-            ),
+            (sprites::animate_player_sprite, sprites::flash_sprite),
         )
-        // Sprites
-        .init_resource::<sprites::PlayerSpritesheets>()
-        .add_systems(Update, (sprites::animate_sprite, sprites::flash_sprite))
         // Controls
         .add_systems(Update, controls::controls)
         // Physics
@@ -117,8 +96,6 @@ fn main() {
         .add_systems(
             Update,
             (
-                events::event_player_attack,
-                events::event_player_hit,
                 events::event_game_over,
                 gameplay::event_on_level_change,
                 gameplay::event_wave,
@@ -129,8 +106,6 @@ fn main() {
         // Resources
         .init_resource::<gameplay::GameplayState>()
         // App Events
-        .add_event::<events::PlayerAttackEvent>()
-        .add_event::<events::PlayerHitEvent>()
         .add_event::<events::GameOverEvent>()
         .add_event::<events::LevelChangeEvent>()
         .add_event::<gameplay::WaveEvent>();
diff --git a/src/sprites.rs b/src/sprites.rs
index e8714b5..f5194f7 100644
--- a/src/sprites.rs
+++ b/src/sprites.rs
@@ -1,6 +1,6 @@
 use bevy::{prelude::*, sprite::Anchor};
 
-use crate::components::Player;
+use crate::entities::player::Player;
 
 pub const SHEET_1_COLUMNS: usize = 13;
 pub const SHEET_1_ROWS: usize = 21;
@@ -62,6 +62,54 @@ pub struct PlayerSpritesheets {
     pub mierda_atlas: Handle<TextureAtlas>,
 }
 
+impl FromWorld for PlayerSpritesheets {
+    fn from_world(world: &mut World) -> Self {
+        let world = world.cell();
+
+        let asset_server_world_borrow = world.get_resource::<AssetServer>();
+        let asset_server = asset_server_world_borrow.as_deref().unwrap();
+
+        let mut texture_atlasses_world_borrow = world.get_resource_mut::<Assets<TextureAtlas>>();
+        let texture_atlasses = texture_atlasses_world_borrow.as_deref_mut().unwrap();
+
+        let player_atlas_1 = load_texture_atlas(
+            PLAYER_ASSET_SHEET_1,
+            asset_server,
+            SHEET_1_COLUMNS,
+            SHEET_1_ROWS,
+            None,
+            64.,
+            texture_atlasses,
+        );
+
+        let player_atlas_2 = load_texture_atlas(
+            PLAYER_ASSET_SHEET_2,
+            asset_server,
+            SHEET_2_COLUMNS,
+            SHEET_2_ROWS,
+            None,
+            64. * 3.,
+            texture_atlasses,
+        );
+
+        let mierda_atlas = load_texture_atlas(
+            MIERDA_ASSET_SHEET,
+            asset_server,
+            5,
+            1,
+            None,
+            16.0,
+            texture_atlasses,
+        );
+
+        PlayerSpritesheets {
+            player_atlas_1,
+            player_atlas_2,
+            mierda_atlas,
+        }
+    }
+}
+
 pub const PLAYER_ASSET_SHEET_1: &str = "sprites/alextime-1.png";
 pub const PLAYER_ASSET_SHEET_2: &str = "sprites/alextime-2.png";
 pub const MIERDA_ASSET_SHEET: &str = "sprites/mierda.png";
@@ -90,7 +138,7 @@ pub fn load_texture_atlas(
     texture_atlasses.add(atlas)
 }
 
-pub fn animate_sprite(
+pub fn animate_player_sprite(
     time: Res<Time>,
     mut query: Query<
         (