diff --git a/src/ai.rs b/src/ai.rs
new file mode 100644
index 0000000..19c0cea
--- /dev/null
+++ b/src/ai.rs
@@ -0,0 +1,58 @@
+use bevy::prelude::*;
+
+use bevy_rapier2d::prelude::*;
+
+use crate::components::*;
+
+pub(crate) 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(crate) 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() {
+            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();
+        }
+    }
+}
diff --git a/src/controls.rs b/src/controls.rs
new file mode 100644
index 0000000..c586c98
--- /dev/null
+++ b/src/controls.rs
@@ -0,0 +1,89 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+use pecs::prelude::*;
+
+use crate::{components::*, events::*, sprites::*};
+
+pub fn controls(
+    mut commands: Commands,
+    input: Res<Input<KeyCode>>,
+    mut query: Query<
+        (
+            Entity,
+            &mut Handle<TextureAtlas>,
+            &mut Velocity,
+            &mut CharacterAnimation,
+            &mut TextureAtlasSprite,
+        ),
+        With<Player>,
+    >,
+    spritesheets: Res<PlayerSpritesheets>,
+) {
+    for (entity, mut texture_atlas, mut velocity, mut char_animation, mut sprite) in &mut query {
+        // no control during attack phase
+        if char_animation.animation_type == AnimationType::Attack {
+            return;
+        }
+
+        if input.pressed(KeyCode::Space) {
+            char_animation.animation_type = AnimationType::Attack;
+            texture_atlas.clone_from(&spritesheets.player_atlas_2);
+
+            let indices =
+                get_animation_indices(char_animation.animation_type, char_animation.direction);
+            sprite.index = indices.first;
+            velocity.linvel = Vec2::ZERO;
+
+            commands
+                .promise(|| (entity))
+                .then(asyn!(state => {
+                    state.asyn().timeout(0.3)
+                }))
+                .then(
+                    asyn!(state, mut ev_attack: EventWriter<PlayerAttackEvent> => {
+                                let event = PlayerAttackEvent { entity: state.value };
+                    ev_attack.send(event);
+                            }),
+                );
+        } else {
+            let right = if input.pressed(KeyCode::D) { 1. } else { 0. };
+            let left = if input.pressed(KeyCode::A) { 1. } else { 0. };
+            let up = if input.pressed(KeyCode::W) { 1. } else { 0. };
+            let down = if input.pressed(KeyCode::S) { 1. } else { 0. };
+
+            velocity.linvel.x = right - left;
+            velocity.linvel.y = up - down;
+
+            velocity.linvel = velocity.linvel.normalize_or_zero() * 100.;
+
+            let linvel_norm = velocity.linvel.distance(Vec2::ZERO);
+
+            // Change animation type if player moved
+            if char_animation.animation_type == AnimationType::Walk {
+                if velocity.linvel.x > 0. {
+                    char_animation.direction = AnimationDirection::Right;
+                } else if velocity.linvel.x < 0. {
+                    char_animation.direction = AnimationDirection::Left;
+                } else if velocity.linvel.y > 0. {
+                    char_animation.direction = AnimationDirection::Up;
+                } else if velocity.linvel.y < 0. {
+                    char_animation.direction = AnimationDirection::Down;
+                }
+            }
+
+            // Don't interrupt attack animation
+            if char_animation.animation_type != AnimationType::Attack {
+                // Change spritesheet
+                if char_animation.animation_type != AnimationType::Walk {
+                    texture_atlas.clone_from(&spritesheets.player_atlas_1);
+                }
+
+                if linvel_norm == 0.0 {
+                    char_animation.animation_type = AnimationType::Stand;
+                } else {
+                    char_animation.animation_type = AnimationType::Walk;
+                }
+            }
+        }
+    }
+}
diff --git a/src/events.rs b/src/events.rs
new file mode 100644
index 0000000..61ea907
--- /dev/null
+++ b/src/events.rs
@@ -0,0 +1,211 @@
+use bevy::prelude::*;
+use bevy_ecs_ldtk::{LdtkLevel, LevelSelection};
+use bevy_rapier2d::prelude::Velocity;
+use pecs::prelude::*;
+
+use crate::{
+    components::{Mierda, Player},
+    sprites::{AnimationDirection, CharacterAnimation, FlashingTimer},
+    ui::{self, UiGameOver},
+    utils::CloneEntity,
+};
+
+#[derive(Event, Clone)]
+pub struct PlayerAttackEvent {
+    pub entity: Entity,
+}
+
+#[derive(Event, Clone)]
+pub struct PlayerHitEvent {
+    pub entity: Entity,
+}
+
+#[derive(Event, Clone)]
+pub struct GameOverEvent;
+
+#[derive(Event, Clone)]
+pub struct MierdaHitEvent(pub Entity);
+
+#[derive(Event, Clone)]
+pub struct SpawnMierdaEvent {
+    pub(crate) count: u32,
+}
+
+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>>,
+    _texture_atlasses: ResMut<Assets<TextureAtlas>>,
+    los_mierdas: Query<(Entity, &Parent, &mut Visibility, &Mierda)>,
+    levels: Query<(Entity, &Handle<LdtkLevel>)>,
+) {
+    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_visibility, 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);
+                        });
+
+                        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,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+
+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_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() {
+        let los_mierdas_count = los_mierdas.iter().len();
+
+        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  => {
+                    commands.entity(state.value).despawn_recursive();
+
+                }));
+
+            if los_mierdas_count < 256 {
+                ev_mierda_spawn.send(SpawnMierdaEvent { count: 2 });
+            }
+        }
+    }
+}
+
+pub fn event_player_hit(
+    mut ev_player_hit_reader: EventReader<PlayerHitEvent>,
+    mut ev_game_over: EventWriter<GameOverEvent>,
+    mut q_player: Query<(Entity, &mut Player)>,
+    mut q_ui_healthbar: Query<(Entity, &mut Style, &ui::UiPlayerHealth)>,
+) {
+    for ev in ev_player_hit_reader.iter() {
+        let (_, mut player) = q_player.get_mut(ev.entity).unwrap();
+
+        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)>,
+) {
+    for _ in ev_game_over.iter() {
+        for (mut visibility, _) in q_ui_game_over.iter_mut() {
+            *visibility = Visibility::Visible;
+        }
+    }
+}
diff --git a/src/ldtk.rs b/src/ldtk.rs
new file mode 100644
index 0000000..401915e
--- /dev/null
+++ b/src/ldtk.rs
@@ -0,0 +1,342 @@
+use std::collections::{HashMap, HashSet};
+
+use bevy::prelude::*;
+use bevy_ecs_ldtk::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+use crate::components::*;
+use crate::events::SpawnMierdaEvent;
+use crate::sprites::*;
+
+const ASPECT_RATIO: f32 = 16. / 9.;
+
+pub fn update_level_selection(
+    level_query: Query<(&Handle<LdtkLevel>, &Transform), Without<Player>>,
+    player_query: Query<&GlobalTransform, With<Player>>,
+    mut level_selection: ResMut<LevelSelection>,
+    ldtk_levels: Res<Assets<LdtkLevel>>,
+) {
+    for (level_handle, level_transform) in &level_query {
+        if let Some(ldtk_level) = ldtk_levels.get(level_handle) {
+            let level_bounds = Rect {
+                min: Vec2::new(level_transform.translation.x, level_transform.translation.y),
+                max: Vec2::new(
+                    level_transform.translation.x + ldtk_level.level.px_wid as f32,
+                    level_transform.translation.y + ldtk_level.level.px_hei as f32,
+                ),
+            };
+
+            for player_transform in &player_query {
+                let player_within_x_bounds = player_transform.translation().x < level_bounds.max.x
+                    && player_transform.translation().x > level_bounds.min.x;
+
+                let player_within_y_bounds = player_transform.translation().y < level_bounds.max.y
+                    && player_transform.translation().y > level_bounds.min.y;
+
+                if player_within_x_bounds && player_within_y_bounds {
+                    let new_level = LevelSelection::Iid(ldtk_level.level.iid.clone());
+                    if *level_selection != new_level {
+                        *level_selection = new_level;
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+pub fn camera_fit_inside_current_level(
+    mut camera_query: Query<
+        (
+            &mut bevy::render::camera::OrthographicProjection,
+            &mut Transform,
+        ),
+        Without<Player>,
+    >,
+    player_query: Query<&GlobalTransform, With<Player>>,
+    level_query: Query<
+        (&Transform, &Handle<LdtkLevel>),
+        (Without<OrthographicProjection>, Without<Player>),
+    >,
+    level_selection: Res<LevelSelection>,
+    ldtk_levels: Res<Assets<LdtkLevel>>,
+) {
+    if player_query.is_empty() {
+        return;
+    }
+
+    let player_translation = player_query.single().translation();
+
+    let (mut orthographic_projection, mut camera_transform) = camera_query.single_mut();
+
+    for (level_transform, level_handle) in &level_query {
+        if let Some(ldtk_level) = ldtk_levels.get(level_handle) {
+            let level = &ldtk_level.level;
+            if level_selection.is_match(&0, level) {
+                // println!("level: {}", level.iid);
+                let level_ratio = level.px_wid as f32 / ldtk_level.level.px_hei as f32;
+                orthographic_projection.viewport_origin = Vec2::ZERO;
+                if level_ratio > ASPECT_RATIO {
+                    // level is wider than the screen
+                    let height = (level.px_hei as f32 / 9.).round() * 9.;
+                    let width = height * ASPECT_RATIO;
+                    orthographic_projection.scaling_mode =
+                        bevy::render::camera::ScalingMode::Fixed { width, height };
+                    camera_transform.translation.x =
+                        (player_translation.x - level_transform.translation.x - width / 2.)
+                            .clamp(0., level.px_wid as f32 - width);
+                    camera_transform.translation.y = 0.;
+                } else {
+                    // level is taller than the screen
+                    let width = (level.px_wid as f32 / 16.).round() * 16.;
+                    let height = width / ASPECT_RATIO;
+                    orthographic_projection.scaling_mode =
+                        bevy::render::camera::ScalingMode::Fixed { width, height };
+                    camera_transform.translation.y =
+                        (player_translation.y - level_transform.translation.y - height / 2.)
+                            .clamp(0., level.px_hei as f32 - height);
+                    camera_transform.translation.x = 0.;
+                }
+
+                camera_transform.translation.x += level_transform.translation.x;
+                camera_transform.translation.y += level_transform.translation.y;
+            }
+        }
+    }
+}
+
+pub fn spawn_wall_collision(
+    mut commands: Commands,
+    wall_query: Query<(&GridCoords, &Parent), Added<Wall>>,
+    parent_query: Query<&Parent, Without<Wall>>,
+    level_query: Query<(Entity, &Handle<LdtkLevel>)>,
+    levels: Res<Assets<LdtkLevel>>,
+) {
+    /// Represents a wide wall that is 1 tile tall
+    /// Used to spawn wall collisions
+    #[derive(Clone, Eq, PartialEq, Debug, Default, Hash)]
+    struct Plate {
+        left: i32,
+        right: i32,
+    }
+
+    /// A simple rectangle type representing a wall of any size
+    struct Rect {
+        left: i32,
+        right: i32,
+        top: i32,
+        bottom: i32,
+    }
+
+    // Consider where the walls are
+    // storing them as GridCoords in a HashSet for quick, easy lookup
+    //
+    // The key of this map will be the entity of the level the wall belongs to.
+    // This has two consequences in the resulting collision entities:
+    // 1. it forces the walls to be split along level boundaries
+    // 2. it lets us easily add the collision entities as children of the appropriate level entity
+    let mut level_to_wall_locations: HashMap<Entity, HashSet<GridCoords>> = HashMap::new();
+
+    wall_query.for_each(|(&grid_coords, parent)| {
+        // An intgrid tile's direct parent will be a layer entity, not the level entity
+        // To get the level entity, you need the tile's grandparent.
+        // This is where parent_query comes in.
+        if let Ok(grandparent) = parent_query.get(parent.get()) {
+            level_to_wall_locations
+                .entry(grandparent.get())
+                .or_default()
+                .insert(grid_coords);
+        }
+    });
+
+    if !wall_query.is_empty() {
+        level_query.for_each(|(level_entity, level_handle)| {
+            if let Some(level_walls) = level_to_wall_locations.get(&level_entity) {
+                let level = levels
+                    .get(level_handle)
+                    .expect("Level should be loaded by this point");
+
+                let LayerInstance {
+                    c_wid: width,
+                    c_hei: height,
+                    grid_size,
+                    ..
+                } = level
+                    .level
+                    .layer_instances
+                    .clone()
+                    .expect("Level asset should have layers")[0];
+
+                // combine wall tiles into flat "plates" in each individual row
+                let mut plate_stack: Vec<Vec<Plate>> = Vec::new();
+
+                for y in 0..height {
+                    let mut row_plates: Vec<Plate> = Vec::new();
+                    let mut plate_start = None;
+
+                    // + 1 to the width so the algorithm "terminates" plates that touch the right edge
+                    for x in 0..width + 1 {
+                        match (plate_start, level_walls.contains(&GridCoords { x, y })) {
+                            (Some(s), false) => {
+                                row_plates.push(Plate {
+                                    left: s,
+                                    right: x - 1,
+                                });
+                                plate_start = None;
+                            }
+                            (None, true) => plate_start = Some(x),
+                            _ => (),
+                        }
+                    }
+
+                    plate_stack.push(row_plates);
+                }
+
+                // combine "plates" into rectangles across multiple rows
+                let mut rect_builder: HashMap<Plate, Rect> = HashMap::new();
+                let mut prev_row: Vec<Plate> = Vec::new();
+                let mut wall_rects: Vec<Rect> = Vec::new();
+
+                // an extra empty row so the algorithm "finishes" the rects that touch the top edge
+                plate_stack.push(Vec::new());
+
+                for (y, current_row) in plate_stack.into_iter().enumerate() {
+                    for prev_plate in &prev_row {
+                        if !current_row.contains(prev_plate) {
+                            // remove the finished rect so that the same plate in the future starts a new rect
+                            if let Some(rect) = rect_builder.remove(prev_plate) {
+                                wall_rects.push(rect);
+                            }
+                        }
+                    }
+                    for plate in &current_row {
+                        rect_builder
+                            .entry(plate.clone())
+                            .and_modify(|e| e.top += 1)
+                            .or_insert(Rect {
+                                bottom: y as i32,
+                                top: y as i32,
+                                left: plate.left,
+                                right: plate.right,
+                            });
+                    }
+                    prev_row = current_row;
+                }
+
+                commands.entity(level_entity).with_children(|level| {
+                    for wall_rect in wall_rects {
+                        level
+                            .spawn_empty()
+                            .insert((
+                                Collider::cuboid(
+                                    (wall_rect.right as f32 - wall_rect.left as f32 + 1.)
+                                        * grid_size as f32
+                                        / 2.,
+                                    (wall_rect.top as f32 - wall_rect.bottom as f32 + 1.)
+                                        * grid_size as f32
+                                        / 2.,
+                                ),
+                                // Sensor {},
+                                ActiveEvents::COLLISION_EVENTS,
+                            ))
+                            .insert(RigidBody::Fixed)
+                            .insert(Friction::new(1.0))
+                            .insert(Transform::from_xyz(
+                                (wall_rect.left + wall_rect.right + 1) as f32 * grid_size as f32
+                                    / 2.,
+                                (wall_rect.bottom + wall_rect.top + 1) as f32 * grid_size as f32
+                                    / 2.,
+                                0.,
+                            ))
+                            .insert(GlobalTransform::default());
+                    }
+                });
+            }
+        });
+    }
+}
+
+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 },
+        }
+    }
+}
+
+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(crate) fn hide_dummy_mierdas(
+    mut commands: Commands,
+    level_selection: Res<LevelSelection>,
+    mut los_mierdas: Query<(Entity, &mut Visibility, &Mierda)>,
+    mut ev_spawn_mierda: EventWriter<SpawnMierdaEvent>,
+) {
+    if !level_selection.is_changed() {
+        return;
+    }
+
+    for (entity, mut visibility, mierda) in los_mierdas.iter_mut() {
+        if mierda.is_dummy {
+            *visibility = Visibility::Hidden;
+            commands.entity(entity).remove::<Collider>();
+
+            ev_spawn_mierda.send(SpawnMierdaEvent { count: 3 });
+        }
+    }
+}
diff --git a/src/physics.rs b/src/physics.rs
new file mode 100644
index 0000000..838d0de
--- /dev/null
+++ b/src/physics.rs
@@ -0,0 +1,35 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+use crate::{components::*, events::PlayerHitEvent};
+
+pub(crate) 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.;
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn handle_player_mierda_collisions(
+    mut collision_events: EventReader<CollisionEvent>,
+    mut q_player: Query<(Entity, &mut Player)>,
+    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() {
+                    ev_player_hit.send(PlayerHitEvent { entity: e });
+                }
+            }
+        }
+    }
+}
diff --git a/src/sprites.rs b/src/sprites.rs
new file mode 100644
index 0000000..3e6e4e6
--- /dev/null
+++ b/src/sprites.rs
@@ -0,0 +1,230 @@
+use bevy::{prelude::*, sprite::Anchor};
+
+use crate::components::Player;
+
+pub const SHEET_1_COLUMNS: usize = 13;
+pub const SHEET_1_ROWS: usize = 21;
+pub const SHEET_2_COLUMNS: usize = 6;
+pub const SHEET_2_ROWS: usize = 4;
+pub const N_FRAMES_WALK: usize = 8;
+pub const N_FRAMES_ATTACK: usize = 5;
+
+#[allow(dead_code)]
+#[derive(Component, Clone, Default, Debug, Reflect)]
+pub struct AnimationIndices {
+    pub first: usize,
+    pub last: usize,
+}
+
+#[derive(Clone, Default, Debug, Reflect)]
+pub enum AnimationState {
+    #[default]
+    Idle,
+    // Run,
+}
+
+#[derive(Clone, Default, Copy, PartialEq, Debug, Reflect)]
+pub enum AnimationDirection {
+    #[default]
+    Left,
+    Right,
+    Up,
+    Down,
+}
+
+#[derive(Clone, Default, Copy, PartialEq, Debug, Reflect)]
+pub enum AnimationType {
+    Walk,
+    #[default]
+    Stand,
+    Attack,
+}
+
+#[derive(Component, Clone, Default, Debug, Reflect)]
+pub struct CharacterAnimation {
+    pub state: AnimationState,
+    pub direction: AnimationDirection,
+    pub animation_type: AnimationType,
+}
+
+#[derive(Component, Reflect)]
+pub struct FlashingTimer {
+    pub timer: Timer,
+}
+
+#[derive(Component, Deref, DerefMut, Clone, Default, Reflect)]
+pub struct AnimationTimer(pub Timer);
+
+#[derive(Resource)]
+pub struct PlayerSpritesheets {
+    pub player_atlas_1: Handle<TextureAtlas>,
+    pub player_atlas_2: Handle<TextureAtlas>,
+    pub mierda_atlas: Handle<TextureAtlas>,
+}
+
+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";
+
+pub fn load_texture_atlas(
+    path: &str,
+    asset_server: &AssetServer,
+    sheet_columns: usize,
+    sheet_rows: usize,
+    padding: Option<Vec2>,
+    sprite_size: f32,
+    texture_atlasses: &mut Assets<TextureAtlas>,
+) -> Handle<TextureAtlas> {
+    let texture_handle = asset_server.load(path);
+
+    let atlas = TextureAtlas::from_grid(
+        texture_handle,
+        Vec2::ONE * sprite_size,
+        sheet_columns,
+        sheet_rows,
+        padding,
+        None,
+    );
+
+    texture_atlasses.add(atlas)
+}
+
+pub fn animate_sprite(
+    time: Res<Time>,
+    mut query: Query<
+        (
+            &mut Handle<TextureAtlas>,
+            &mut CharacterAnimation,
+            &mut AnimationTimer,
+            &mut TextureAtlasSprite,
+            &mut Transform,
+        ),
+        With<Player>,
+    >,
+    spritesheets: Res<PlayerSpritesheets>,
+) {
+    for (mut texture_atlas, mut character_animation, mut timer, mut sprite, mut _transform) in
+        &mut query
+    {
+        timer.tick(time.delta());
+
+        // fix sprite position
+        let mut indices = get_animation_indices(
+            character_animation.animation_type,
+            character_animation.direction,
+        );
+
+        if timer.just_finished() {
+            sprite.index = if (sprite.index >= indices.last) || (sprite.index < indices.first) {
+                // if attacking animation finished, go back to standing
+                if character_animation.animation_type == AnimationType::Attack
+                    && (sprite.index >= indices.last)
+                {
+                    character_animation.animation_type = AnimationType::Stand;
+                    texture_atlas.clone_from(&spritesheets.player_atlas_1);
+                }
+
+                if character_animation.animation_type == AnimationType::Stand {
+                    indices = get_animation_indices(
+                        character_animation.animation_type,
+                        character_animation.direction,
+                    );
+                }
+
+                indices.first
+            } else {
+                sprite.index + 1
+            };
+        }
+
+        if character_animation.animation_type == AnimationType::Walk
+            || character_animation.animation_type == AnimationType::Stand
+        {
+            sprite.anchor = Anchor::Custom(Vec2::new(0.0, -0.12));
+        } else if character_animation.animation_type == AnimationType::Attack {
+            sprite.anchor = Anchor::Custom(Vec2::new(0.0, -0.05));
+        }
+    }
+}
+
+#[allow(clippy::erasing_op)]
+pub fn get_animation_indices(
+    animation_type: AnimationType,
+    animation_direction: AnimationDirection,
+) -> AnimationIndices {
+    let mut first = 0;
+    let mut last = 0;
+
+    // Walk
+    if animation_type == AnimationType::Walk && animation_direction == AnimationDirection::Right {
+        first = SHEET_1_COLUMNS * 11 + 1;
+        last = SHEET_1_COLUMNS * 11 + N_FRAMES_WALK;
+    }
+    if animation_type == AnimationType::Walk && animation_direction == AnimationDirection::Left {
+        first = SHEET_1_COLUMNS * 9 + 1;
+        last = SHEET_1_COLUMNS * 9 + N_FRAMES_WALK;
+    }
+    if animation_type == AnimationType::Walk && animation_direction == AnimationDirection::Up {
+        first = SHEET_1_COLUMNS * 8 + 1;
+        last = SHEET_1_COLUMNS * 8 + N_FRAMES_WALK;
+    }
+    if animation_type == AnimationType::Walk && animation_direction == AnimationDirection::Down {
+        first = SHEET_1_COLUMNS * 10 + 1;
+        last = SHEET_1_COLUMNS * 10 + N_FRAMES_WALK;
+    }
+
+    // Stand
+    if animation_type == AnimationType::Stand && animation_direction == AnimationDirection::Right {
+        first = SHEET_1_COLUMNS * 11;
+        last = first;
+    }
+    if animation_type == AnimationType::Stand && animation_direction == AnimationDirection::Left {
+        first = SHEET_1_COLUMNS * 9;
+        last = first;
+    }
+    if animation_type == AnimationType::Stand && animation_direction == AnimationDirection::Up {
+        first = SHEET_1_COLUMNS * 8;
+        last = first;
+    }
+    if animation_type == AnimationType::Stand && animation_direction == AnimationDirection::Down {
+        first = SHEET_1_COLUMNS * 10;
+        last = first;
+    }
+
+    // Attack
+    if animation_type == AnimationType::Attack && animation_direction == AnimationDirection::Right {
+        first = SHEET_2_COLUMNS * 3;
+        last = SHEET_2_COLUMNS * 3 + N_FRAMES_ATTACK;
+    }
+    if animation_type == AnimationType::Attack && animation_direction == AnimationDirection::Left {
+        first = SHEET_2_COLUMNS;
+        last = SHEET_2_COLUMNS + N_FRAMES_ATTACK;
+    }
+    if animation_type == AnimationType::Attack && animation_direction == AnimationDirection::Up {
+        first = SHEET_2_COLUMNS * 0;
+        last = SHEET_2_COLUMNS * 0 + N_FRAMES_ATTACK;
+    }
+    if animation_type == AnimationType::Attack && animation_direction == AnimationDirection::Down {
+        first = SHEET_2_COLUMNS * 2;
+        last = SHEET_2_COLUMNS * 2 + N_FRAMES_ATTACK;
+    }
+
+    AnimationIndices { first, last }
+}
+
+pub fn flash_sprite(
+    mut commands: Commands,
+    mut flashing_query: Query<(&mut FlashingTimer, Entity, &mut TextureAtlasSprite)>,
+    time: Res<Time>,
+) {
+    for (mut timer, timer_e, mut timer_sprite) in flashing_query.iter_mut() {
+        timer_sprite.color = Color::rgba(1.0, 0.0, 0.0, 0.5);
+
+        timer.timer.tick(time.delta());
+
+        if timer.timer.finished() {
+            timer_sprite.color = Color::rgba(1.0, 1.0, 1.0, 1.0);
+            commands.entity(timer_e).remove::<FlashingTimer>();
+        }
+    }
+}
diff --git a/src/ui.rs b/src/ui.rs
new file mode 100644
index 0000000..77010a6
--- /dev/null
+++ b/src/ui.rs
@@ -0,0 +1,104 @@
+use bevy::prelude::*;
+
+#[derive(Component)]
+pub struct UiPlayerHealth;
+
+#[derive(Component)]
+pub struct UiGameOver;
+
+pub(crate) fn draw_ui(mut commands: Commands, asset_server: Res<AssetServer>) {
+    // alextime face
+    commands
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.0),
+                    position_type: PositionType::Absolute,
+                    justify_content: JustifyContent::Center,
+                    bottom: Val::Px(0.0),
+                    align_items: AlignItems::FlexStart,
+                    ..default()
+                },
+                ..default()
+            },
+            Name::new("ui face"),
+        ))
+        .with_children(|parent| {
+            parent.spawn((
+                NodeBundle {
+                    style: Style {
+                        width: Val::Px(125.0),
+                        height: Val::Px(125.0),
+                        margin: UiRect::top(Val::VMin(5.)),
+                        ..default()
+                    },
+                    background_color: Color::WHITE.into(),
+                    ..default()
+                },
+                UiImage::new(asset_server.load("face.png")),
+            ));
+        });
+    // health bar
+    commands
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(50.0),
+                    position_type: PositionType::Absolute,
+                    justify_content: JustifyContent::FlexStart,
+                    bottom: Val::Px(35.0),
+                    left: Val::Px(20.0),
+                    padding: UiRect {
+                        right: Val::Px(75.0),
+                        ..default()
+                    },
+                    align_items: AlignItems::FlexStart,
+                    ..default()
+                },
+                ..default()
+            },
+            Name::new("ui healthbar"),
+        ))
+        .with_children(|parent| {
+            parent
+                .spawn((NodeBundle {
+                    style: Style {
+                        width: Val::Percent(100.0),
+                        height: Val::Px(20.0),
+                        margin: UiRect::top(Val::VMin(5.)),
+                        ..default()
+                    },
+                    background_color: Color::RED.into(),
+                    ..default()
+                },))
+                .insert(UiPlayerHealth);
+        });
+    // game over
+    commands
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.0),
+                    position_type: PositionType::Absolute,
+                    justify_content: JustifyContent::Center,
+                    top: Val::Percent(33.0),
+                    align_items: AlignItems::FlexStart,
+                    ..default()
+                },
+                visibility: Visibility::Hidden,
+                ..default()
+            },
+            UiGameOver,
+            Name::new("ui game over"),
+        ))
+        .with_children(|parent| {
+            parent.spawn(TextBundle::from_section(
+                "GAME\nOVER",
+                TextStyle {
+                    font: asset_server.load("fonts/Mexicana.ttf"),
+                    font_size: 100.0,
+                    color: Color::WHITE,
+                },
+            ));
+        });
+}
diff --git a/src/utils.rs b/src/utils.rs
new file mode 100644
index 0000000..a869d9b
--- /dev/null
+++ b/src/utils.rs
@@ -0,0 +1,105 @@
+//! Bevy Version: 0.10
+//! Original: https://gist.github.com/GianpaoloBranca/17e5bd6ada9bdb04cca58182db8505d4
+//! See also: https://github.com/bevyengine/bevy/issues/1515
+
+use bevy::ecs::system::Command;
+use bevy::prelude::*;
+
+pub struct CloneEntity {
+    pub source: Entity,
+    pub destination: Entity,
+}
+
+impl CloneEntity {
+    // Copy all components from an entity to another.
+    // Using an entity with no components as the destination creates a copy of the source entity.
+    // Panics if:
+    // - the components are not registered in the type registry,
+    // - the world does not have a type registry
+    // - the source or destination entity do not exist
+    fn clone_entity(self, world: &mut World) {
+        let components = {
+            let registry = world.get_resource::<AppTypeRegistry>().unwrap().read();
+
+            world
+                .get_entity(self.source)
+                .unwrap()
+                .archetype()
+                .components()
+                .map(|component_id| {
+                    world
+                        .components()
+                        .get_info(component_id)
+                        .unwrap()
+                        .type_id()
+                        .unwrap()
+                })
+                .map(|type_id| {
+                    let tp = registry.get(type_id);
+                    tp?;
+                    tp.unwrap().data::<ReflectComponent>()
+                })
+                .filter(|comp| comp.is_some())
+                .map(|comp| comp.unwrap().clone())
+                .collect::<Vec<_>>()
+        };
+
+        for component in components {
+            let source = component
+                .reflect(world.get_entity(self.source).unwrap())
+                .unwrap()
+                .clone_value();
+
+            let mut destination = world.get_entity_mut(self.destination).unwrap();
+
+            component.apply_or_insert(&mut destination, &*source);
+        }
+    }
+}
+
+// This allows the command to be used in systems
+impl Command for CloneEntity {
+    fn apply(self, world: &mut World) {
+        self.clone_entity(world)
+    }
+}
+
+// **********************************************************
+// Adapt the code below to your needs
+// **********************************************************
+
+// Components must derive Reflect and use reflect(Component)
+// If your component includes some other structs, these have to derive from Reflect and FromReflect
+// #[derive(Component, Reflect, Default)]
+// #[reflect(Component)]
+// pub struct Foo {
+//     pub bar: i32,
+//     pub baz: bool,
+// }
+
+// // In your system, clone an entity like this:
+// fn clone_entity(mut commands: Commands /* whatever you want that gets your entity */) {
+//     // your code here to fetch the source entity
+//     // ...
+//     let copy = commands.spawn_empty().id();
+//     commands.add(CloneEntity {
+//         source: entity,
+//         destination: copy,
+//     });
+// }
+
+// // Also, remember to register your components in the App Type Registry!
+// // Some predefined components are already registered (e.g. Name)
+// // You can write your own plugin where you put all your registrations
+// fn main() {
+//     let mut app = App::new();
+
+//     {
+//         let registry = app.world.resource_mut::<AppTypeRegistry>();
+//         let mut wr = registry.write();
+//         wr.register::<Foo>();
+//         // other structs...
+//     }
+
+//     app.run()
+// }