refactor(player): separate into 2 systems

src/player/systems/input.rs

@@ -0,0 +1,28 @@
+use crate::player::components::Player;
+use bevy::prelude::*;
+use hexx::EdgeDirection;
+
+const fn create_direction(key: &KeyCode) -> Option<EdgeDirection> {
+    match key {
+        KeyCode::KeyD => Some(EdgeDirection::FLAT_SOUTH),
+        KeyCode::KeyS => Some(EdgeDirection::FLAT_NORTH_EAST),
+        KeyCode::KeyA => Some(EdgeDirection::FLAT_NORTH),
+        KeyCode::KeyQ => Some(EdgeDirection::FLAT_NORTH_WEST),
+        KeyCode::KeyW => Some(EdgeDirection::FLAT_SOUTH_WEST),
+        KeyCode::KeyE => Some(EdgeDirection::FLAT_SOUTH_EAST),
+        _ => None,
+    }
+}
+
+pub(super) fn player_input(input: Res<ButtonInput<KeyCode>>, mut player_query: Query<&mut Player>) {
+    for mut player in player_query.iter_mut() {
+        if player.target_hex.is_some() {
+            continue;
+        }
+
+        if let Some(direction) = input.get_pressed().find_map(|key| create_direction(key)) {
+            let next_hex = player.current_hex + direction.into_hex();
+            player.target_hex = Some(next_hex);
+        }
+    }
+}

src/player/systems/mod.rs

@@ -1,9 +1,11 @@
-pub mod movement;
+mod input;
+mod movement;
 pub mod spawn;
 
 use bevy::prelude::*;
+use input::player_input;
 use movement::player_movement;
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_systems(Update, player_movement);
+    app.add_systems(Update, (player_input, player_movement.after(player_input)));
 }

src/player/systems/movement.rs

@@ -1,52 +1,66 @@
 use crate::{maze::MazeConfig, player::components::Player};
 use bevy::prelude::*;
-use hexx::EdgeDirection;
+use hexx::Hex;
 
-const fn create_direction(key: &KeyCode) -> Option<EdgeDirection> {
+pub(super) fn player_movement(
-    match key {
-        KeyCode::KeyD => Some(EdgeDirection::FLAT_SOUTH),
-        KeyCode::KeyS => Some(EdgeDirection::FLAT_NORTH_EAST),
-        KeyCode::KeyA => Some(EdgeDirection::FLAT_NORTH),
-        KeyCode::KeyQ => Some(EdgeDirection::FLAT_NORTH_WEST),
-        KeyCode::KeyW => Some(EdgeDirection::FLAT_SOUTH_WEST),
-        KeyCode::KeyE => Some(EdgeDirection::FLAT_SOUTH_EAST),
-        _ => None,
-    }
-}
-
-pub fn player_movement(
     time: Res<Time>,
-    input: Res<ButtonInput<KeyCode>>,
     mut player_query: Query<(&mut Player, &mut Transform)>,
     maze_config: Res<MazeConfig>,
 ) {
     for (mut player, mut transform) in player_query.iter_mut() {
-        if let Some(direction) = input.get_pressed().find_map(|key| create_direction(key)) {
-            let next_hex = player.current_hex + direction.into_hex();
-            player.target_hex = Some(next_hex);
-        }
-
         if let Some(target_hex) = player.target_hex {
             let current_pos = transform.translation;
-            let target_pos = {
+            let target_pos = calculate_target_position(&maze_config, target_hex, current_pos.y);
-                let world_pos = maze_config.layout.hex_to_world_pos(target_hex);
-                Vec3::new(world_pos.x, current_pos.y, world_pos.y)
-            };
-            let direction = target_pos - current_pos;
-            let distance = direction.length();
 
-            if distance < 0.1 {
+            if should_complete_movement(current_pos, target_pos) {
-                transform.translation = target_pos;
+                complete_movement(&mut player, &mut transform, target_pos, target_hex);
-                player.current_hex = target_hex;
+                continue;
-                player.target_hex = None;
-            } else {
-                let movement = direction.normalize() * player.speed * time.delta_seconds();
-                if movement.length() > distance {
-                    transform.translation = target_pos;
-                } else {
-                    transform.translation += movement;
-                }
             }
+
+            update_position(
+                &mut transform,
+                current_pos,
+                target_pos,
+                player.speed,
+                time.delta_seconds(),
+            );
         }
     }
 }
+
+fn calculate_target_position(maze_config: &MazeConfig, target_hex: Hex, y: f32) -> Vec3 {
+    let world_pos = maze_config.layout.hex_to_world_pos(target_hex);
+    Vec3::new(world_pos.x, y, world_pos.y)
+}
+
+fn should_complete_movement(current_pos: Vec3, target_pos: Vec3) -> bool {
+    (target_pos - current_pos).length() < 0.1
+}
+
+fn complete_movement(
+    player: &mut Player,
+    transform: &mut Transform,
+    target_pos: Vec3,
+    target_hex: Hex,
+) {
+    transform.translation = target_pos;
+    player.current_hex = target_hex;
+    player.target_hex = None;
+}
+
+fn update_position(
+    transform: &mut Transform,
+    current_pos: Vec3,
+    target_pos: Vec3,
+    speed: f32,
+    delta_time: f32,
+) {
+    let direction = target_pos - current_pos;
+    let movement = direction.normalize() * speed * delta_time;
+
+    if movement.length() > direction.length() {
+        transform.translation = target_pos;
+        return;
+    }
+    transform.translation += movement;
+}