diff --git a/assets/beach/beach.level.yaml b/assets/beach/beach.level.yaml
index 1ea6e8f4..de13534d 100644
--- a/assets/beach/beach.level.yaml
+++ b/assets/beach/beach.level.yaml
@@ -68,6 +68,11 @@ enemies:
   - fighter: *brute
     location: [450, 20, 0]
     trip_point_x: 300
+  - fighter: *brute
+    location: [1000, 20, 0]
+    trip_point_x: 700
+
+stop_points: [500, 1000]
 
 items:
   - item: &bottle /items/bottle/bottle.item.yaml
diff --git a/history/history.db b/history/history.db
new file mode 100644
index 00000000..806e3fef
Binary files /dev/null and b/history/history.db differ
diff --git a/src/attack.rs b/src/attack.rs
index d6a220fc..2901e4d9 100644
--- a/src/attack.rs
+++ b/src/attack.rs
@@ -25,10 +25,8 @@ use crate::{
     },
     input::PlayerAction,
     item::item_carried_by_player,
-    metadata::{FighterMeta, GameMeta, ItemMeta},
-    movement::{
-        clamp_player_movements, LeftMovementBoundary, MoveInArc, MoveInDirection, Rotate, Target,
-    },
+    metadata::{FighterMeta, ItemMeta},
+    movement::{MoveInArc, MoveInDirection, PlayerMovementClamper, Rotate, Target},
     state::State,
     ArrivedEvent, Enemy, GameState, Player, Stats,
 };
@@ -297,10 +295,9 @@ fn player_flop(
         ),
         With<Player>,
     >,
+    player_movement_clamper: PlayerMovementClamper,
     fighter_assets: Res<Assets<FighterMeta>>,
     time: Res<Time>,
-    left_movement_boundary: Res<LeftMovementBoundary>,
-    game_meta: Res<GameMeta>,
     mut start_y: Local<Option<f32>>,
 ) {
     let players_movement = query
@@ -387,8 +384,7 @@ fn player_flop(
         )
         .collect::<Vec<_>>();
 
-    let players_movement =
-        clamp_player_movements(players_movement, &left_movement_boundary, &game_meta);
+    let players_movement = player_movement_clamper.clamp(players_movement);
 
     for ((_, _, mut transform, _, _, _, _, _), player_dir) in query.iter_mut().zip(players_movement)
     {
diff --git a/src/enemy.rs b/src/enemy.rs
index 3ead3dea..95736b1d 100644
--- a/src/enemy.rs
+++ b/src/enemy.rs
@@ -14,10 +14,14 @@ pub struct Enemy;
 #[derive(Component)]
 pub struct TripPointX(pub f32);
 
+#[derive(Component)]
+pub struct SpawnLocationX(pub f32);
+
 #[derive(Bundle)]
 pub struct EnemyBundle {
     enemy: Enemy,
     facing: Facing,
+    spawn_location_x: SpawnLocationX,
     #[bundle]
     transform_bundle: TransformBundle,
     fighter_handle: Handle<FighterMeta>,
@@ -37,6 +41,7 @@ impl EnemyBundle {
         EnemyBundle {
             enemy: Enemy,
             facing: Facing::Left,
+            spawn_location_x: SpawnLocationX(enemy_pos.x),
             transform_bundle,
             fighter_handle,
             trip_point_x: TripPointX(enemy_meta.trip_point_x),
diff --git a/src/fighter.rs b/src/fighter.rs
new file mode 100644
index 00000000..63eb4d54
--- /dev/null
+++ b/src/fighter.rs
@@ -0,0 +1,71 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::CollisionGroups;
+use rand::prelude::SliceRandom;
+
+use crate::{
+    animation::Animation, collisions::BodyLayers, enemy::Enemy, metadata::FighterMeta,
+    player::Player, AnimatedSpriteSheetBundle, CharacterBundle, PhysicsBundle,
+};
+
+/// Bundle added to a fighter stub, in order to activate it.
+#[derive(Bundle)]
+pub struct ActiveFighterBundle {
+    name: Name,
+    #[bundle]
+    animated_spritesheet_bundle: AnimatedSpriteSheetBundle,
+    #[bundle]
+    character_bundle: CharacterBundle,
+    #[bundle]
+    physics_bundle: PhysicsBundle,
+}
+
+/// Turns a fighter stub data (loaded from the metadata) into a fully active fighter.
+impl ActiveFighterBundle {
+    pub fn activate_fighter_stub(
+        commands: &mut Commands,
+        fighter: &FighterMeta,
+        entity: Entity,
+        transform: &Transform,
+        player: Option<&Player>,
+        enemy: Option<&Enemy>,
+    ) {
+        let body_layers = if player.is_some() {
+            BodyLayers::PLAYER
+        } else if enemy.is_some() {
+            BodyLayers::ENEMY
+        } else {
+            unreachable!();
+        };
+
+        let active_fighter_bundle = ActiveFighterBundle {
+            name: Name::new(fighter.name.clone()),
+            animated_spritesheet_bundle: AnimatedSpriteSheetBundle {
+                sprite_sheet: SpriteSheetBundle {
+                    sprite: TextureAtlasSprite::new(0),
+                    texture_atlas: fighter
+                        .spritesheet
+                        .atlas_handle
+                        .choose(&mut rand::thread_rng())
+                        .unwrap()
+                        .clone(),
+                    transform: *transform,
+                    ..Default::default()
+                },
+                animation: Animation::new(
+                    fighter.spritesheet.animation_fps,
+                    fighter.spritesheet.animations.clone(),
+                ),
+            },
+            character_bundle: CharacterBundle {
+                stats: fighter.stats.clone(),
+                ..default()
+            },
+            physics_bundle: PhysicsBundle {
+                collision_groups: CollisionGroups::new(body_layers, BodyLayers::ALL),
+                ..default()
+            },
+        };
+
+        commands.entity(entity).insert_bundle(active_fighter_bundle);
+    }
+}
diff --git a/src/loading.rs b/src/loading.rs
index ed0cfe33..471a5beb 100644
--- a/src/loading.rs
+++ b/src/loading.rs
@@ -1,21 +1,20 @@
 use bevy::{asset::AssetStage, prelude::*};
 use bevy_parallax::ParallaxResource;
-use bevy_rapier2d::prelude::CollisionGroups;
 use iyes_loopless::{prelude::*, state::NextState};
 
 use rand::seq::SliceRandom;
 
 use crate::{
     animation::Animation,
-    collisions::BodyLayers,
     config::ENGINE_CONFIG,
     enemy::{Enemy, EnemyBundle},
+    fighter::ActiveFighterBundle,
     input::MenuAction,
     item::ItemBundle,
     metadata::{BorderImageMeta, FighterMeta, GameMeta, ItemMeta, LevelMeta, Settings},
     platform::Storage,
     player::{Player, PlayerBundle},
-    AnimatedSpriteSheetBundle, CharacterBundle, GameStage, GameState, PhysicsBundle, Stats,
+    GameStage, GameState, Stats,
 };
 
 use bevy::{ecs::system::SystemParam, render::camera::ScalingMode};
@@ -443,42 +442,14 @@ fn load_fighters(
 ) {
     for (entity, transform, fighter_handle, player, enemy) in fighters.iter() {
         if let Some(fighter) = fighter_assets.get(fighter_handle) {
-            let body_layers = if player.is_some() {
-                BodyLayers::PLAYER
-            } else if enemy.is_some() {
-                BodyLayers::ENEMY
-            } else {
-                unreachable!();
-            };
-
-            commands
-                .entity(entity)
-                .insert(Name::new(fighter.name.clone()))
-                .insert_bundle(AnimatedSpriteSheetBundle {
-                    sprite_sheet: SpriteSheetBundle {
-                        sprite: TextureAtlasSprite::new(0),
-                        texture_atlas: fighter
-                            .spritesheet
-                            .atlas_handle
-                            .choose(&mut rand::thread_rng())
-                            .unwrap()
-                            .clone(),
-                        transform: *transform,
-                        ..Default::default()
-                    },
-                    animation: Animation::new(
-                        fighter.spritesheet.animation_fps,
-                        fighter.spritesheet.animations.clone(),
-                    ),
-                })
-                .insert_bundle(CharacterBundle {
-                    stats: fighter.stats.clone(),
-                    ..default()
-                })
-                .insert_bundle(PhysicsBundle {
-                    collision_groups: CollisionGroups::new(body_layers, BodyLayers::ALL),
-                    ..default()
-                });
+            ActiveFighterBundle::activate_fighter_stub(
+                &mut commands,
+                fighter,
+                entity,
+                transform,
+                player,
+                enemy,
+            );
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index e2a7c1b8..1784049c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -33,6 +33,7 @@ mod collisions;
 mod config;
 mod consts;
 mod enemy;
+mod fighter;
 mod input;
 mod item;
 mod loading;
diff --git a/src/metadata.rs b/src/metadata.rs
index a510fbf8..0324d48e 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -72,6 +72,7 @@ pub struct LevelMeta {
     pub music: String,
     #[serde(skip)]
     pub music_handle: Handle<AudioSource>,
+    pub stop_points: Vec<f32>,
 }
 
 impl LevelMeta {
diff --git a/src/movement.rs b/src/movement.rs
index 45438cdb..bc3a4f24 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -1,4 +1,5 @@
 use bevy::{
+    ecs::system::SystemParam,
     math::{Quat, Vec2, Vec3},
     prelude::{
         Commands, Component, Deref, DerefMut, Entity, EventWriter, Query, Res, ResMut, Transform,
@@ -11,8 +12,9 @@ use leafwing_input_manager::prelude::ActionState;
 use crate::{
     animation::Facing,
     consts::{self, LEFT_BOUNDARY_MAX_DISTANCE},
+    enemy::SpawnLocationX,
     input::PlayerAction,
-    metadata::GameMeta,
+    metadata::{GameMeta, LevelMeta},
     state::State,
     ArrivedEvent, DespawnMarker, Player, Stats,
 };
@@ -40,9 +42,8 @@ pub struct Knockback {
 pub fn knockback_system(
     mut commands: Commands,
     mut query: Query<(Entity, &mut Transform, &mut Knockback, Option<&Player>)>,
+    player_movement_clamper: PlayerMovementClamper,
     time: Res<Time>,
-    game_meta: Res<GameMeta>,
-    left_movement_boundary: Res<LeftMovementBoundary>,
 ) {
     let mut all_knockbacks = query.iter_mut().collect::<Vec<_>>();
 
@@ -85,7 +86,7 @@ pub fn knockback_system(
         })
         .collect::<Vec<_>>();
 
-    let player_dirs = clamp_player_movements(player_movements, &left_movement_boundary, &game_meta);
+    let player_dirs = player_movement_clamper.clamp(player_movements);
 
     for ((_, transform, _, _), player_dir) in player_knockbacks.iter_mut().zip(player_dirs) {
         transform.translation += player_dir.unwrap().extend(0.);
@@ -103,9 +104,8 @@ pub fn player_controller(
         ),
         With<Player>,
     >,
+    player_movement_clamper: PlayerMovementClamper,
     time: Res<Time>,
-    game_meta: Res<GameMeta>,
-    left_movement_boundary: Res<LeftMovementBoundary>,
 ) {
     // Compute the new direction vectors; can be None if the state is not (idle or running).
     //
@@ -130,7 +130,7 @@ pub fn player_controller(
         })
         .collect::<Vec<_>>();
 
-    let player_dirs = clamp_player_movements(player_movements, &left_movement_boundary, &game_meta);
+    let player_dirs = player_movement_clamper.clamp(player_movements);
 
     for ((mut state, _, mut transform, mut facing, _), dir) in
         query.iter_mut().zip(player_dirs.iter())
@@ -286,71 +286,110 @@ pub fn update_left_movement_boundary(
     }
 }
 
-/// Returns the direction vectors, with X/Y clamping.
-///
-/// Not a system, but a utility method!.
-///
-/// player_movements: array of (location, direction vector).
-///
-/// WATCH OUT! All players must be included, even if they don't move, in which case, pass
-/// None as direction. This is because clamping is based on the position of _all_ the
-/// players.
-/// It's possible to pass an empty array; this can happen if the system doesn't guard the case
-/// where all the players are dead; an empty array will be returned.
-pub fn clamp_player_movements(
-    player_movements: Vec<(Vec3, Option<Vec2>)>,
-    left_movement_boundary: &LeftMovementBoundary,
-    game_meta: &GameMeta,
-) -> Vec<Option<Vec2>> {
-    // In the first pass, we perform the absolute clamping (screen limits), and we collect the data
-    // required for the relative clamping.
-
-    let mut min_new_player_x = f32::MAX;
-
-    let player_movements = player_movements
-        .iter()
-        .map(|(location, movement)| {
-            let new_movement = movement.map(|mut movement| {
-                let new_x = location.x + movement.x;
+#[derive(SystemParam)]
+pub struct PlayerMovementClamper<'w, 's> {
+    enemy_spawn_locations_query: Query<'w, 's, &'static SpawnLocationX>,
+    level_meta: Res<'w, LevelMeta>,
+    game_meta: Res<'w, GameMeta>,
+    left_movement_boundary: Res<'w, LeftMovementBoundary>,
+}
 
-                if new_x < left_movement_boundary.0 {
-                    movement.x = 0.;
+impl<'w, 's> PlayerMovementClamper<'w, 's> {
+    /// Returns the direction vectors, with X/Y clamping.
+    ///
+    /// Not a system, but a utility method!.
+    ///
+    /// player_movements: array of (location, direction vector).
+    /// enemy_spawn_location_query: spawn locations of _alive_ enemies.
+    ///
+    /// WATCH OUT! All players must be included, even if they don't move, in which case, pass
+    /// None as direction. This is because clamping is based on the position of _all_ the
+    /// players.
+    /// It's possible to pass an empty array; this can happen if the system doesn't guard the case
+    /// where all the players are dead; an empty array will be returned.
+    pub fn clamp(&self, mut player_movements: Vec<(Vec3, Option<Vec2>)>) -> Vec<Option<Vec2>> {
+        // In the first pass, we check the camera stop points. If a player is moving across a stop
+        // point, all the enemies up to that point must have been defeated, in order to move.
+
+        let current_stop_point = self.level_meta.stop_points.iter().find(|point_x| {
+            player_movements.iter().any(|(location, dir)| {
+                if let Some(dir) = dir {
+                    location.x < **point_x && **point_x <= location.x + dir.x
+                } else {
+                    false
                 }
+            })
+        });
+
+        if let Some(current_stop_point) = current_stop_point {
+            let any_enemy_behind_stop_point = self
+                .enemy_spawn_locations_query
+                .iter()
+                .any(|SpawnLocationX(spawn_x)| spawn_x <= current_stop_point);
+
+            if any_enemy_behind_stop_point {
+                for (location, movement) in player_movements.iter_mut() {
+                    if let Some(movement) = movement.as_mut() {
+                        // Can be simplified, but it's harder to understand.
+                        if location.x + movement.x > *current_stop_point {
+                            movement.x = 0.;
+                        }
+                    }
+                }
+            }
+        }
 
-                //Restrict player to the ground
-                let new_y = location.y + movement.y + consts::GROUND_OFFSET;
+        // Then, we perform the absolute clamping (screen top/left/bottom), and we collect the data
+        // required for the relative clamping.
 
-                if new_y >= consts::MAX_Y || new_y <= consts::MIN_Y {
-                    movement.y = 0.;
-                }
+        let mut min_new_player_x = f32::MAX;
 
-                (movement, new_x)
-            });
+        let player_movements = player_movements
+            .iter()
+            .map(|(location, movement)| {
+                let new_movement = movement.map(|mut movement| {
+                    let new_x = location.x + movement.x;
 
-            if let Some((_, new_x)) = new_movement {
-                min_new_player_x = min_new_player_x.min(new_x);
-            } else {
-                min_new_player_x = min_new_player_x.min(location.x);
-            }
+                    if new_x < self.left_movement_boundary.0 {
+                        movement.x = 0.;
+                    }
 
-            (location, new_movement)
-        })
-        .collect::<Vec<_>>();
+                    //Restrict player to the ground
+                    let new_y = location.y + movement.y + consts::GROUND_OFFSET;
 
-    // Then, we perform the clamping of the players relative to each other.
+                    if new_y >= consts::MAX_Y || new_y <= consts::MIN_Y {
+                        movement.y = 0.;
+                    }
 
-    let max_players_x_distance = LEFT_BOUNDARY_MAX_DISTANCE + game_meta.camera_move_right_boundary;
+                    (movement, new_x)
+                });
 
-    player_movements
-        .iter()
-        .map(|(_, player_movement)| {
-            player_movement.map(|(player_dir, new_player_x)| {
-                if new_player_x > min_new_player_x + max_players_x_distance {
-                    Vec2::ZERO
+                if let Some((_, new_x)) = new_movement {
+                    min_new_player_x = min_new_player_x.min(new_x);
                 } else {
-                    player_dir
+                    min_new_player_x = min_new_player_x.min(location.x);
                 }
+
+                (location, new_movement)
             })
-        })
-        .collect::<Vec<_>>()
+            .collect::<Vec<_>>();
+
+        // Then, we perform the clamping of the players relative to each other.
+
+        let max_players_x_distance =
+            LEFT_BOUNDARY_MAX_DISTANCE + self.game_meta.camera_move_right_boundary;
+
+        player_movements
+            .iter()
+            .map(|(_, player_movement)| {
+                player_movement.map(|(player_dir, new_player_x)| {
+                    if new_player_x > min_new_player_x + max_players_x_distance {
+                        Vec2::ZERO
+                    } else {
+                        player_dir
+                    }
+                })
+            })
+            .collect::<Vec<_>>()
+    }
 }