Implement first version of camera stopping

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

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)
     {

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),

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);
+    }
+}

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,
+            );
         }
     }
 }

src/main.rs

@@ -33,6 +33,7 @@ mod collisions;
 mod config;
 mod consts;
 mod enemy;
+mod fighter;
 mod input;
 mod item;
 mod loading;

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 {