From c080f3f0c1444a3321e91187e4915fafc24e52e3 Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Sun, 10 Jul 2022 18:40:22 +0200
Subject: [PATCH 01/10] player_controller: Split in two stages, as preparation
 for camera bounds

---
 src/movement.rs | 75 +++++++++++++++++++++++++++++--------------------
 1 file changed, 44 insertions(+), 31 deletions(-)

diff --git a/src/movement.rs b/src/movement.rs
index 15c35239..2ba0f465 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -51,44 +51,57 @@ pub fn player_controller(
     >,
     time: Res<Time>,
 ) {
-    for (mut state, stats, mut transform, facing_option, input) in query.iter_mut() {
-        if *state != State::Idle && *state != State::Running {
-            break;
-        }
-
-        let mut dir = Vec2::ZERO;
-
-        if input.pressed(PlayerAction::Move) {
-            dir = input.action_axis_pair(PlayerAction::Move).unwrap().xy();
-        }
+    // Compute the new direction vectors; can be None if the state is not (idle or running).
+    //
+    let player_dirs = query
+        .iter()
+        .map(|(state, stats, transform, _, input)| {
+            if *state != State::Idle && *state != State::Running {
+                None
+            } else {
+                let mut dir = Vec2::ZERO;
 
-        // Apply speed
-        dir = dir * stats.movement_speed * time.delta_seconds();
+                if input.pressed(PlayerAction::Move) {
+                    dir = input.action_axis_pair(PlayerAction::Move).unwrap().xy();
+                }
 
-        //Restrict player to the ground
-        let new_y = transform.translation.y + dir.y + consts::GROUND_OFFSET;
+                // Apply speed
+                dir = dir * stats.movement_speed * time.delta_seconds();
 
-        if new_y >= consts::MAX_Y || new_y <= consts::MIN_Y {
-            dir.y = 0.;
-        }
+                //Restrict player to the ground
+                let new_y = transform.translation.y + dir.y + consts::GROUND_OFFSET;
 
-        //Move the player
-        transform.translation.x += dir.x;
-        transform.translation.y += dir.y;
+                if new_y >= consts::MAX_Y || new_y <= consts::MIN_Y {
+                    dir.y = 0.;
+                }
 
-        //Set the player state and direction
-        if let Some(mut facing) = facing_option {
-            if dir.x < 0. {
-                facing.set(Facing::Left);
-            } else if dir.x > 0. {
-                facing.set(Facing::Right);
+                //Move the player
+                Some(dir)
+            }
+        })
+        .collect::<Vec<_>>();
+
+    for ((mut state, _, mut transform, facing_option, _), dir) in
+        query.iter_mut().zip(player_dirs.iter())
+    {
+        if let Some(dir) = dir {
+            transform.translation.x += dir.x;
+            transform.translation.y += dir.y;
+
+            //Set the player state and direction
+            if let Some(mut facing) = facing_option {
+                if dir.x < 0. {
+                    facing.set(Facing::Left);
+                } else if dir.x > 0. {
+                    facing.set(Facing::Right);
+                }
             }
-        }
 
-        if dir == Vec2::ZERO {
-            state.set(State::Idle);
-        } else {
-            state.set(State::Running);
+            if dir == &Vec2::ZERO {
+                state.set(State::Idle);
+            } else {
+                state.set(State::Running);
+            }
         }
     }
 }

From d061ca5fc6f4f0664653e6b03c01e4974b532261 Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Sun, 10 Jul 2022 19:00:07 +0200
Subject: [PATCH 02/10] Add max_players_x_distance_fraction to GameMeta

---
 assets/default.game.yaml | 3 +++
 src/metadata.rs          | 1 +
 2 files changed, 4 insertions(+)

diff --git a/assets/default.game.yaml b/assets/default.game.yaml
index 1ccf6cdd..5897f3a1 100644
--- a/assets/default.game.yaml
+++ b/assets/default.game.yaml
@@ -1,5 +1,8 @@
 start_level: beach/beach.level.yaml
 camera_height: 448
+# Allowed x distance between players, as a fraction of the screen width.
+# This is also used for camera move, so be careful.
+max_players_x_distance_fraction: 0.25
 
 main_menu:
   title_font:
diff --git a/src/metadata.rs b/src/metadata.rs
index f93d179a..3b0a2bbf 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -34,6 +34,7 @@ pub struct GameMeta {
     pub main_menu: MainMenuMeta,
     pub ui_theme: UIThemeMeta,
     pub camera_height: u32,
+    pub max_players_x_distance_fraction: f32,
 
     pub default_input_maps: InputMapsMeta,
     pub translations: TranslationsMeta,

From fac3ed78fb09bf1e53e6684ab8013b1e111cecdf Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Sun, 10 Jul 2022 20:15:19 +0200
Subject: [PATCH 03/10] Limit players distance

---
 src/movement.rs | 40 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 37 insertions(+), 3 deletions(-)

diff --git a/src/movement.rs b/src/movement.rs
index 2ba0f465..a885b9c4 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -4,12 +4,13 @@ use bevy::{
     prelude::{
         Commands, Component, Deref, DerefMut, Entity, EventWriter, Query, Res, Transform, With,
     },
+    window::Windows,
 };
 use leafwing_input_manager::prelude::ActionState;
 
 use crate::{
-    animation::Facing, consts, input::PlayerAction, item::ThrowItemEvent, state::State,
-    ArrivedEvent, DespawnMarker, Player, Stats,
+    animation::Facing, consts, input::PlayerAction, item::ThrowItemEvent, metadata::GameMeta,
+    state::State, ArrivedEvent, DespawnMarker, Player, Stats,
 };
 
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
@@ -50,10 +51,17 @@ pub fn player_controller(
         With<Player>,
     >,
     time: Res<Time>,
+    game_meta: Res<GameMeta>,
+    windows: Res<Windows>,
 ) {
+    let players_x = query
+        .iter()
+        .map(|(_, _, transform, _, _)| transform.translation.x)
+        .collect::<Vec<_>>();
+
     // Compute the new direction vectors; can be None if the state is not (idle or running).
     //
-    let player_dirs = query
+    let mut player_dirs = query
         .iter()
         .map(|(state, stats, transform, _, input)| {
             if *state != State::Idle && *state != State::Running {
@@ -81,6 +89,32 @@ pub fn player_controller(
         })
         .collect::<Vec<_>>();
 
+    if player_dirs.len() == 2 {
+        let window_width = windows.get_primary().unwrap().width();
+        let max_players_x_distance = window_width * game_meta.max_players_x_distance_fraction;
+
+        let new_players_x = players_x
+            .iter()
+            .zip(player_dirs.iter())
+            .map(|(x, dir)| x + dir.unwrap_or(Vec2::ZERO).x)
+            .collect::<Vec<_>>();
+
+        if (new_players_x[0] - new_players_x[1]).abs() > max_players_x_distance {
+            let right_player_i = if new_players_x[0] > new_players_x[1] {
+                0
+            } else {
+                1
+            };
+
+            // We could clamp the dir.x, however, if we do that, we'd have to deal with jitter.
+            // Since we assume that the movement in each frame is small, we just stop the movement.
+            //
+            if player_dirs[right_player_i].unwrap().x > 0. {
+                player_dirs[right_player_i] = Some(Vec2::ZERO);
+            }
+        }
+    }
+
     for ((mut state, _, mut transform, facing_option, _), dir) in
         query.iter_mut().zip(player_dirs.iter())
     {

From 8eee957ee6d70fe84da3f2356e21d9ab5cc5dd6e Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Sun, 10 Jul 2022 20:41:11 +0200
Subject: [PATCH 04/10] Fix redundant camera operation in camera_follow_player

Setting the x value there is not necessary, and it's actually very confusing.
---
 src/camera.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/camera.rs b/src/camera.rs
index 25f207fc..199d3c05 100644
--- a/src/camera.rs
+++ b/src/camera.rs
@@ -77,7 +77,7 @@ pub fn camera_follow_player(
 
         let diff = player.translation.x - (camera.translation.x - panning.offset.x);
 
-        camera.translation.x = player.translation.x + panning.offset.x;
+        // The x axis is handled by the parallax plugin.
         camera.translation.y = consts::GROUND_Y + panning.offset.y;
 
         move_event_writer.send(ParallaxMoveEvent {

From 45db3a9feb0b894e9a0b737ef9c06bffdd742001 Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Sun, 10 Jul 2022 21:32:54 +0200
Subject: [PATCH 05/10] Add LeftMovementBoundary resource and base logic

---
 src/consts.rs   |  3 +++
 src/main.rs     |  2 ++
 src/movement.rs | 37 +++++++++++++++++++++++++++++++++++--
 3 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/src/consts.rs b/src/consts.rs
index a0b59865..6f51b81d 100644
--- a/src/consts.rs
+++ b/src/consts.rs
@@ -3,6 +3,9 @@ pub const PLAYER_SPRITE_HEIGHT: f32 = 80.;
 pub const PLAYER_HITBOX_HEIGHT: f32 = 50.;
 
 pub const PLAYER_HEIGHT: f32 = PLAYER_SPRITE_HEIGHT - 50.;
+// Distance from the player, after which the player movement boundary is moved forward.
+//
+pub const LEFT_BOUNDARY_MAX_DISTANCE: f32 = 380.;
 
 pub const GROUND_Y: f32 = -120.;
 pub const GROUND_HEIGHT: f32 = 150.;
diff --git a/src/main.rs b/src/main.rs
index 696b13f1..5f34a54c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -222,6 +222,7 @@ fn main() {
         .add_plugin(ParallaxPlugin)
         .add_plugin(UIPlugin)
         .insert_resource(ParallaxResource::default())
+        .insert_resource(LeftMovementBoundary::default())
         .add_system(game_init::load_game.run_in_state(GameState::LoadingGame))
         .add_system(load_level.run_in_state(GameState::LoadingLevel))
         .add_system_set(
@@ -270,6 +271,7 @@ fn main() {
                 .with_system(move_in_arc_system)
                 .with_system(rotate_system)
                 .with_system(camera_follow_player)
+                .with_system(update_left_movement_boundary)
                 .into(),
         )
         .add_system_to_stage(CoreStage::Last, despawn_entities);
diff --git a/src/movement.rs b/src/movement.rs
index a885b9c4..7c8856b1 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -2,14 +2,15 @@ use bevy::{
     core::{Time, Timer},
     math::{Quat, Vec2, Vec3Swizzles},
     prelude::{
-        Commands, Component, Deref, DerefMut, Entity, EventWriter, Query, Res, Transform, With,
+        Commands, Component, Deref, DerefMut, Entity, EventWriter, Query, Res, ResMut, Transform,
+        With,
     },
     window::Windows,
 };
 use leafwing_input_manager::prelude::ActionState;
 
 use crate::{
-    animation::Facing, consts, input::PlayerAction, item::ThrowItemEvent, metadata::GameMeta,
+    animation::Facing, consts::{self, LEFT_BOUNDARY_MAX_DISTANCE}, input::PlayerAction, item::ThrowItemEvent, metadata::GameMeta,
     state::State, ArrivedEvent, DespawnMarker, Player, Stats,
 };
 
@@ -17,6 +18,16 @@ use crate::{
 #[derive(Component, Deref, DerefMut)]
 pub struct MoveInDirection(pub Vec2);
 
+// (Moving) bondary before which, the players can't go back.
+#[derive(Component)]
+pub struct LeftMovementBoundary(f32);
+
+impl Default for LeftMovementBoundary {
+    fn default() -> Self {
+        Self(-LEFT_BOUNDARY_MAX_DISTANCE)
+    }
+}
+
 #[derive(Component)]
 pub struct Knockback {
     pub direction: Vec2,
@@ -53,6 +64,7 @@ pub fn player_controller(
     time: Res<Time>,
     game_meta: Res<GameMeta>,
     windows: Res<Windows>,
+    left_movement_boundary: Res<LeftMovementBoundary>,
 ) {
     let players_x = query
         .iter()
@@ -76,6 +88,16 @@ pub fn player_controller(
                 // Apply speed
                 dir = dir * stats.movement_speed * time.delta_seconds();
 
+                let new_x = transform.translation.x + dir.x;
+
+                // The dir.x condition allows some flexibility (e.g. in case of knockback), given
+                // the current state of development. To be removed once the movement logic is
+                // stabilized.
+                //
+                if dir.x < 0. && new_x < left_movement_boundary.0 {
+                    dir.x = 0.;
+                }
+
                 //Restrict player to the ground
                 let new_y = transform.translation.y + dir.y + consts::GROUND_OFFSET;
 
@@ -283,3 +305,14 @@ pub fn move_to_target(
         }
     }
 }
+
+pub fn update_left_movement_boundary(
+    query: Query<&Transform, With<Player>>,
+    mut boundary: ResMut<LeftMovementBoundary>,
+) {
+    for transform in query.iter() {
+        boundary.0 = boundary
+            .0
+            .max(transform.translation.x - LEFT_BOUNDARY_MAX_DISTANCE)
+    }
+}

From c1d57fda5b393180ca49cd0afa85c1c92fee9317 Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Sun, 10 Jul 2022 23:33:03 +0200
Subject: [PATCH 06/10] Add support for arbitrary number of players to movement
 limitation

---
 src/movement.rs | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/movement.rs b/src/movement.rs
index 7c8856b1..727012f9 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -10,8 +10,13 @@ use bevy::{
 use leafwing_input_manager::prelude::ActionState;
 
 use crate::{
-    animation::Facing, consts::{self, LEFT_BOUNDARY_MAX_DISTANCE}, input::PlayerAction, item::ThrowItemEvent, metadata::GameMeta,
-    state::State, ArrivedEvent, DespawnMarker, Player, Stats,
+    animation::Facing,
+    consts::{self, LEFT_BOUNDARY_MAX_DISTANCE},
+    input::PlayerAction,
+    item::ThrowItemEvent,
+    metadata::GameMeta,
+    state::State,
+    ArrivedEvent, DespawnMarker, Player, Stats,
 };
 
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
@@ -111,7 +116,7 @@ pub fn player_controller(
         })
         .collect::<Vec<_>>();
 
-    if player_dirs.len() == 2 {
+    if player_dirs.len() > 1 {
         let window_width = windows.get_primary().unwrap().width();
         let max_players_x_distance = window_width * game_meta.max_players_x_distance_fraction;
 
@@ -121,18 +126,16 @@ pub fn player_controller(
             .map(|(x, dir)| x + dir.unwrap_or(Vec2::ZERO).x)
             .collect::<Vec<_>>();
 
-        if (new_players_x[0] - new_players_x[1]).abs() > max_players_x_distance {
-            let right_player_i = if new_players_x[0] > new_players_x[1] {
-                0
-            } else {
-                1
-            };
+        let min_player_x = new_players_x
+            .iter()
+            .min_by(|ax, bx| ax.total_cmp(bx))
+            .unwrap();
 
-            // We could clamp the dir.x, however, if we do that, we'd have to deal with jitter.
-            // Since we assume that the movement in each frame is small, we just stop the movement.
-            //
-            if player_dirs[right_player_i].unwrap().x > 0. {
-                player_dirs[right_player_i] = Some(Vec2::ZERO);
+        for (player_dir, player_x) in player_dirs.iter_mut().zip(new_players_x.iter()) {
+            if let Some(player_dir) = player_dir.as_mut() {
+                if *player_x > min_player_x + max_players_x_distance {
+                    *player_dir = Vec2::ZERO;
+                }
             }
         }
     }

From e501dd4f6ae42ec30b3e2dfcaf18ff1a038ceaf9 Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Mon, 11 Jul 2022 00:14:32 +0200
Subject: [PATCH 07/10] Add GameMeta#camera_move_right_boundary

---
 assets/default.game.yaml | 2 ++
 src/metadata.rs          | 1 +
 2 files changed, 3 insertions(+)

diff --git a/assets/default.game.yaml b/assets/default.game.yaml
index 5897f3a1..3c6c72fd 100644
--- a/assets/default.game.yaml
+++ b/assets/default.game.yaml
@@ -3,6 +3,8 @@ camera_height: 448
 # Allowed x distance between players, as a fraction of the screen width.
 # This is also used for camera move, so be careful.
 max_players_x_distance_fraction: 0.25
+# Distance of the rightmost player from the center of the camera, after which the camera moves.
+camera_move_right_boundary: 150.
 
 main_menu:
   title_font:
diff --git a/src/metadata.rs b/src/metadata.rs
index 3b0a2bbf..930808e2 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -35,6 +35,7 @@ pub struct GameMeta {
     pub ui_theme: UIThemeMeta,
     pub camera_height: u32,
     pub max_players_x_distance_fraction: f32,
+    pub camera_move_right_boundary: f32,
 
     pub default_input_maps: InputMapsMeta,
     pub translations: TranslationsMeta,

From e90fe4141f37ed9925049e1db7fcc9186e0d7150 Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Mon, 11 Jul 2022 00:36:28 +0200
Subject: [PATCH 08/10] Move camera based on a player location threshold

---
 src/camera.rs | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/camera.rs b/src/camera.rs
index 199d3c05..957d0f5b 100644
--- a/src/camera.rs
+++ b/src/camera.rs
@@ -11,7 +11,7 @@ use bevy::{
 use bevy_parallax::ParallaxMoveEvent;
 use leafwing_input_manager::prelude::ActionState;
 
-use crate::{consts, input::CameraAction, Player};
+use crate::{consts, input::CameraAction, metadata::GameMeta, Player};
 
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
 #[derive(Component)]
@@ -66,22 +66,31 @@ pub fn helper_camera_controller(
     }
 }
 
+/// Moves the camera according to the RIGHT_BOUNDARY_DISTANCE. Note that this does not enforce
+/// limitations of any kind - that's up to the players movement logic (e.g. max distance).
 pub fn camera_follow_player(
     player_query: Query<&Transform, With<Player>>,
     mut camera_query: Query<(&mut Transform, &Panning), (With<Camera>, Without<Player>)>,
     mut move_event_writer: EventWriter<ParallaxMoveEvent>,
+    game_meta: Res<GameMeta>,
 ) {
-    // TODO: Follow both players, not just the first one
-    if let Some(player) = player_query.iter().next() {
-        let (mut camera, panning) = camera_query.single_mut();
+    let max_player_x = player_query
+        .iter()
+        .map(|transform| transform.translation.x)
+        .max_by(|ax, bx| ax.total_cmp(bx))
+        .unwrap();
 
-        let diff = player.translation.x - (camera.translation.x - panning.offset.x);
+    let (mut camera, panning) = camera_query.single_mut();
 
+    let max_player_x_diff =
+        max_player_x - camera.translation.x - game_meta.camera_move_right_boundary;
+
+    if max_player_x_diff > 0. {
         // The x axis is handled by the parallax plugin.
         camera.translation.y = consts::GROUND_Y + panning.offset.y;
 
         move_event_writer.send(ParallaxMoveEvent {
-            camera_move_speed: diff * consts::CAMERA_SPEED,
+            camera_move_speed: max_player_x_diff * consts::CAMERA_SPEED,
         });
     }
 }

From a299a1d0b6aae79ae539c07a6ca2bf81abe55955 Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Mon, 11 Jul 2022 00:45:08 +0200
Subject: [PATCH 09/10] Fully implement a movement/camera boundary box (line,
 actually)

This has also the side effect of simplifying the logic :)
---
 assets/default.game.yaml | 4 +---
 src/metadata.rs          | 1 -
 src/movement.rs          | 6 ++----
 3 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/assets/default.game.yaml b/assets/default.game.yaml
index 3c6c72fd..b617f838 100644
--- a/assets/default.game.yaml
+++ b/assets/default.game.yaml
@@ -1,9 +1,7 @@
 start_level: beach/beach.level.yaml
 camera_height: 448
-# Allowed x distance between players, as a fraction of the screen width.
-# This is also used for camera move, so be careful.
-max_players_x_distance_fraction: 0.25
 # Distance of the rightmost player from the center of the camera, after which the camera moves.
+# For simplicity, this value can also be used for movement limitation calculations.
 camera_move_right_boundary: 150.
 
 main_menu:
diff --git a/src/metadata.rs b/src/metadata.rs
index 930808e2..83ffce85 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -34,7 +34,6 @@ pub struct GameMeta {
     pub main_menu: MainMenuMeta,
     pub ui_theme: UIThemeMeta,
     pub camera_height: u32,
-    pub max_players_x_distance_fraction: f32,
     pub camera_move_right_boundary: f32,
 
     pub default_input_maps: InputMapsMeta,
diff --git a/src/movement.rs b/src/movement.rs
index 727012f9..279ce9cf 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -5,7 +5,6 @@ use bevy::{
         Commands, Component, Deref, DerefMut, Entity, EventWriter, Query, Res, ResMut, Transform,
         With,
     },
-    window::Windows,
 };
 use leafwing_input_manager::prelude::ActionState;
 
@@ -68,7 +67,6 @@ pub fn player_controller(
     >,
     time: Res<Time>,
     game_meta: Res<GameMeta>,
-    windows: Res<Windows>,
     left_movement_boundary: Res<LeftMovementBoundary>,
 ) {
     let players_x = query
@@ -117,8 +115,8 @@ pub fn player_controller(
         .collect::<Vec<_>>();
 
     if player_dirs.len() > 1 {
-        let window_width = windows.get_primary().unwrap().width();
-        let max_players_x_distance = window_width * game_meta.max_players_x_distance_fraction;
+        let max_players_x_distance =
+            LEFT_BOUNDARY_MAX_DISTANCE + game_meta.camera_move_right_boundary;
 
         let new_players_x = players_x
             .iter()

From 7f22dcbda1a35f91f2183380315d0006d39247ce Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Mon, 11 Jul 2022 01:02:50 +0200
Subject: [PATCH 10/10] Adjust update_left_movement_boundary logic to new
 camera

---
 src/movement.rs | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/movement.rs b/src/movement.rs
index 279ce9cf..26454208 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -310,10 +310,15 @@ pub fn move_to_target(
 pub fn update_left_movement_boundary(
     query: Query<&Transform, With<Player>>,
     mut boundary: ResMut<LeftMovementBoundary>,
+    game_meta: Res<GameMeta>,
 ) {
-    for transform in query.iter() {
-        boundary.0 = boundary
-            .0
-            .max(transform.translation.x - LEFT_BOUNDARY_MAX_DISTANCE)
-    }
+    let max_player_x = query
+        .iter()
+        .map(|transform| transform.translation.x)
+        .max_by(|ax, bx| ax.total_cmp(bx))
+        .unwrap();
+
+    boundary.0 = boundary
+        .0
+        .max(max_player_x - game_meta.camera_move_right_boundary - LEFT_BOUNDARY_MAX_DISTANCE);
 }