diff --git a/src/bullet.rs b/src/bullet.rs
index 2ab56c3..5481fb0 100644
--- a/src/bullet.rs
+++ b/src/bullet.rs
@@ -1,17 +1,17 @@
 use bevy::prelude::*;
 
-use crate::components::{Bullet, Enemy, EnemyBullet, EnemyType};
+use crate::components::{Bullet, Enemy, EnemyBullet, EnemyType, Invincible, Player};
 use crate::constants::{
-    BULLET_ENEMY_COLLISION_THRESHOLD, BULLET_SIZE, BULLET_SPEED, ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD,
-    ENEMY_BULLET_SIZE, ENEMY_BULLET_SPEED, WINDOW_HEIGHT,
+    BULLET_ENEMY_COLLISION_THRESHOLD, BULLET_SIZE, BULLET_SPEED,
+    ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD, ENEMY_BULLET_SIZE, ENEMY_BULLET_SPEED, WINDOW_HEIGHT,
 };
-use crate::resources::{PlayerLives, PlayerRespawnTimer, Score};
 use crate::game_state::AppState;
-use crate::components::Player; // Needed for check_enemy_bullet_player_collisions
-use crate::components::Invincible; // Needed for check_enemy_bullet_player_collisions
+use crate::player::kill_player;
+use crate::resources::{PlayerLives, PlayerRespawnTimer, Score};
 use crate::systems::spawn_explosion;
 
-// --- Player Bullet Systems ---
+const GRUNT_POINTS: u32 = 100;
+const BOSS_POINTS: u32 = 100; // TODO(GAL-27): differentiate Boss from Grunt scoring
 
 pub fn move_bullets(
     mut query: Query<(Entity, &mut Transform), With<Bullet>>,
@@ -20,7 +20,6 @@ pub fn move_bullets(
 ) {
     for (entity, mut transform) in query.iter_mut() {
         transform.translation.y += BULLET_SPEED * time.delta_secs();
-
         if transform.translation.y > WINDOW_HEIGHT / 2.0 + BULLET_SIZE.y {
             commands.entity(entity).despawn();
         }
@@ -30,35 +29,26 @@ pub fn move_bullets(
 pub fn check_bullet_collisions(
     mut commands: Commands,
     bullet_query: Query<(Entity, &Transform), With<Bullet>>,
-    enemy_query: Query<(Entity, &Transform, &Enemy), With<Enemy>>, // Fetch Enemy component too
-    mut score: ResMut<Score>,                                      // Add Score resource
+    enemy_query: Query<(Entity, &Transform, &Enemy)>,
+    mut score: ResMut<Score>,
 ) {
     for (bullet_entity, bullet_transform) in bullet_query.iter() {
-        for (enemy_entity, enemy_transform, enemy) in enemy_query.iter() {
-            // Get Enemy component
-            let distance = bullet_transform
-                .translation
-                .distance(enemy_transform.translation);
+        let hit = enemy_query.iter().find(|(_, t, _)| {
+            bullet_transform.translation.distance(t.translation) < BULLET_ENEMY_COLLISION_THRESHOLD
+        });
 
-            if distance < BULLET_ENEMY_COLLISION_THRESHOLD {
-                commands.entity(bullet_entity).despawn();
-                spawn_explosion(&mut commands, enemy_transform.translation);
-                commands.entity(enemy_entity).despawn();
-                // Increment score based on enemy type
-                let points = match enemy.enemy_type {
-                    EnemyType::Grunt => 100,
-                    EnemyType::Boss => 100, // Same points as Grunt for now
-                };
-                score.value += points;
-                println!("Enemy hit by player bullet! Score: {}", score.value); // Log score update
-                break; // Bullet only hits one enemy
-            }
+        if let Some((enemy_entity, enemy_transform, enemy)) = hit {
+            commands.entity(bullet_entity).despawn();
+            spawn_explosion(&mut commands, enemy_transform.translation);
+            commands.entity(enemy_entity).despawn();
+            score.value += match enemy.enemy_type {
+                EnemyType::Grunt => GRUNT_POINTS,
+                EnemyType::Boss => BOSS_POINTS,
+            };
         }
     }
 }
 
-// --- Enemy Bullet Systems ---
-
 pub fn move_enemy_bullets(
     mut commands: Commands,
     time: Res<Time>,
@@ -66,51 +56,38 @@ pub fn move_enemy_bullets(
 ) {
     for (entity, mut transform) in query.iter_mut() {
         transform.translation.y -= ENEMY_BULLET_SPEED * time.delta_secs();
-
-        // Despawn if off screen (bottom)
         if transform.translation.y < -WINDOW_HEIGHT / 2.0 - ENEMY_BULLET_SIZE.y {
             commands.entity(entity).despawn();
         }
     }
 }
 
-// Check collisions between enemy bullets and the player
 pub fn check_enemy_bullet_player_collisions(
     mut commands: Commands,
     mut lives: ResMut<PlayerLives>,
     mut respawn_timer: ResMut<PlayerRespawnTimer>,
     mut next_state: ResMut<NextState<AppState>>,
-    // Player query matching the run_if condition (player exists and is vulnerable)
     player_query: Query<(Entity, &Transform), (With<Player>, Without<Invincible>)>,
-    enemy_bullet_query: Query<(Entity, &Transform), With<EnemyBullet>>,
+    bullet_query: Query<(Entity, &Transform), With<EnemyBullet>>,
 ) {
-    if let Ok((player_entity, player_transform)) = player_query.single() {
-        for (bullet_entity, bullet_transform) in enemy_bullet_query.iter() {
-            let distance = player_transform
-                .translation
-                .distance(bullet_transform.translation);
+    let Ok((player_entity, player_transform)) = player_query.single() else {
+        return;
+    };
+    let player_pos = player_transform.translation;
 
-            if distance < ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD {
-                println!("Player hit by enemy bullet!");
-                spawn_explosion(&mut commands, player_transform.translation);
-                commands.entity(bullet_entity).despawn(); // Despawn bullet
+    let Some((bullet_entity, _)) = bullet_query.iter().find(|(_, t)| {
+        player_pos.distance(t.translation) < ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD
+    }) else {
+        return;
+    };
 
-                lives.count = lives.count.saturating_sub(1);
-                println!("Lives remaining: {}", lives.count);
-
-                commands.entity(player_entity).despawn(); // Despawn player
-
-                if lives.count > 0 {
-                    respawn_timer.timer.reset();
-                    respawn_timer.timer.unpause();
-                    println!("Respawn timer started.");
-                } else {
-                    println!("GAME OVER!");
-                    next_state.set(AppState::GameOver);
-                }
-                // Break because the player can only be hit once per frame
-                break;
-            }
-        }
-    }
-}
\ No newline at end of file
+    commands.entity(bullet_entity).despawn();
+    kill_player(
+        &mut commands,
+        &mut lives,
+        &mut respawn_timer,
+        &mut next_state,
+        player_entity,
+        player_pos,
+    );
+}
diff --git a/src/components.rs b/src/components.rs
index 700f260..c7fb877 100644
--- a/src/components.rs
+++ b/src/components.rs
@@ -1,6 +1,5 @@
 use bevy::prelude::*;
 
-// --- Components ---
 #[derive(Component)]
 pub struct Player {
     pub speed: f32,
@@ -10,15 +9,15 @@ pub struct Player {
 #[derive(Component)]
 pub struct Bullet;
 
-#[derive(Component, Clone, Copy, PartialEq, Eq, Debug)] // Added derive for common traits
+#[derive(Component, Clone, Copy, PartialEq, Eq, Debug)]
 pub enum EnemyType {
     Grunt,
-    Boss, // Added Boss type
+    Boss,
 }
 
 #[derive(Component)]
 pub struct Enemy {
-    pub enemy_type: EnemyType, // Add type field
+    pub enemy_type: EnemyType,
     pub shoot_cooldown: Timer,
 }
 
@@ -27,22 +26,19 @@ pub struct Invincible {
     pub timer: Timer,
 }
 
-// New component to mark a player as captured by a Boss enemy
-#[derive(Component, Clone)] // Added Clone derive
+/// Marks a player held by a Boss's tractor beam.
+#[derive(Component)]
 pub struct Captured {
-    // Reference to the capturing boss entity
     pub boss_entity: Entity,
-    // Timer for how long the player remains captured
     pub timer: Timer,
 }
 
-// New component for the tractor beam visual effect
 #[derive(Component)]
 pub struct TractorBeam {
-    pub target: Option<Entity>, // The entity being targeted (usually player)
-    pub timer: Timer,           // How long the beam lasts
-    pub width: f32,             // Visual width of the beam
-    pub active: bool,           // Whether the beam is currently active
+    pub target: Option<Entity>,
+    pub timer: Timer,
+    pub width: f32,
+    pub active: bool,
 }
 
 #[derive(Component)]
@@ -53,38 +49,34 @@ pub struct FormationTarget {
     pub position: Vec3,
 }
 
-// Component to store the original formation position for enemies that need to return
+/// Stored on enemies once they reach formation, so attackers can return to it.
 #[derive(Component)]
 pub struct OriginalFormationPosition {
     pub position: Vec3,
 }
 
-// Enum defining different ways an enemy can attack
 #[derive(Component, Clone, Copy, PartialEq, Debug)]
 pub enum AttackPattern {
-    SwoopDive,      // Original pattern: dive towards center, then off screen
-    DirectDive,     // Dive straight down
-    Kamikaze(Vec3), // Dive towards a specific target location (e.g., player's last known position) - Needs target Vec3
-    CaptureBeam, // New pattern: Boss dives and attempts to capture the player with a tractor beam
-                 // Add more patterns later (e.g., FigureEight, Looping)
+    SwoopDive,
+    DirectDive,
+    Kamikaze(Vec3),
+    CaptureBeam,
 }
 
-#[derive(Component, Clone, PartialEq, Debug)] // Added Debug derive
+#[derive(Component, Clone, PartialEq, Debug)]
 pub enum EnemyState {
-    Entering,                 // Flying onto the screen towards formation target
-    InFormation,              // Holding position in the formation
-    Attacking(AttackPattern), // Diving towards the player using a specific pattern
-    ReturningWithCaptive,     // Boss returning to formation with captured player
+    Entering,
+    InFormation,
+    Attacking(AttackPattern),
+    ReturningWithCaptive,
 }
 
 #[derive(Component)]
 pub struct EnemyBullet;
 
-// Game Over UI Component (might move to ui.rs later if more UI exists)
 #[derive(Component)]
 pub struct GameOverUI;
 
-// Start Menu UI Components
 #[derive(Component)]
 pub struct StartMenuUI;
 
diff --git a/src/constants.rs b/src/constants.rs
index fdea676..61828df 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -1,60 +1,61 @@
 use bevy::math::Vec2;
 use bevy::prelude::*;
 
-// --- Constants ---
+// Window
 pub const WINDOW_WIDTH: f32 = 600.0;
 pub const WINDOW_HEIGHT: f32 = 800.0;
+
+// Player
 pub const PLAYER_SPEED: f32 = 300.0;
-pub const BULLET_SPEED: f32 = 500.0;
-pub const ENEMY_SPEED: f32 = 100.0;
 pub const PLAYER_SIZE: Vec2 = Vec2::new(30.0, 30.0);
+pub const STARTING_LIVES: u32 = 3;
+pub const PLAYER_RESPAWN_DELAY: f32 = 2.0;
+pub const PLAYER_INVINCIBILITY_DURATION: f32 = 2.0;
+
+// Enemies
+pub const ENEMY_SPEED: f32 = 100.0;
 pub const ENEMY_SIZE: Vec2 = Vec2::new(40.0, 40.0);
-pub const BULLET_SIZE: Vec2 = Vec2::new(5.0, 15.0);
-// Player bullet
-pub const ENEMY_BULLET_SIZE: Vec2 = Vec2::new(8.0, 8.0);
-// Enemy bullet
-pub const ENEMY_BULLET_SPEED: f32 = 300.0;
 pub const ENEMY_SHOOT_INTERVAL: f32 = 1.5;
-// Formation constants
+
+// Bullets
+pub const BULLET_SPEED: f32 = 500.0;
+pub const BULLET_SIZE: Vec2 = Vec2::new(5.0, 15.0);
+pub const ENEMY_BULLET_SIZE: Vec2 = Vec2::new(8.0, 8.0);
+pub const ENEMY_BULLET_SPEED: f32 = 300.0;
+
+// Formation
 const FORMATION_ROWS: usize = 4;
 pub const FORMATION_COLS: usize = 8;
 pub const FORMATION_ENEMY_COUNT: usize = FORMATION_ROWS * FORMATION_COLS;
 pub const FORMATION_X_SPACING: f32 = 60.0;
 pub const FORMATION_Y_SPACING: f32 = 50.0;
 pub const FORMATION_BASE_Y: f32 = WINDOW_HEIGHT / 2.0 - 150.0;
-// Top area for formation
-pub const STARTING_LIVES: u32 = 3;
-pub const PLAYER_RESPAWN_DELAY: f32 = 2.0;
-pub const PLAYER_INVINCIBILITY_DURATION: f32 = 2.0;
-// Collision thresholds
+
+// Collision thresholds (mean of half-widths)
 pub const BULLET_ENEMY_COLLISION_THRESHOLD: f32 = (BULLET_SIZE.x + ENEMY_SIZE.x) * 0.5;
-// 22.5
 pub const PLAYER_ENEMY_COLLISION_THRESHOLD: f32 = (PLAYER_SIZE.x + ENEMY_SIZE.x) * 0.5;
-// 35.0
 pub const ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD: f32 =
     (ENEMY_BULLET_SIZE.x + PLAYER_SIZE.x) * 0.5;
 
-// Tractor beam constants
+// Tractor beam
 pub const TRACTOR_BEAM_WIDTH: f32 = 20.0;
 pub const TRACTOR_BEAM_DURATION: f32 = 3.0;
-pub const TRACTOR_BEAM_COLOR: Color = Color::srgba(0.5, 0.0, 0.8, 0.6);
-pub const CAPTURE_DURATION: f32 = 10.0; // How long the player stays captured
-// Tractor beam visual constants
+pub const CAPTURE_DURATION: f32 = 10.0;
 pub const BEAM_GLOW_WIDTH: f32 = 40.0;
 pub const BEAM_GLOW_COLOR: Color = Color::srgba(0.3, 0.0, 0.5, 0.25);
 pub const BEAM_CORE_COLOR: Color = Color::srgba(0.7, 0.2, 1.0, 0.7);
 pub const BEAM_PULSE_FREQ: f32 = 3.0;
 pub const BEAM_PULSE_AMPLITUDE: f32 = 0.15;
 
-// Starfield constants
+// Starfield
 pub const STAR_COUNT: usize = 150;
 pub const STAR_MIN_SIZE: f32 = 1.0;
 pub const STAR_MAX_SIZE: f32 = 3.0;
 pub const STAR_MIN_SPEED: f32 = 20.0;
 pub const STAR_MAX_SPEED: f32 = 100.0;
-pub const STAR_Z_DEPTH: f32 = -10.0; // Behind all game entities
+pub const STAR_Z_DEPTH: f32 = -10.0;
 
-// Explosion constants
+// Explosion
 pub const EXPLOSION_DURATION: f32 = 0.4;
 pub const EXPLOSION_BASE_SIZE: Vec2 = Vec2::new(15.0, 15.0);
 pub const EXPLOSION_MAX_SIZE: Vec2 = Vec2::new(50.0, 50.0);
diff --git a/src/enemy.rs b/src/enemy.rs
index d9d5a68..2d7bee2 100644
--- a/src/enemy.rs
+++ b/src/enemy.rs
@@ -2,123 +2,111 @@ use bevy::prelude::*;
 use std::time::Duration;
 
 use crate::components::{
-    Captured, Enemy, EnemyBullet, EnemyState, EnemyType, FormationTarget,
-    OriginalFormationPosition, TractorBeam, TractorBeamSprite,
+    AttackPattern, Captured, Enemy, EnemyBullet, EnemyState, EnemyType, FormationTarget,
+    OriginalFormationPosition, Player, TractorBeam, TractorBeamSprite,
 };
 use crate::constants::{
-    BEAM_CORE_COLOR,
-    BEAM_GLOW_COLOR,
-    BEAM_GLOW_WIDTH,
-    BEAM_PULSE_AMPLITUDE,
-    BEAM_PULSE_FREQ,
-    CAPTURE_DURATION,
-    // Only keeping used constants
-    ENEMY_BULLET_SIZE,
-    ENEMY_SIZE,
-    ENEMY_SPEED,
-    TRACTOR_BEAM_DURATION,
-    TRACTOR_BEAM_WIDTH,
-    WINDOW_HEIGHT,
-    WINDOW_WIDTH,
+    BEAM_CORE_COLOR, BEAM_GLOW_COLOR, BEAM_GLOW_WIDTH, BEAM_PULSE_AMPLITUDE, BEAM_PULSE_FREQ,
+    CAPTURE_DURATION, ENEMY_BULLET_SIZE, ENEMY_SIZE, ENEMY_SPEED, TRACTOR_BEAM_DURATION,
+    TRACTOR_BEAM_WIDTH, WINDOW_HEIGHT, WINDOW_WIDTH,
 };
 use crate::resources::{
     AttackDiveTimer, CurrentStage, EnemySpawnTimer, FormationState, StageConfigurations,
 };
 
+const BOSS_BASE_CHANCE: f32 = 0.30;
+const BOSS_CHANCE_PER_STAGE: f32 = 0.05;
+const BOSS_CHANCE_BONUS_CAP: f32 = 0.50;
+const BOSS_CAPTURE_BEAM_PROBABILITY: f32 = 0.80;
+const ATTACKER_SPEED_MULTIPLIER: f32 = 1.5;
+const RETURN_SPEED_MULTIPLIER: f32 = 0.7;
+const SWOOP_HORIZONTAL_FACTOR: f32 = 0.5;
+const KAMIKAZE_NEAR_DISTANCE: f32 = 50.0;
+const RETURN_ARRIVAL_DISTANCE: f32 = 5.0;
+const ARRIVAL_THRESHOLD_FACTOR: f32 = 1.1;
+const BOSS_CAPTURE_BEAM_HOVER_Y_FACTOR: f32 = 0.25; // -WINDOW_HEIGHT * this
+const BOSS_DESCENT_SPEED_FACTOR: f32 = 0.8;
+
 pub fn spawn_enemies(
     mut commands: Commands,
     time: Res<Time>,
     mut timer: ResMut<EnemySpawnTimer>,
     mut stage: ResMut<CurrentStage>,
     mut formation_state: ResMut<FormationState>,
-    stage_configs: Res<StageConfigurations>, // Use imported name
+    stage_configs: Res<StageConfigurations>,
 ) {
-    // Get current stage config, looping if stage number exceeds defined configs
-    let config_index = (stage.number as usize - 1) % stage_configs.stages.len();
-    let current_config = &stage_configs.stages[config_index];
-    let stage_enemy_count = current_config.enemy_count;
-
-    // Tick the timer every frame
+    let config = stage_configs.for_stage(stage.number);
     timer.timer.tick(time.delta());
 
-    // Only spawn if we haven't spawned the full formation for this stage yet
-    // AND the timer just finished this frame
-    if formation_state.total_spawned_this_stage < stage_enemy_count && timer.timer.just_finished() {
-        let slot_index = formation_state.next_slot_index;
+    if formation_state.total_spawned_this_stage >= config.enemy_count
+        || !timer.timer.just_finished()
+    {
+        return;
+    }
 
-        // Ensure slot_index is within bounds of the formation layout
-        if slot_index >= current_config.formation_layout.positions.len() {
-            println!(
-                "Warning: slot_index {} out of bounds for formation layout '{}' (size {})",
-                slot_index,
-                current_config.formation_layout.name,
-                current_config.formation_layout.positions.len()
-            );
-            // Optionally, reset the timer and skip spawning this frame, or handle differently
-            timer.timer.reset();
-            return;
-        }
+    let slot = formation_state.next_slot_index;
+    if slot >= config.formation_layout.positions.len() {
+        warn!(
+            "slot_index {} out of bounds for formation '{}' (size {})",
+            slot,
+            config.formation_layout.name,
+            config.formation_layout.positions.len()
+        );
+        timer.timer.reset();
+        return;
+    }
 
-        // Get target position from the stage's formation layout
-        let target_pos = current_config.formation_layout.positions[slot_index];
+    let target_pos = config.formation_layout.positions[slot];
+    let spawn_pos = Vec3::new(
+        (fastrand::f32() - 0.5) * (WINDOW_WIDTH - ENEMY_SIZE.x),
+        WINDOW_HEIGHT / 2.0 + ENEMY_SIZE.y / 2.0,
+        0.0,
+    );
 
-        // Spawn position (random at the top) - Corrected to use WINDOW_WIDTH
-        let spawn_x = (fastrand::f32() - 0.5) * (WINDOW_WIDTH - ENEMY_SIZE.x);
-        let spawn_y = WINDOW_HEIGHT / 2.0 + ENEMY_SIZE.y / 2.0; // Spawn slightly above screen
+    let boss_chance = BOSS_BASE_CHANCE
+        + (stage.number as f32 * BOSS_CHANCE_PER_STAGE).min(BOSS_CHANCE_BONUS_CAP);
+    let enemy_type = if fastrand::f32() < boss_chance {
+        EnemyType::Boss
+    } else {
+        EnemyType::Grunt
+    };
 
-        // Determine enemy type - now with a chance to spawn Boss enemies
-        // Higher stages have a slightly higher boss chance
-        let boss_chance = 0.30 + (stage.number as f32 * 0.05).min(0.50); // Increased for testing
-        let enemy_type = if fastrand::f32() < boss_chance {
-            println!("Spawning a Boss enemy!");
-            EnemyType::Boss
-        } else {
-            EnemyType::Grunt
-        };
+    let color = match enemy_type {
+        EnemyType::Grunt => Color::srgb(1.0, 0.2, 0.2),
+        EnemyType::Boss => Color::srgb(0.8, 0.2, 1.0),
+    };
 
-        // Determine sprite color based on type
-        let sprite_color = match enemy_type {
-            EnemyType::Grunt => Color::srgb(1.0, 0.2, 0.2),
-            EnemyType::Boss => Color::srgb(0.8, 0.2, 1.0),
-        };
+    commands.spawn((
+        Sprite {
+            color,
+            custom_size: Some(ENEMY_SIZE),
+            ..default()
+        },
+        Transform::from_translation(spawn_pos),
+        Enemy {
+            enemy_type,
+            shoot_cooldown: Timer::new(
+                Duration::from_secs_f32(config.enemy_shoot_interval),
+                TimerMode::Once,
+            ),
+        },
+        FormationTarget {
+            position: target_pos,
+        },
+        EnemyState::Entering,
+    ));
 
-        commands.spawn((
-            Sprite {
-                color: sprite_color,
-                custom_size: Some(ENEMY_SIZE),
-                ..default()
-            },
-            Transform::from_translation(Vec3::new(spawn_x, spawn_y, 0.0)),
-            Enemy {
-                enemy_type,
-                // Use shoot interval from stage config
-                shoot_cooldown: Timer::new(
-                    Duration::from_secs_f32(current_config.enemy_shoot_interval),
-                    TimerMode::Once,
-                ),
-            },
-            FormationTarget {
-                position: target_pos,
-            },
-            EnemyState::Entering,
-        ));
+    formation_state.next_slot_index = (slot + 1) % config.enemy_count;
+    formation_state.total_spawned_this_stage += 1;
+    stage.waiting_for_clear = true;
 
-        // Use stage_enemy_count for cycling index
-        formation_state.next_slot_index = (slot_index + 1) % stage_enemy_count;
-        formation_state.total_spawned_this_stage += 1;
-
-        // Mark that we are now waiting for enemies to be cleared
-        stage.waiting_for_clear = true;
-
-        // Reset timer only if we are still spawning more enemies for the formation
-        if formation_state.total_spawned_this_stage < stage_enemy_count {
-            timer.timer.reset();
-        } else {
-            println!(
-                "Full formation ({}) spawned for Stage {}",
-                current_config.formation_layout.name, stage.number
-            );
-        }
+    if formation_state.total_spawned_this_stage < config.enemy_count {
+        timer.timer.reset();
+    } else {
+        info!(
+            "Stage {} formation '{}' fully spawned",
+            stage.number, config.formation_layout.name
+        );
     }
 }
 
@@ -134,471 +122,288 @@ pub fn move_enemies(
             &mut EnemyState,
             &Enemy,
             Option<&OriginalFormationPosition>,
-        ), // Add mutable state and original position
+        ),
         (With<Enemy>, Without<FormationTarget>),
-    >, // Query potential attackers
+    >,
     time: Res<Time>,
     mut commands: Commands,
     stage: Res<CurrentStage>,
-    stage_configs: Res<StageConfigurations>, // Add stage configurations
+    stage_configs: Res<StageConfigurations>,
     has_beam_query: Query<&TractorBeam>,
 ) {
-    // Get current stage config for speed multiplier
-    let config_index = (stage.number as usize - 1) % stage_configs.stages.len();
-    let current_config = &stage_configs.stages[config_index];
-    let speed_multiplier = current_config.enemy_speed_multiplier;
-
-    // Calculate speeds for this frame
+    let dt = time.delta_secs();
+    let speed_multiplier = stage_configs.for_stage(stage.number).enemy_speed_multiplier;
     let base_speed = ENEMY_SPEED * speed_multiplier;
-    let attack_speed = base_speed * 1.5; // Attackers are faster
-    let arrival_threshold = base_speed * time.delta_secs() * 1.1; // Threshold for reaching formation target
+    let attack_speed = base_speed * ATTACKER_SPEED_MULTIPLIER;
+    let arrival_threshold = base_speed * dt * ARRIVAL_THRESHOLD_FACTOR;
 
-    // --- Handle Entering Enemies ---
     for (entity, mut transform, target, mut state) in entering_query.iter_mut() {
-        // Ensure we only process Entering state here, though query filters it mostly
-        if *state == EnemyState::Entering {
-            let current_pos = transform.translation;
-            let target_pos = target.position;
-            // Using target_pos which is already a Vec3, not a reference
-            let direction = target_pos - current_pos;
-            let distance = direction.length();
-
-            if distance < arrival_threshold {
-                // Arrived at target
-                transform.translation = target_pos;
-                commands.entity(entity).remove::<FormationTarget>(); // Remove target component
-                *state = EnemyState::InFormation; // Change state
-
-                // Store the original formation position for potential return
-                commands.entity(entity).insert(OriginalFormationPosition {
-                    position: target_pos,
-                });
-
-                println!(
-                    "Enemy {:?} reached formation target and is now InFormation.",
-                    entity
-                );
-            } else {
-                // Move towards target using base_speed
-                let move_delta = direction.normalize() * base_speed * time.delta_secs();
-                transform.translation += move_delta;
-            }
+        if *state != EnemyState::Entering {
+            continue;
+        }
+        let direction = target.position - transform.translation;
+        if direction.length() < arrival_threshold {
+            transform.translation = target.position;
+            commands.entity(entity).remove::<FormationTarget>();
+            commands.entity(entity).insert(OriginalFormationPosition {
+                position: target.position,
+            });
+            *state = EnemyState::InFormation;
+        } else {
+            transform.translation += direction.normalize() * base_speed * dt;
         }
     }
 
-    // --- Handle Attacking and Returning Enemies ---
     for (entity, mut transform, mut state, enemy, original_pos) in attacking_query.iter_mut() {
-        // Check what state the enemy is in
         match state.as_ref() {
-            EnemyState::Attacking(attack_pattern) => {
-                // Apply different movement based on enemy type
-                match enemy.enemy_type {
-                    EnemyType::Grunt => {
-                        // Basic enemies follow their attack pattern
-                        match attack_pattern {
-                            // ... existing patterns ...
-                            AttackPattern::SwoopDive => {
-                                // ... existing code ...
-                                let vertical_movement = attack_speed * time.delta_secs();
-                                let horizontal_speed_factor = 0.5;
-                                let horizontal_movement = if transform.translation.x < 0.0 {
-                                    attack_speed * horizontal_speed_factor * time.delta_secs()
-                                } else if transform.translation.x > 0.0 {
-                                    -attack_speed * horizontal_speed_factor * time.delta_secs()
-                                } else {
-                                    0.0
-                                };
-
-                                transform.translation.y -= vertical_movement;
-                                transform.translation.x += horizontal_movement;
-
-                                // Prevent overshooting center
-                                if (transform.translation.x > 0.0
-                                    && transform.translation.x + horizontal_movement < 0.0)
-                                    || (transform.translation.x < 0.0
-                                        && transform.translation.x + horizontal_movement > 0.0)
-                                {
-                                    transform.translation.x = 0.0;
-                                }
-                            }
-                            AttackPattern::DirectDive => {
-                                transform.translation.y -= attack_speed * time.delta_secs();
-                            }
-                            AttackPattern::Kamikaze(target) => {
-                                // Copy the target value rather than dereferencing
-                                // since target should actually be a Vec3 in this context
-                                let target_pos = *target; // Dereference here
-                                let direction = target_pos - transform.translation;
-                                let distance = direction.length();
-                                let kamikaze_threshold = attack_speed * time.delta_secs() * 1.1; // Threshold to stop near target
-
-                                if distance > kamikaze_threshold {
-                                    let move_delta =
-                                        direction.normalize() * attack_speed * time.delta_secs();
-                                    transform.translation += move_delta;
-                                } else {
-                                    // Optionally stop or continue past target - for now, just stop moving towards it
-                                    // Could also despawn here if desired upon reaching target
-                                }
-                            }
-                            // New CaptureBeam pattern - Bosses behave differently
-                            AttackPattern::CaptureBeam => {
-                                // For Grunt enemies, just do a direct dive (fallback)
-                                transform.translation.y -= attack_speed * time.delta_secs();
-                            }
-                        }
-                    }
-                    EnemyType::Boss => {
-                        // Boss has special behavior, especially for CaptureBeam
-                        match attack_pattern {
-                            AttackPattern::CaptureBeam => {
-                                // Boss moves down to a position above the player area
-                                let target_y = -WINDOW_HEIGHT / 4.0; // Position at lower quarter of the screen
-
-                                if transform.translation.y > target_y {
-                                    // Move down to position
-                                    transform.translation.y -=
-                                        attack_speed * 0.8 * time.delta_secs();
-                                } else {
-                                    // Once in position, stay there briefly before activating beam
-                                    // Check if this boss already has a TractorBeam component
-                                    if has_beam_query.get(entity).is_err() {
-                                        // Spawn tractor beam component on this boss
-                                        commands.entity(entity).insert(TractorBeam {
-                                            target: None, // Will be filled in by the boss_capture_attack
-                                            timer: Timer::new(
-                                                Duration::from_secs_f32(TRACTOR_BEAM_DURATION),
-                                                TimerMode::Once,
-                                            ),
-                                            width: TRACTOR_BEAM_WIDTH,
-                                            active: false,
-                                        });
-                                    }
-                                }
-                            }
-                            AttackPattern::SwoopDive => {
-                                // ... existing code for swoop dive ...
-                                let center_x = 0.0;
-                                let bottom_y = -WINDOW_HEIGHT / 2.0 - ENEMY_SIZE.y;
-
-                                // First move towards center-bottom
-                                let target = Vec3::new(center_x, bottom_y, 0.0);
-                                // target is directly created as Vec3, not a reference
-                                let direction = target - transform.translation;
-
-                                // Normalize and move
-                                if direction.length() > 0.0 {
-                                    let normalized_dir = direction.normalize();
-                                    transform.translation +=
-                                        normalized_dir * attack_speed * time.delta_secs();
-                                }
-                            }
-                            AttackPattern::DirectDive => {
-                                transform.translation.y -= attack_speed * time.delta_secs();
-                            }
-                            AttackPattern::Kamikaze(target) => {
-                                // Convert the target to a value type
-                                let target_pos = *target; // Dereference here
-                                let direction = target_pos - transform.translation;
-
-                                // If very close to target, just move straight down
-                                if direction.length() < 50.0 {
-                                    transform.translation.y -= attack_speed * time.delta_secs();
-                                } else {
-                                    // Move toward target
-                                    let normalized_dir = direction.normalize();
-                                    transform.translation +=
-                                        normalized_dir * attack_speed * time.delta_secs();
-                                }
-                            }
-                        }
-                    }
-                }
+            EnemyState::Attacking(pattern) => {
+                step_attacker(
+                    &mut commands,
+                    entity,
+                    &mut transform,
+                    enemy.enemy_type,
+                    *pattern,
+                    attack_speed,
+                    dt,
+                    &has_beam_query,
+                );
             }
             EnemyState::ReturningWithCaptive => {
-                // Boss returning to formation with captured player
-                if let Some(original_pos) = original_pos {
-                    let direction = original_pos.position - transform.translation;
-                    let distance = direction.length();
-                    let return_speed = ENEMY_SPEED * speed_multiplier * 0.7; // Slightly slower when carrying captive
-
-                    if distance < 5.0 {
-                        // Close enough to formation position
-                        // Return to formation
-                        transform.translation = original_pos.position;
+                if let Some(home) = original_pos {
+                    let direction = home.position - transform.translation;
+                    let return_speed = base_speed * RETURN_SPEED_MULTIPLIER;
+                    if direction.length() < RETURN_ARRIVAL_DISTANCE {
+                        transform.translation = home.position;
                         *state = EnemyState::InFormation;
-                        println!("Boss {:?} returned to formation with captive!", entity);
                     } else {
-                        // Move towards formation position
-                        let move_delta =
-                            direction.normalize() * return_speed * time.delta_secs();
-                        transform.translation += move_delta;
+                        transform.translation += direction.normalize() * return_speed * dt;
                     }
                 }
             }
-            _ => {} // Handle other states if needed
+            _ => {}
         }
 
-        // Despawn if off screen (This should be inside the loop)
         if transform.translation.y < -WINDOW_HEIGHT / 2.0 - ENEMY_SIZE.y {
-            println!(
-                "Despawning enemy {:?} that went off screen.", // Generic message as it could be InFormation or Attacking
-                entity
-            );
             commands.entity(entity).despawn();
-            // TODO: Later, attacking enemies might return to formation or loop
         }
-    } // Closes for loop
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn step_attacker(
+    commands: &mut Commands,
+    entity: Entity,
+    transform: &mut Transform,
+    enemy_type: EnemyType,
+    pattern: AttackPattern,
+    attack_speed: f32,
+    dt: f32,
+    has_beam_query: &Query<&TractorBeam>,
+) {
+    match (enemy_type, pattern) {
+        (EnemyType::Boss, AttackPattern::CaptureBeam) => {
+            let hover_y = -WINDOW_HEIGHT * BOSS_CAPTURE_BEAM_HOVER_Y_FACTOR;
+            if transform.translation.y > hover_y {
+                transform.translation.y -= attack_speed * BOSS_DESCENT_SPEED_FACTOR * dt;
+            } else if has_beam_query.get(entity).is_err() {
+                commands.entity(entity).insert(TractorBeam {
+                    target: None,
+                    timer: Timer::new(
+                        Duration::from_secs_f32(TRACTOR_BEAM_DURATION),
+                        TimerMode::Once,
+                    ),
+                    width: TRACTOR_BEAM_WIDTH,
+                    active: false,
+                });
+            }
+        }
+        (EnemyType::Boss, AttackPattern::SwoopDive) => {
+            let target = Vec3::new(0.0, -WINDOW_HEIGHT / 2.0 - ENEMY_SIZE.y, 0.0);
+            let direction = target - transform.translation;
+            if direction.length() > 0.0 {
+                transform.translation += direction.normalize() * attack_speed * dt;
+            }
+        }
+        (_, AttackPattern::DirectDive) | (EnemyType::Grunt, AttackPattern::CaptureBeam) => {
+            transform.translation.y -= attack_speed * dt;
+        }
+        (EnemyType::Grunt, AttackPattern::SwoopDive) => {
+            transform.translation.y -= attack_speed * dt;
+            let prev_x = transform.translation.x;
+            let dx = -prev_x.signum() * attack_speed * SWOOP_HORIZONTAL_FACTOR * dt;
+            transform.translation.x += dx;
+            // Snap to center if we crossed it (prevents wobble)
+            if prev_x != 0.0 && prev_x.signum() != transform.translation.x.signum() {
+                transform.translation.x = 0.0;
+            }
+        }
+        (_, AttackPattern::Kamikaze(target)) => {
+            let direction = target - transform.translation;
+            let dist = direction.length();
+            if enemy_type == EnemyType::Boss && dist < KAMIKAZE_NEAR_DISTANCE {
+                transform.translation.y -= attack_speed * dt;
+            } else if dist > attack_speed * dt * ARRIVAL_THRESHOLD_FACTOR {
+                transform.translation += direction.normalize() * attack_speed * dt;
+            }
+        }
+    }
 }
 
-// System to check if all spawned enemies have reached their formation position
 pub fn check_formation_complete(
     mut formation_state: ResMut<FormationState>,
     enemy_query: Query<&EnemyState, With<Enemy>>,
     mut attack_dive_timer: ResMut<AttackDiveTimer>,
-    stage: Res<CurrentStage>,                // Need current stage
-    stage_configs: Res<StageConfigurations>, // Need stage configs
+    stage: Res<CurrentStage>,
+    stage_configs: Res<StageConfigurations>,
 ) {
-    // Only run the check if the formation isn't already marked as complete
-    if !formation_state.formation_complete {
-        // Get current stage config
-        let config_index = (stage.number as usize - 1) % stage_configs.stages.len();
-        let current_config = &stage_configs.stages[config_index];
-        let stage_enemy_count = current_config.enemy_count;
-
-        // Check if all enemies for *this stage* have been spawned
-        if formation_state.total_spawned_this_stage == stage_enemy_count {
-            // Check if any enemies are still in the Entering state
-            let mut any_entering = false;
-            for state in enemy_query.iter() {
-                // Use matches! macro for safety
-                if matches!(state, EnemyState::Entering) {
-                    any_entering = true;
-                    break;
-                }
-            }
-
-            // If all spawned and none are entering, formation is complete
-            if !any_entering {
-                println!(
-                    "Formation complete for Stage {}! Setting attack timer. (Spawned={})",
-                    stage.number, formation_state.total_spawned_this_stage
-                );
-                formation_state.formation_complete = true;
-
-                // Set timer duration based on stage config
-                let dive_interval = Duration::from_secs_f32(current_config.attack_dive_interval);
-                attack_dive_timer.timer.set_duration(dive_interval);
-                attack_dive_timer.timer.reset();
-                attack_dive_timer.timer.unpause();
-                println!(
-                    "Attack timer set to {:?} duration, unpaused and reset.",
-                    dive_interval
-                );
-            }
-        }
+    if formation_state.formation_complete {
+        return;
+    }
+    let config = stage_configs.for_stage(stage.number);
+    if formation_state.total_spawned_this_stage != config.enemy_count {
+        return;
+    }
+    let any_entering = enemy_query
+        .iter()
+        .any(|s| matches!(s, EnemyState::Entering));
+    if any_entering {
+        return;
     }
-}
 
-use crate::components::{AttackPattern, Player}; // Import the new enum and Player
+    info!("Stage {} formation complete", stage.number);
+    formation_state.formation_complete = true;
+    let dive_interval = Duration::from_secs_f32(config.attack_dive_interval);
+    attack_dive_timer.timer.set_duration(dive_interval);
+    attack_dive_timer.timer.reset();
+    attack_dive_timer.timer.unpause();
+}
 
 pub fn trigger_attack_dives(
     mut timer: ResMut<AttackDiveTimer>,
     time: Res<Time>,
-    mut enemy_query: Query<(Entity, &mut EnemyState, &Enemy)>, // Added Enemy component to check type
+    mut enemy_query: Query<(Entity, &mut EnemyState, &Enemy)>,
     formation_state: Res<FormationState>,
-    stage: Res<CurrentStage>,                      // Need current stage
-    stage_configs: Res<StageConfigurations>,       // Need stage configs
-    player_query: Query<&Transform, With<Player>>, // Need player position for Kamikaze
+    stage: Res<CurrentStage>,
+    stage_configs: Res<StageConfigurations>,
+    player_query: Query<&Transform, With<Player>>,
 ) {
     timer.timer.tick(time.delta());
+    if !timer.timer.just_finished() || !formation_state.formation_complete {
+        return;
+    }
 
-    // Only proceed if the timer finished AND the formation is complete
-    if timer.timer.just_finished() && formation_state.formation_complete {
-        // Get the current stage config
-        let config_index = (stage.number as usize - 1) % stage_configs.stages.len();
-        let current_config = &stage_configs.stages[config_index];
+    let config = stage_configs.for_stage(stage.number);
+    if config.attack_patterns.is_empty() {
+        return;
+    }
 
-        // Find all enemies currently in formation
-        let mut available_enemies: Vec<(Entity, EnemyType)> = Vec::new();
-        for (entity, state, enemy) in enemy_query.iter() {
-            // Check the state correctly and store enemy type
-            if matches!(state, EnemyState::InFormation) {
-                available_enemies.push((entity, enemy.enemy_type));
-            }
+    let candidates: Vec<(Entity, EnemyType)> = enemy_query
+        .iter()
+        .filter(|(_, state, _)| matches!(state, EnemyState::InFormation))
+        .map(|(e, _, enemy)| (e, enemy.enemy_type))
+        .collect();
+    if candidates.is_empty() {
+        return;
+    }
+
+    let (chosen, enemy_type) = candidates[fastrand::usize(..candidates.len())];
+    let pattern = pick_pattern(enemy_type, config.attack_patterns.as_slice(), &player_query);
+
+    if let Ok((_, mut state, _)) = enemy_query.get_mut(chosen) {
+        *state = EnemyState::Attacking(pattern);
+    }
+}
+
+fn pick_pattern(
+    enemy_type: EnemyType,
+    available: &[AttackPattern],
+    player_query: &Query<&Transform, With<Player>>,
+) -> AttackPattern {
+    let pattern = match enemy_type {
+        EnemyType::Boss if fastrand::f32() < BOSS_CAPTURE_BEAM_PROBABILITY => {
+            AttackPattern::CaptureBeam
         }
+        _ => available[fastrand::usize(..available.len())],
+    };
 
-        // If there are enemies available, pick one randomly
-        if !available_enemies.is_empty() && !current_config.attack_patterns.is_empty() {
-            let random_index = fastrand::usize(..available_enemies.len());
-            let (chosen_entity, enemy_type) = available_enemies[random_index];
-
-            // Select an attack pattern based on enemy type
-            let mut selected_pattern = match enemy_type {
-                // For Boss enemies, occasionally use the CaptureBeam pattern
-                EnemyType::Boss => {
-                    if fastrand::f32() < 0.8 {
-                        // 80% chance for Boss to use CaptureBeam (increased for testing)
-                        println!("Boss {:?} selected CaptureBeam attack!", chosen_entity);
-                        AttackPattern::CaptureBeam
-                    } else {
-                        // Otherwise use a random pattern from the stage config
-                        let pattern_index = fastrand::usize(..current_config.attack_patterns.len());
-                        println!(
-                            "Boss {:?} selected {:?} attack!",
-                            chosen_entity, current_config.attack_patterns[pattern_index]
-                        );
-                        current_config.attack_patterns[pattern_index]
-                    }
-                }
-                // Regular enemies use patterns from the stage config
-                EnemyType::Grunt => {
-                    let pattern_index = fastrand::usize(..current_config.attack_patterns.len());
-                    current_config.attack_patterns[pattern_index]
-                }
-            };
-
-            // If Kamikaze, get player position (if player exists)
-            if let AttackPattern::Kamikaze(_) = selected_pattern {
-                if let Ok(player_transform) = player_query.single() {
-                    selected_pattern = AttackPattern::Kamikaze(player_transform.translation);
-                } else {
-                    // Fallback if player doesn't exist (e.g., just died)
-                    selected_pattern = AttackPattern::DirectDive; // Or SwoopDive
-                    println!("Kamikaze target not found, falling back to DirectDive");
-                }
-            }
-
-            // Get the chosen enemy's state mutably and change it
-            if let Ok((_, mut state, _)) = enemy_query.get_mut(chosen_entity) {
-                println!(
-                    "Enemy {:?} starting attack dive with pattern {:?}!",
-                    chosen_entity, selected_pattern
-                );
-                *state = EnemyState::Attacking(selected_pattern); // Set state with pattern
-                                                                  // Timer duration is handled elsewhere (e.g., check_formation_complete)
-            }
+    // Resolve Kamikaze target (or fall back if player is gone).
+    if matches!(pattern, AttackPattern::Kamikaze(_)) {
+        match player_query.single() {
+            Ok(t) => AttackPattern::Kamikaze(t.translation),
+            Err(_) => AttackPattern::DirectDive,
         }
+    } else {
+        pattern
     }
 }
 
 pub fn enemy_shoot(
     mut commands: Commands,
     time: Res<Time>,
-    // Query attacking enemies: need their transform and mutable Enemy component for the timer
-    mut enemy_query: Query<(&Transform, &mut Enemy, &EnemyState), Without<FormationTarget>>, // Query remains the same
+    mut enemy_query: Query<(&Transform, &mut Enemy, &EnemyState), Without<FormationTarget>>,
 ) {
     for (transform, mut enemy, state) in enemy_query.iter_mut() {
-        // Only shoot if in any Attacking state (pattern doesn't matter for shooting)
-        if matches!(state, EnemyState::Attacking(_)) {
-            // Use matches! macro
-            enemy.shoot_cooldown.tick(time.delta());
-            if enemy.shoot_cooldown.is_finished() {
-                // println!("Enemy {:?} firing!", transform.translation); // Less verbose logging
-                let bullet_start_pos = transform.translation
-                    - Vec3::Y * (ENEMY_SIZE.y / 2.0 + ENEMY_BULLET_SIZE.y / 2.0);
-
-                commands.spawn((
-                    Sprite {
-                        color: Color::srgb(1.0, 0.5, 0.5),
-                        custom_size: Some(ENEMY_BULLET_SIZE),
-                        ..default()
-                    },
-                    Transform::from_translation(bullet_start_pos),
-                    EnemyBullet,
-                ));
-
-                // Reset the timer for the next shot
-                enemy.shoot_cooldown.reset();
-            }
+        if !matches!(state, EnemyState::Attacking(_)) {
+            continue;
         }
+        enemy.shoot_cooldown.tick(time.delta());
+        if !enemy.shoot_cooldown.is_finished() {
+            continue;
+        }
+
+        let bullet_pos =
+            transform.translation - Vec3::Y * (ENEMY_SIZE.y / 2.0 + ENEMY_BULLET_SIZE.y / 2.0);
+        commands.spawn((
+            Sprite {
+                color: Color::srgb(1.0, 0.5, 0.5),
+                custom_size: Some(ENEMY_BULLET_SIZE),
+                ..default()
+            },
+            Transform::from_translation(bullet_pos),
+            EnemyBullet,
+        ));
+        enemy.shoot_cooldown.reset();
     }
 }
 
-// Check collisions between enemy bullets and the player
-// Moved to player.rs as it affects player state directly
-
-// New run condition: Check if the formation is complete
 pub fn is_formation_complete(formation_state: Res<FormationState>) -> bool {
     formation_state.formation_complete
 }
 
-/// Calculate the beam height from the boss's Y position to the bottom of the screen.
+/// Beam spans from the boss down to the bottom of the screen.
 pub(crate) fn calculate_beam_height(boss_y: f32) -> f32 {
     (boss_y - (-WINDOW_HEIGHT / 2.0)).max(0.0)
 }
 
-/// Calculate the pulsing alpha value for a beam layer.
+/// Sinusoidal alpha pulse, clamped to [0, 1].
 pub(crate) fn beam_pulse_alpha(base_alpha: f32, time_secs: f32, freq: f32, amplitude: f32) -> f32 {
     (base_alpha + (time_secs * freq).sin() * amplitude).clamp(0.0, 1.0)
 }
 
-// New system to handle the tractor beam attack from Boss enemies
 pub fn boss_capture_attack(
     mut commands: Commands,
     time: Res<Time>,
     mut boss_query: Query<(Entity, &Transform, &mut TractorBeam)>,
-    player_query: Query<(Entity, &Transform), (With<Player>, Without<Captured>)>, // Only target non-captured players
+    player_query: Query<(Entity, &Transform), (With<Player>, Without<Captured>)>,
     enemy_query: Query<&EnemyState, With<Enemy>>,
     children_query: Query<&Children>,
 ) {
-    for (boss_entity, boss_transform, mut tractor_beam) in boss_query.iter_mut() {
-        // Tick the beam timer
-        tractor_beam.timer.tick(time.delta());
+    for (boss_entity, boss_transform, mut beam) in boss_query.iter_mut() {
+        beam.timer.tick(time.delta());
 
-        // If player exists and beam is not active yet, set player as target
-        if !tractor_beam.active && tractor_beam.target.is_none() {
+        if !beam.active && beam.target.is_none() {
             if let Ok((player_entity, _)) = player_query.single() {
-                tractor_beam.target = Some(player_entity);
-                tractor_beam.active = true;
-                println!(
-                    "Boss {:?} activated tractor beam targeting player!",
-                    boss_entity
-                );
-
-                let beam_height = calculate_beam_height(boss_transform.translation.y);
-
-                commands.entity(boss_entity).with_children(|parent| {
-                    // Outer glow layer (wide, dim)
-                    parent.spawn((
-                        Sprite {
-                            color: BEAM_GLOW_COLOR,
-                            custom_size: Some(Vec2::new(BEAM_GLOW_WIDTH, beam_height)),
-                            ..default()
-                        },
-                        Transform::from_xyz(0.0, -beam_height / 2.0, -0.5),
-                        TractorBeamSprite,
-                    ));
-                    // Inner core layer (narrow, bright, shorter)
-                    let core_height = beam_height * 0.6;
-                    parent.spawn((
-                        Sprite {
-                            color: BEAM_CORE_COLOR,
-                            custom_size: Some(Vec2::new(TRACTOR_BEAM_WIDTH, core_height)),
-                            ..default()
-                        },
-                        Transform::from_xyz(
-                            0.0,
-                            -core_height / 2.0 - beam_height * 0.2,
-                            -0.3,
-                        ),
-                        TractorBeamSprite,
-                    ));
-                });
+                beam.target = Some(player_entity);
+                beam.active = true;
+                spawn_beam_visual(&mut commands, boss_entity, boss_transform.translation.y);
             }
         }
 
-        // If beam is active, check if player is in beam's path
-        if tractor_beam.active {
+        if beam.active {
             if let Ok((player_entity, player_transform)) = player_query.single() {
-                // Check if player is roughly under the boss
-                if (player_transform.translation.x - boss_transform.translation.x).abs()
-                    < tractor_beam.width / 2.0
-                {
-                    // Player is in the beam! Capture them
-                    println!("Player captured by boss {:?}!", boss_entity);
-
-                    // Add Captured component to player
+                let dx = (player_transform.translation.x - boss_transform.translation.x).abs();
+                if dx < beam.width / 2.0 {
+                    info!("Player captured by boss {boss_entity:?}");
                     commands.entity(player_entity).insert(Captured {
                         boss_entity,
                         timer: Timer::new(
@@ -606,86 +411,98 @@ pub fn boss_capture_attack(
                             TimerMode::Once,
                         ),
                     });
-
-                    // Boss returns to formation with captured player
-                    commands.entity(boss_entity).remove::<TractorBeam>();
-
-                    // Change boss state to returning with captive
-                    if let Ok(EnemyState::Attacking(_)) = enemy_query.get(boss_entity) {
-                        commands
-                            .entity(boss_entity)
-                            .insert(EnemyState::ReturningWithCaptive);
-
-                        // Clean up the beam visual
-                        if let Ok(children) = children_query.get(boss_entity) {
-                            for child in children.iter() {
-                                commands.entity(child).despawn();
-                            }
-                        }
-                    }
-                    break;
+                    end_beam(&mut commands, boss_entity, &enemy_query, &children_query);
+                    continue;
                 }
             }
         }
 
-        // If beam timer finishes and player wasn't captured, end the beam attack
-        if tractor_beam.timer.is_finished() {
-            println!("Boss {:?} tractor beam expired", boss_entity);
-            commands.entity(boss_entity).remove::<TractorBeam>();
-
-            // Clean up the beam visual
-            if let Ok(children) = children_query.get(boss_entity) {
-                for child in children.iter() {
-                    commands.entity(child).despawn();
-                }
-            }
-
-            // Boss returns to formation after failed capture
-            if let Ok(EnemyState::Attacking(_)) = enemy_query.get(boss_entity) {
-                commands
-                    .entity(boss_entity)
-                    .insert(EnemyState::ReturningWithCaptive);
-            }
+        if beam.timer.is_finished() {
+            end_beam(&mut commands, boss_entity, &enemy_query, &children_query);
         }
     }
 }
 
-/// Update tractor beam visual: pulse opacity and update beam height.
+fn spawn_beam_visual(commands: &mut Commands, boss_entity: Entity, boss_y: f32) {
+    let beam_height = calculate_beam_height(boss_y);
+    let core_height = beam_height * 0.6;
+    commands.entity(boss_entity).with_children(|parent| {
+        parent.spawn((
+            Sprite {
+                color: BEAM_GLOW_COLOR,
+                custom_size: Some(Vec2::new(BEAM_GLOW_WIDTH, beam_height)),
+                ..default()
+            },
+            Transform::from_xyz(0.0, -beam_height / 2.0, -0.5),
+            TractorBeamSprite,
+        ));
+        parent.spawn((
+            Sprite {
+                color: BEAM_CORE_COLOR,
+                custom_size: Some(Vec2::new(TRACTOR_BEAM_WIDTH, core_height)),
+                ..default()
+            },
+            Transform::from_xyz(0.0, -core_height / 2.0 - beam_height * 0.2, -0.3),
+            TractorBeamSprite,
+        ));
+    });
+}
+
+/// Tear down the beam component and visuals; if the boss was attacking, send it home.
+fn end_beam(
+    commands: &mut Commands,
+    boss_entity: Entity,
+    enemy_query: &Query<&EnemyState, With<Enemy>>,
+    children_query: &Query<&Children>,
+) {
+    commands.entity(boss_entity).remove::<TractorBeam>();
+    if let Ok(children) = children_query.get(boss_entity) {
+        for child in children.iter() {
+            commands.entity(child).despawn();
+        }
+    }
+    if let Ok(EnemyState::Attacking(_)) = enemy_query.get(boss_entity) {
+        commands
+            .entity(boss_entity)
+            .insert(EnemyState::ReturningWithCaptive);
+    }
+}
+
 pub fn update_tractor_beam_visual(
     time: Res<Time>,
-    boss_query: Query<(Entity, &Transform, &TractorBeam), Without<TractorBeamSprite>>,
+    boss_query: Query<(Entity, &Transform), (With<TractorBeam>, Without<TractorBeamSprite>)>,
     mut sprite_query: Query<(&mut Sprite, &mut Transform), With<TractorBeamSprite>>,
-    children: Query<&Children>,
+    children_query: Query<&Children>,
 ) {
-    for (boss_entity, boss_transform, _tractor_beam) in boss_query.iter() {
-        let current_beam_height = calculate_beam_height(boss_transform.translation.y);
-        let time_secs = time.elapsed_secs();
+    let time_secs = time.elapsed_secs();
+    for (boss_entity, boss_transform) in boss_query.iter() {
+        let beam_height = calculate_beam_height(boss_transform.translation.y);
+        let Ok(children) = children_query.get(boss_entity) else {
+            continue;
+        };
 
-        if let Ok(child_entities) = children.get(boss_entity) {
-            for child in child_entities {
-                if let Ok((mut sprite, mut transform)) = sprite_query.get_mut(*child) {
-                    // Update color pulse
-                    let base_alpha = sprite.color.alpha();
-                    let new_alpha = beam_pulse_alpha(
-                        base_alpha,
-                        time_secs,
-                        BEAM_PULSE_FREQ,
-                        BEAM_PULSE_AMPLITUDE,
-                    );
-                    sprite.color.set_alpha(new_alpha);
+        for &child in children {
+            let Ok((mut sprite, mut transform)) = sprite_query.get_mut(child) else {
+                continue;
+            };
 
-                    // Update size and position
-                    let current_width = sprite.custom_size.map(|s| s.x).unwrap_or(0.0);
-                    if current_width == BEAM_GLOW_WIDTH {
-                        let new_height = current_beam_height;
-                        sprite.custom_size = Some(Vec2::new(current_width, new_height));
-                        transform.translation.y = -new_height / 2.0;
-                    } else if current_width == TRACTOR_BEAM_WIDTH {
-                        let core_height = current_beam_height * 0.6;
-                        sprite.custom_size = Some(Vec2::new(current_width, core_height));
-                        transform.translation.y = -core_height / 2.0 - current_beam_height * 0.2;
-                    }
-                }
+            let alpha = beam_pulse_alpha(
+                sprite.color.alpha(),
+                time_secs,
+                BEAM_PULSE_FREQ,
+                BEAM_PULSE_AMPLITUDE,
+            );
+            sprite.color.set_alpha(alpha);
+
+            // Distinguish glow vs. core by their fixed widths.
+            let width = sprite.custom_size.map(|s| s.x).unwrap_or(0.0);
+            if (width - BEAM_GLOW_WIDTH).abs() < f32::EPSILON {
+                sprite.custom_size = Some(Vec2::new(width, beam_height));
+                transform.translation.y = -beam_height / 2.0;
+            } else if (width - TRACTOR_BEAM_WIDTH).abs() < f32::EPSILON {
+                let core_height = beam_height * 0.6;
+                sprite.custom_size = Some(Vec2::new(width, core_height));
+                transform.translation.y = -core_height / 2.0 - beam_height * 0.2;
             }
         }
     }
@@ -717,7 +534,6 @@ mod beam_tests {
 
     #[test]
     fn pulse_at_peak() {
-        // sin(pi/2) = 1, so time = (pi/2) / freq
         let t = std::f32::consts::FRAC_PI_2 / 3.0;
         let result = beam_pulse_alpha(0.5, t, 3.0, 0.15);
         assert!((result - 0.65).abs() < 0.001);
@@ -725,7 +541,6 @@ mod beam_tests {
 
     #[test]
     fn pulse_at_trough() {
-        // sin(3pi/2) = -1, so time = (3pi/2) / freq = pi/2
         let t = std::f32::consts::FRAC_PI_2;
         let result = beam_pulse_alpha(0.5, t, 3.0, 0.15);
         assert!((result - 0.35).abs() < 0.001);
@@ -733,7 +548,6 @@ mod beam_tests {
 
     #[test]
     fn pulse_clamped_to_zero() {
-        // sin(3pi/2) = -1, so time = (3pi/2) / freq
         let t = 3.0 * std::f32::consts::FRAC_PI_2 / 3.0;
         let result = beam_pulse_alpha(0.05, t, 3.0, 1.0);
         assert_eq!(result, 0.0);
diff --git a/src/game_state.rs b/src/game_state.rs
index e74a7b0..35c6f11 100644
--- a/src/game_state.rs
+++ b/src/game_state.rs
@@ -1,8 +1,8 @@
-use crate::components::{Bullet, Enemy, GameOverUI, RestartMessage, StartButton, StartMenuUI};
-use crate::resources::RestartPressed;
 use bevy::prelude::*;
 
-// --- Game States ---
+use crate::components::{Bullet, Enemy, EnemyBullet, GameOverUI, RestartMessage, StartButton, StartMenuUI};
+use crate::resources::RestartPressed;
+
 #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
 pub enum AppState {
     #[default]
@@ -11,10 +11,12 @@ pub enum AppState {
     GameOver,
 }
 
+const BUTTON_IDLE: Color = Color::srgb(0.1, 0.1, 0.5);
+const BUTTON_HOVER: Color = Color::srgb(0.2, 0.2, 0.7);
+
 // --- Game Over UI ---
 
 pub fn setup_game_over_ui(mut commands: Commands) {
-    println!("Entering GameOver state. Setting up UI.");
     commands.spawn((
         Text::new("GAME OVER"),
         TextFont {
@@ -51,39 +53,20 @@ pub fn setup_game_over_ui(mut commands: Commands) {
 
 pub fn cleanup_game_over_ui(
     mut commands: Commands,
-    query: Query<Entity, With<GameOverUI>>,
-    restart_query: Query<Entity, With<RestartMessage>>,
+    query: Query<Entity, Or<(With<GameOverUI>, With<RestartMessage>)>>,
 ) {
-    println!("Exiting GameOver state. Cleaning up UI.");
-    for entity in query.iter() {
-        commands.entity(entity).despawn();
-    }
-    for entity in restart_query.iter() {
+    for entity in &query {
         commands.entity(entity).despawn();
     }
 }
 
-// --- Cleanup ---
+// --- Cleanup on leaving Playing ---
 
-// Cleanup system when exiting the Playing state
 pub fn cleanup_game_entities(
     mut commands: Commands,
-    bullet_query: Query<Entity, With<Bullet>>,
-    enemy_bullet_query: Query<Entity, With<crate::components::EnemyBullet>>,
-    enemy_query: Query<Entity, With<Enemy>>,
-    restart_message_query: Query<Entity, With<crate::components::RestartMessage>>,
+    query: Query<Entity, Or<(With<Bullet>, With<EnemyBullet>, With<Enemy>)>>,
 ) {
-    println!("Exiting Playing state. Cleaning up game entities.");
-    for entity in bullet_query.iter() {
-        commands.entity(entity).despawn();
-    }
-    for entity in enemy_bullet_query.iter() {
-        commands.entity(entity).despawn();
-    }
-    for entity in enemy_query.iter() {
-        commands.entity(entity).despawn();
-    }
-    for entity in restart_message_query.iter() {
+    for entity in &query {
         commands.entity(entity).despawn();
     }
 }
@@ -91,8 +74,6 @@ pub fn cleanup_game_entities(
 // --- Start Menu UI ---
 
 pub fn setup_start_menu_ui(mut commands: Commands) {
-    println!("Entering StartMenu state. Setting up UI.");
-
     commands
         .spawn((
             Node {
@@ -106,7 +87,6 @@ pub fn setup_start_menu_ui(mut commands: Commands) {
             StartMenuUI,
         ))
         .with_children(|parent| {
-            // Title
             parent.spawn((
                 Text::new("BGLGA"),
                 TextFont {
@@ -119,8 +99,6 @@ pub fn setup_start_menu_ui(mut commands: Commands) {
                     ..default()
                 },
             ));
-
-            // Start Game Button
             parent
                 .spawn((
                     Button,
@@ -133,7 +111,7 @@ pub fn setup_start_menu_ui(mut commands: Commands) {
                         ..default()
                     },
                     BorderColor::all(Color::WHITE),
-                    BackgroundColor(Color::srgb(0.1, 0.1, 0.5)),
+                    BackgroundColor(BUTTON_IDLE),
                     StartButton,
                 ))
                 .with_children(|parent| {
@@ -150,51 +128,42 @@ pub fn setup_start_menu_ui(mut commands: Commands) {
 }
 
 pub fn cleanup_start_menu_ui(mut commands: Commands, query: Query<Entity, With<StartMenuUI>>) {
-    println!("Exiting StartMenu state. Cleaning up UI.");
-    for entity in query.iter() {
+    for entity in &query {
         commands.entity(entity).despawn();
     }
 }
 
 pub fn start_menu_button_system(
-    mut interaction_query: Query<
+    mut interactions: Query<
         (&Interaction, &mut BackgroundColor),
         (Changed<Interaction>, With<StartButton>),
     >,
-    mut app_state: ResMut<NextState<AppState>>,
+    mut next_state: ResMut<NextState<AppState>>,
 ) {
-    for (interaction, mut color) in &mut interaction_query {
+    for (interaction, mut bg) in &mut interactions {
         match *interaction {
-            Interaction::Pressed => {
-                println!("Start button pressed! Transitioning to Playing state.");
-                app_state.set(AppState::Playing);
-            }
-            Interaction::Hovered => {
-                color.0 = Color::srgb(0.2, 0.2, 0.7);
-            }
-            Interaction::None => {
-                color.0 = Color::srgb(0.1, 0.1, 0.5);
-            }
+            Interaction::Pressed => next_state.set(AppState::Playing),
+            Interaction::Hovered => bg.0 = BUTTON_HOVER,
+            Interaction::None => bg.0 = BUTTON_IDLE,
         }
     }
 }
 
 pub fn handle_restart_input(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut restart_resource: ResMut<RestartPressed>,
+    keyboard: Res<ButtonInput<KeyCode>>,
+    mut restart: ResMut<RestartPressed>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::KeyR) {
-        restart_resource.pressed = true;
+    if keyboard.just_pressed(KeyCode::KeyR) {
+        restart.pressed = true;
     }
 }
 
 pub fn restart_game_system(
-    mut app_state: ResMut<NextState<AppState>>,
-    mut restart_resource: ResMut<RestartPressed>,
+    mut next_state: ResMut<NextState<AppState>>,
+    mut restart: ResMut<RestartPressed>,
 ) {
-    if restart_resource.pressed {
-        println!("Restart requested. Transitioning to Playing state.");
-        restart_resource.pressed = false;
-        app_state.set(AppState::Playing);
+    if restart.pressed {
+        restart.pressed = false;
+        next_state.set(AppState::Playing);
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index c782a34..9c16d49 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,44 +3,46 @@
 use bevy::prelude::*;
 use std::time::Duration;
 
+pub mod bullet;
 pub mod components;
 pub mod constants;
-pub mod resources;
+pub mod enemy;
 pub mod game_state;
 pub mod player;
-pub mod enemy;
-pub mod bullet;
+pub mod resources;
 pub mod stage;
-pub mod systems;
 pub mod starfield;
+pub mod systems;
 
-use components::TractorBeam;
-use constants::{PLAYER_RESPAWN_DELAY, STARTING_LIVES, WINDOW_HEIGHT, WINDOW_WIDTH};
-use resources::{
-    AttackDiveTimer, CurrentStage, EnemySpawnTimer, FormationState, PlayerLives,
-    PlayerRespawnTimer, Score, StageConfigurations,
-};
-use game_state::{
-    cleanup_game_entities, cleanup_game_over_ui, setup_game_over_ui, AppState,
-    setup_start_menu_ui, cleanup_start_menu_ui, start_menu_button_system,
-    handle_restart_input, restart_game_system,
-};
-use resources::RestartPressed;
-use player::{
-    check_player_enemy_collisions, manage_invincibility, move_player, player_shoot,
-    respawn_player, handle_captured_player,
-};
-use enemy::{
-    check_formation_complete, enemy_shoot, is_formation_complete, move_enemies, spawn_enemies,
-    trigger_attack_dives, boss_capture_attack, update_tractor_beam_visual,
-};
 use bullet::{
     check_bullet_collisions, check_enemy_bullet_player_collisions, move_bullets,
     move_enemy_bullets,
 };
+use components::TractorBeam;
+use constants::{PLAYER_RESPAWN_DELAY, STARTING_LIVES, WINDOW_HEIGHT, WINDOW_WIDTH};
+use enemy::{
+    boss_capture_attack, check_formation_complete, enemy_shoot, is_formation_complete,
+    move_enemies, spawn_enemies, trigger_attack_dives, update_tractor_beam_visual,
+};
+use game_state::{
+    cleanup_game_entities, cleanup_game_over_ui, cleanup_start_menu_ui, handle_restart_input,
+    restart_game_system, setup_game_over_ui, setup_start_menu_ui, start_menu_button_system,
+    AppState,
+};
+use player::{
+    check_player_enemy_collisions, handle_captured_player, manage_invincibility, move_player,
+    player_shoot, respawn_player,
+};
+use resources::{
+    AttackDiveTimer, CurrentStage, EnemySpawnTimer, FormationState, PlayerLives,
+    PlayerRespawnTimer, RestartPressed, Score, StageConfigurations,
+};
 use stage::check_stage_clear;
-use systems::{player_exists, player_vulnerable, setup, should_respawn_player, update_window_title, animate_explosion};
 use starfield::scroll_starfield;
+use systems::{
+    animate_explosion, player_exists, player_vulnerable, setup, should_respawn_player,
+    update_window_title,
+};
 
 pub fn run() {
     App::new()
@@ -58,29 +60,25 @@ pub fn run() {
         .insert_resource(EnemySpawnTimer {
             timer: Timer::new(Duration::from_secs_f32(1.0), TimerMode::Once),
         })
-        .insert_resource(PlayerLives { count: STARTING_LIVES })
+        .insert_resource(PlayerLives {
+            count: STARTING_LIVES,
+        })
         .insert_resource(PlayerRespawnTimer {
             timer: Timer::new(
                 Duration::from_secs_f32(PLAYER_RESPAWN_DELAY),
                 TimerMode::Once,
             ),
         })
-        .insert_resource(Score { value: 0 })
-        .insert_resource(CurrentStage {
-            number: 1,
-            waiting_for_clear: false,
-        })
-        .insert_resource(FormationState {
-            formation_complete: false,
-            total_spawned_this_stage: 0,
-            next_slot_index: 0,
-        })
         .insert_resource(AttackDiveTimer {
             timer: Timer::new(Duration::from_secs_f32(3.0), TimerMode::Once),
         })
-        .insert_resource(StageConfigurations::default())
-        .insert_resource(RestartPressed::default())
+        .init_resource::<Score>()
+        .init_resource::<CurrentStage>()
+        .init_resource::<FormationState>()
+        .init_resource::<StageConfigurations>()
+        .init_resource::<RestartPressed>()
         .add_systems(Startup, setup)
+        // Systems active only while Playing.
         .add_systems(
             Update,
             (
@@ -113,15 +111,22 @@ pub fn run() {
                 .chain()
                 .run_if(in_state(AppState::Playing)),
         )
-        .add_systems(Update, scroll_starfield)
-        .add_systems(Update, animate_explosion)
+        // Always-on background systems.
+        .add_systems(Update, (scroll_starfield, animate_explosion))
+        // Start menu.
         .add_systems(OnEnter(AppState::StartMenu), setup_start_menu_ui)
         .add_systems(OnExit(AppState::StartMenu), cleanup_start_menu_ui)
-        .add_systems(Update, start_menu_button_system.run_if(in_state(AppState::StartMenu)))
+        .add_systems(
+            Update,
+            start_menu_button_system.run_if(in_state(AppState::StartMenu)),
+        )
+        // Game over.
         .add_systems(OnEnter(AppState::GameOver), setup_game_over_ui)
-        .add_systems(Update, handle_restart_input.run_if(in_state(AppState::GameOver)))
-        .add_systems(Update, restart_game_system.run_if(in_state(AppState::GameOver)))
-        .add_systems(OnExit(AppState::Playing), cleanup_game_entities)
         .add_systems(OnExit(AppState::GameOver), cleanup_game_over_ui)
+        .add_systems(
+            Update,
+            (handle_restart_input, restart_game_system).run_if(in_state(AppState::GameOver)),
+        )
+        .add_systems(OnExit(AppState::Playing), cleanup_game_entities)
         .run();
 }
diff --git a/src/player.rs b/src/player.rs
index bc62cdd..a552694 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -1,5 +1,4 @@
 use bevy::prelude::*;
-use bevy::ecs::system::ParamSet;
 use std::time::Duration;
 
 use crate::components::{Bullet, Captured, Enemy, Invincible, Player};
@@ -11,7 +10,11 @@ use crate::game_state::AppState;
 use crate::resources::{PlayerLives, PlayerRespawnTimer};
 use crate::systems::spawn_explosion;
 
-// Helper to spawn player (used in setup and respawn)
+const PLAYER_SHOOT_COOLDOWN: f32 = 0.3;
+const CAPTURE_FOLLOW_LERP: f32 = 0.2;
+const CAPTURE_OFFSET_BELOW_BOSS: f32 = PLAYER_SIZE.y + 10.0;
+const INVINCIBILITY_BLINK_HZ: f32 = 10.0;
+
 pub fn spawn_player_ship(commands: &mut Commands) {
     commands.spawn((
         Sprite {
@@ -19,16 +22,14 @@ pub fn spawn_player_ship(commands: &mut Commands) {
             custom_size: Some(PLAYER_SIZE),
             ..default()
         },
-        Transform::from_translation(Vec3::new(
-            0.0,
-            -WINDOW_HEIGHT / 2.0 + PLAYER_SIZE.y / 2.0 + 20.0,
-            0.0,
-        )),
+        Transform::from_xyz(0.0, -WINDOW_HEIGHT / 2.0 + PLAYER_SIZE.y / 2.0 + 20.0, 0.0),
         Player {
             speed: PLAYER_SPEED,
-            shoot_cooldown: Timer::new(Duration::from_secs_f32(0.3), TimerMode::Once),
+            shoot_cooldown: Timer::new(
+                Duration::from_secs_f32(PLAYER_SHOOT_COOLDOWN),
+                TimerMode::Once,
+            ),
         },
-        // Player starts invincible for a short time
         Invincible {
             timer: Timer::new(
                 Duration::from_secs_f32(PLAYER_INVINCIBILITY_DURATION),
@@ -36,256 +37,194 @@ pub fn spawn_player_ship(commands: &mut Commands) {
             ),
         },
     ));
-    println!("Player spawned!");
 }
 
 pub fn move_player(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&mut Transform, &Player), Without<Captured>>, // Don't move captured players with controls
+    keyboard: Res<ButtonInput<KeyCode>>,
+    mut query: Query<(&mut Transform, &Player), Without<Captured>>,
     time: Res<Time>,
 ) {
-    // Using get_single_mut handles the case where player might not exist yet (or was just destroyed)
-    if let Ok((mut transform, player)) = query.single_mut() {
-        let mut direction = 0.0;
+    let Ok((mut transform, player)) = query.single_mut() else {
+        return;
+    };
 
-        if keyboard_input.pressed(KeyCode::KeyA) || keyboard_input.pressed(KeyCode::ArrowLeft) {
-            direction -= 1.0;
-        }
-
-        if keyboard_input.pressed(KeyCode::KeyD) || keyboard_input.pressed(KeyCode::ArrowRight) {
-            direction += 1.0;
-        }
-
-        transform.translation.x += direction * player.speed * time.delta_secs();
-        let half_player_width = PLAYER_SIZE.x / 2.0;
-        transform.translation.x = transform.translation.x.clamp(
-            -WINDOW_WIDTH / 2.0 + half_player_width,
-            WINDOW_WIDTH / 2.0 - half_player_width,
-        );
+    let mut direction = 0.0;
+    if keyboard.pressed(KeyCode::KeyA) || keyboard.pressed(KeyCode::ArrowLeft) {
+        direction -= 1.0;
     }
+    if keyboard.pressed(KeyCode::KeyD) || keyboard.pressed(KeyCode::ArrowRight) {
+        direction += 1.0;
+    }
+
+    transform.translation.x += direction * player.speed * time.delta_secs();
+    let half_width = PLAYER_SIZE.x / 2.0;
+    transform.translation.x = transform
+        .translation
+        .x
+        .clamp(-WINDOW_WIDTH / 2.0 + half_width, WINDOW_WIDTH / 2.0 - half_width);
 }
 
-// New system to handle captured player movement
 pub fn handle_captured_player(
     mut commands: Commands,
     time: Res<Time>,
-    mut set: ParamSet<(
-        Query<(Entity, &mut Transform, &mut Captured)>,
-        Query<&Transform, (With<Enemy>, Without<Player>)>,
-    )>,
+    mut player_query: Query<(Entity, &mut Transform, &mut Captured), With<Player>>,
+    boss_query: Query<&Transform, (With<Enemy>, Without<Player>)>,
     mut lives: ResMut<PlayerLives>,
     mut respawn_timer: ResMut<PlayerRespawnTimer>,
     mut next_state: ResMut<NextState<AppState>>,
 ) {
-    // First, collect data about captured players and their bosses
-    let mut captured_data = Vec::new();
-    
-    // Get player data
-    for (entity, transform, captured) in set.p0().iter() {
-        captured_data.push((entity, transform.translation, captured.boss_entity, captured.timer.clone()));
-    }
-    
-    // Process each captured player
-    for (player_entity, _player_pos, boss_entity, mut timer) in captured_data {
-        // Check if the boss exists and get its position
-        let boss_pos = set.p1().get(boss_entity).map(|t| t.translation).ok();
-        
-        // Tick the timer
-        timer.tick(time.delta());
-        
-        // Update the player
-        if let Ok((entity, mut transform, mut captured)) = set.p0().get_mut(player_entity) {
-            // Update the actual timer
-            captured.timer.tick(time.delta());
-            
-            match boss_pos {
-                Some(boss_pos) => {
-                    // Boss exists, update player position
-                    let target_pos = boss_pos - Vec3::new(0.0, PLAYER_SIZE.y + 10.0, 0.0);
-                    transform.translation = transform.translation.lerp(target_pos, 0.2);
-                }
-                None => {
-                    // Boss is gone, release player but lose a life
-                    println!("Boss is gone, releasing captured player!");
-                    commands.entity(entity).remove::<Captured>();
-                    lose_life_and_respawn(
-                        &mut commands,
-                        &mut lives,
-                        &mut respawn_timer,
-                        &mut next_state,
-                        entity,
-                        _player_pos,
-                    );
-                    continue; // Skip the rest of processing for this player
-                }
-            }
-            
-            // If capture duration expires, player escapes but loses a life
-            if captured.timer.is_finished() {
-                println!("Player escaped from capture after timer expired!");
-                commands.entity(entity).remove::<Captured>();
-                lose_life_and_respawn(
-                    &mut commands,
-                    &mut lives,
-                    &mut respawn_timer,
-                    &mut next_state,
-                    entity,
-                    transform.translation,
-                );
-            }
+    for (player_entity, mut transform, mut captured) in player_query.iter_mut() {
+        captured.timer.tick(time.delta());
+
+        let Ok(boss_transform) = boss_query.get(captured.boss_entity) else {
+            // Boss was despawned mid-capture: release and penalize.
+            commands.entity(player_entity).remove::<Captured>();
+            kill_player(
+                &mut commands,
+                &mut lives,
+                &mut respawn_timer,
+                &mut next_state,
+                player_entity,
+                transform.translation,
+            );
+            continue;
+        };
+
+        let target = boss_transform.translation - Vec3::Y * CAPTURE_OFFSET_BELOW_BOSS;
+        transform.translation = transform.translation.lerp(target, CAPTURE_FOLLOW_LERP);
+
+        if captured.timer.is_finished() {
+            commands.entity(player_entity).remove::<Captured>();
+            kill_player(
+                &mut commands,
+                &mut lives,
+                &mut respawn_timer,
+                &mut next_state,
+                player_entity,
+                transform.translation,
+            );
         }
     }
 }
 
-// Helper function for player life loss and respawn logic
-fn lose_life_and_respawn(
+/// Despawn the player at `position`, decrement lives, and either start the respawn
+/// timer or transition to GameOver. Does not handle collateral entities (the caller
+/// despawns enemies/bullets/etc. as needed).
+pub(crate) fn kill_player(
     commands: &mut Commands,
-    lives: &mut ResMut<PlayerLives>,
-    respawn_timer: &mut ResMut<PlayerRespawnTimer>,
-    next_state: &mut ResMut<NextState<AppState>>,
+    lives: &mut PlayerLives,
+    respawn_timer: &mut PlayerRespawnTimer,
+    next_state: &mut NextState<AppState>,
     player_entity: Entity,
-    player_position: Vec3,
+    position: Vec3,
 ) {
-    // Lose a life
     lives.count = lives.count.saturating_sub(1);
-    println!("Lives remaining: {}", lives.count);
-
-    // Spawn explosion at player position before destroying
-    spawn_explosion(commands, player_position);
-
-    // Destroy player
+    spawn_explosion(commands, position);
     commands.entity(player_entity).despawn();
 
     if lives.count > 0 {
         respawn_timer.timer.reset();
         respawn_timer.timer.unpause();
-        println!("Respawn timer started.");
     } else {
-        println!("GAME OVER!");
+        info!("GAME OVER");
         next_state.set(AppState::GameOver);
     }
 }
 
 pub fn player_shoot(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&Transform, &mut Player), Without<Captured>>, // Only non-captured players can shoot
+    keyboard: Res<ButtonInput<KeyCode>>,
+    mut query: Query<(&Transform, &mut Player), Without<Captured>>,
     mut commands: Commands,
     time: Res<Time>,
 ) {
-    if let Ok((player_transform, mut player)) = query.single_mut() {
-        player.shoot_cooldown.tick(time.delta());
+    let Ok((transform, mut player)) = query.single_mut() else {
+        return;
+    };
+    player.shoot_cooldown.tick(time.delta());
 
-        if (keyboard_input.just_pressed(KeyCode::Space)
-            || keyboard_input.just_pressed(KeyCode::ArrowUp))
-            && player.shoot_cooldown.is_finished()
-        {
-            player.shoot_cooldown.reset();
-
-            let bullet_start_pos = player_transform.translation
-                + Vec3::Y * (PLAYER_SIZE.y / 2.0 + BULLET_SIZE.y / 2.0);
-
-            commands.spawn((
-                Sprite {
-                    color: Color::srgb(1.0, 1.0, 1.0),
-                    custom_size: Some(BULLET_SIZE),
-                    ..default()
-                },
-                Transform::from_translation(bullet_start_pos),
-                Bullet,
-            ));
-        }
+    let fire = keyboard.just_pressed(KeyCode::Space) || keyboard.just_pressed(KeyCode::ArrowUp);
+    if !fire || !player.shoot_cooldown.is_finished() {
+        return;
     }
+    player.shoot_cooldown.reset();
+
+    let bullet_pos = transform.translation + Vec3::Y * (PLAYER_SIZE.y / 2.0 + BULLET_SIZE.y / 2.0);
+    commands.spawn((
+        Sprite {
+            color: Color::WHITE,
+            custom_size: Some(BULLET_SIZE),
+            ..default()
+        },
+        Transform::from_translation(bullet_pos),
+        Bullet,
+    ));
 }
 
-// Modified Collision Check for Player vs Enemy
 pub fn check_player_enemy_collisions(
     mut commands: Commands,
     mut lives: ResMut<PlayerLives>,
     mut respawn_timer: ResMut<PlayerRespawnTimer>,
-    mut next_state: ResMut<NextState<AppState>>, // Resource to change state
-    // Query player without Invincible component - relies on run_if condition too
+    mut next_state: ResMut<NextState<AppState>>,
     player_query: Query<
         (Entity, &Transform),
         (With<Player>, Without<Invincible>, Without<Captured>),
-    >, // Don't check collisions for captured players
+    >,
     enemy_query: Query<(Entity, &Transform), With<Enemy>>,
 ) {
-    // This system only runs if player exists and is not invincible, due to run_if
-    if let Ok((player_entity, player_transform)) = player_query.single() {
-        for (enemy_entity, enemy_transform) in enemy_query.iter() {
-            let distance = player_transform
-                .translation
-                .distance(enemy_transform.translation);
+    let Ok((player_entity, player_transform)) = player_query.single() else {
+        return;
+    };
+    let player_pos = player_transform.translation;
 
-            if distance < PLAYER_ENEMY_COLLISION_THRESHOLD {
-                println!("Player hit by enemy!");
-                spawn_explosion(&mut commands, enemy_transform.translation);
-                commands.entity(enemy_entity).despawn(); // Despawn enemy
+    let Some((enemy_entity, enemy_transform)) = enemy_query
+        .iter()
+        .find(|(_, t)| player_pos.distance(t.translation) < PLAYER_ENEMY_COLLISION_THRESHOLD)
+    else {
+        return;
+    };
 
-                lives.count = lives.count.saturating_sub(1); // Decrement lives safely
-                println!("Lives remaining: {}", lives.count);
-
-                spawn_explosion(&mut commands, player_transform.translation);
-                commands.entity(player_entity).despawn(); // Despawn player
-
-                if lives.count > 0 {
-                    // Start the respawn timer
-                    respawn_timer.timer.reset();
-                    respawn_timer.timer.unpause();
-                    println!("Respawn timer started.");
-                } else {
-                    println!("GAME OVER!");
-                    next_state.set(AppState::GameOver); // Updated for newer Bevy states API
-                }
-                // Important: Break after handling one collision per frame for the player
-                break;
-            }
-        }
-    }
+    spawn_explosion(&mut commands, enemy_transform.translation);
+    commands.entity(enemy_entity).despawn();
+    kill_player(
+        &mut commands,
+        &mut lives,
+        &mut respawn_timer,
+        &mut next_state,
+        player_entity,
+        player_pos,
+    );
 }
 
-// New System: Respawn Player
 pub fn respawn_player(
     mut commands: Commands,
     time: Res<Time>,
     mut respawn_timer: ResMut<PlayerRespawnTimer>,
-    // No player query needed here due to run_if condition
 ) {
-    // Tick the timer only if it's actually running
     if respawn_timer.timer.tick(time.delta()).just_finished() {
-        println!("Respawn timer finished. Spawning player.");
         spawn_player_ship(&mut commands);
-        respawn_timer.timer.pause(); // Pause timer until next death
+        respawn_timer.timer.pause();
     }
 }
 
-// New System: Manage Invincibility
 pub fn manage_invincibility(
     mut commands: Commands,
     time: Res<Time>,
-    mut query: Query<(Entity, &mut Invincible, Option<&mut Visibility>), With<Player>>,
+    mut query: Query<(Entity, &mut Invincible, &mut Visibility), With<Player>>,
 ) {
     for (entity, mut invincible, mut visibility) in query.iter_mut() {
         invincible.timer.tick(time.delta());
 
-        // Blinking effect (optional)
-        if let Some(ref mut vis) = visibility {
-            // Blink roughly 5 times per second
-            let elapsed_secs = invincible.timer.elapsed_secs();
-            **vis = if (elapsed_secs * 10.0).floor() % 2.0 == 0.0 {
+        if invincible.timer.is_finished() {
+            commands.entity(entity).remove::<Invincible>();
+            *visibility = Visibility::Visible;
+        } else {
+            // Blink at INVINCIBILITY_BLINK_HZ / 2 (one full cycle = 2 floor steps).
+            let phase = (invincible.timer.elapsed_secs() * INVINCIBILITY_BLINK_HZ) as u32;
+            *visibility = if phase.is_multiple_of(2) {
                 Visibility::Visible
             } else {
                 Visibility::Hidden
             };
         }
-
-        if invincible.timer.is_finished() {
-            println!("Invincibility finished.");
-            commands.entity(entity).remove::<Invincible>();
-            // Ensure player is visible when invincibility ends
-            if let Some(ref mut vis) = visibility {
-                **vis = Visibility::Visible;
-            }
-        }
     }
 }
diff --git a/src/resources.rs b/src/resources.rs
index 77633d5..7ca44af 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -1,6 +1,11 @@
 use bevy::prelude::*;
 
-// --- Resources ---
+use crate::components::AttackPattern;
+use crate::constants::{
+    ENEMY_SHOOT_INTERVAL, FORMATION_BASE_Y, FORMATION_COLS, FORMATION_ENEMY_COUNT,
+    FORMATION_X_SPACING, FORMATION_Y_SPACING, WINDOW_WIDTH,
+};
+
 #[derive(Resource)]
 pub struct EnemySpawnTimer {
     pub timer: Timer,
@@ -16,59 +21,57 @@ pub struct PlayerRespawnTimer {
     pub timer: Timer,
 }
 
-// New struct to define formation positions
 #[derive(Clone, Debug)]
 pub struct FormationLayout {
-    pub name: String, // Optional name for debugging/identification
+    pub name: String,
     pub positions: Vec<Vec3>,
 }
 
-// Default implementation for easy initialization
 impl Default for FormationLayout {
     fn default() -> Self {
-        // Default to the original grid formation for now
-        let mut positions = Vec::with_capacity(crate::constants::FORMATION_ENEMY_COUNT);
-        for i in 0..crate::constants::FORMATION_ENEMY_COUNT {
-            let row = i / crate::constants::FORMATION_COLS;
-            let col = i % crate::constants::FORMATION_COLS;
-            let target_x = (col as f32 - (crate::constants::FORMATION_COLS as f32 - 1.0) / 2.0)
-                * crate::constants::FORMATION_X_SPACING;
-            let target_y = crate::constants::FORMATION_BASE_Y
-                - (row as f32 * crate::constants::FORMATION_Y_SPACING);
-            positions.push(Vec3::new(target_x, target_y, 0.0));
-        }
-        FormationLayout {
+        let positions = (0..FORMATION_ENEMY_COUNT)
+            .map(|i| {
+                let row = i / FORMATION_COLS;
+                let col = i % FORMATION_COLS;
+                let x = (col as f32 - (FORMATION_COLS as f32 - 1.0) / 2.0) * FORMATION_X_SPACING;
+                let y = FORMATION_BASE_Y - row as f32 * FORMATION_Y_SPACING;
+                Vec3::new(x, y, 0.0)
+            })
+            .collect();
+        Self {
             name: "Default Grid".to_string(),
             positions,
         }
     }
 }
 
-// Configuration for a single stage
 #[derive(Clone, Debug)]
 pub struct StageConfig {
     pub formation_layout: FormationLayout,
-    pub enemy_count: usize, // Allow overriding enemy count per stage
-    pub attack_patterns: Vec<crate::components::AttackPattern>, // Possible patterns for this stage
-    pub attack_dive_interval: f32, // Time between attack dives for this stage
-    pub enemy_speed_multiplier: f32, // Speed multiplier for this stage
-    pub enemy_shoot_interval: f32, // Shoot interval for this stage
+    pub enemy_count: usize,
+    pub attack_patterns: Vec<AttackPattern>,
+    pub attack_dive_interval: f32,
+    pub enemy_speed_multiplier: f32,
+    pub enemy_shoot_interval: f32,
 }
 
-// Resource to hold all stage configurations
 #[derive(Resource, Debug, Clone)]
 pub struct StageConfigurations {
     pub stages: Vec<StageConfig>,
 }
 
+impl StageConfigurations {
+    /// Cycles through configured stages once `stage_number` exceeds the count.
+    pub fn for_stage(&self, stage_number: u32) -> &StageConfig {
+        let idx = (stage_number.saturating_sub(1) as usize) % self.stages.len();
+        &self.stages[idx]
+    }
+}
+
 impl Default for StageConfigurations {
     fn default() -> Self {
-        use crate::components::AttackPattern;
-        use crate::constants::*; // Import constants for default values
-
-        // Define configurations for a few stages
         let stage1 = StageConfig {
-            formation_layout: FormationLayout::default(), // Use the default grid
+            formation_layout: FormationLayout::default(),
             enemy_count: FORMATION_ENEMY_COUNT,
             attack_patterns: vec![AttackPattern::SwoopDive],
             attack_dive_interval: 3.0,
@@ -76,41 +79,36 @@ impl Default for StageConfigurations {
             enemy_shoot_interval: ENEMY_SHOOT_INTERVAL,
         };
 
-        let stage2_layout = {
-            let mut positions = Vec::new();
-            let radius = WINDOW_WIDTH / 4.0;
-            let center_y = FORMATION_BASE_Y - 50.0;
-            let count = 16; // Example: Fewer enemies in a circle
-            for i in 0..count {
-                let angle = (i as f32 / count as f32) * 2.0 * std::f32::consts::PI;
-                positions.push(Vec3::new(
-                    angle.cos() * radius,
-                    center_y + angle.sin() * radius,
-                    0.0,
-                ));
-            }
-            FormationLayout {
-                name: "Circle".to_string(),
-                positions,
-            }
-        };
+        let stage2_layout = circle_formation(16, WINDOW_WIDTH / 4.0, FORMATION_BASE_Y - 50.0);
         let stage2 = StageConfig {
             formation_layout: stage2_layout,
             enemy_count: 16,
-            attack_patterns: vec![AttackPattern::SwoopDive, AttackPattern::DirectDive], // Add direct dive
-            attack_dive_interval: 2.5,   // Faster dives
-            enemy_speed_multiplier: 1.2, // Faster enemies
-            enemy_shoot_interval: ENEMY_SHOOT_INTERVAL * 0.8, // Faster shooting
+            attack_patterns: vec![AttackPattern::SwoopDive, AttackPattern::DirectDive],
+            attack_dive_interval: 2.5,
+            enemy_speed_multiplier: 1.2,
+            enemy_shoot_interval: ENEMY_SHOOT_INTERVAL * 0.8,
         };
 
-        // Add more stages here...
-
-        StageConfigurations {
-            stages: vec![stage1, stage2], // Add more stages as needed
+        Self {
+            stages: vec![stage1, stage2],
         }
     }
 }
-#[derive(Resource)]
+
+fn circle_formation(count: usize, radius: f32, center_y: f32) -> FormationLayout {
+    let positions = (0..count)
+        .map(|i| {
+            let angle = (i as f32 / count as f32) * std::f32::consts::TAU;
+            Vec3::new(angle.cos() * radius, center_y + angle.sin() * radius, 0.0)
+        })
+        .collect();
+    FormationLayout {
+        name: "Circle".to_string(),
+        positions,
+    }
+}
+
+#[derive(Resource, Default)]
 pub struct Score {
     pub value: u32,
 }
@@ -118,14 +116,23 @@ pub struct Score {
 #[derive(Resource)]
 pub struct CurrentStage {
     pub number: u32,
-    pub waiting_for_clear: bool, // Flag to check if we should check for stage clear
+    pub waiting_for_clear: bool,
 }
 
-#[derive(Resource)]
+impl Default for CurrentStage {
+    fn default() -> Self {
+        Self {
+            number: 1,
+            waiting_for_clear: false,
+        }
+    }
+}
+
+#[derive(Resource, Default)]
 pub struct FormationState {
     pub next_slot_index: usize,
     pub total_spawned_this_stage: usize,
-    pub formation_complete: bool, // Flag to indicate if all enemies are in position
+    pub formation_complete: bool,
 }
 
 #[derive(Resource)]
diff --git a/src/stage.rs b/src/stage.rs
index 1c56969..30cac54 100644
--- a/src/stage.rs
+++ b/src/stage.rs
@@ -3,35 +3,19 @@ use bevy::prelude::*;
 use crate::components::Enemy;
 use crate::resources::{CurrentStage, EnemySpawnTimer, FormationState};
 
-// Helper to access world directly in check_stage_clear
-pub fn check_stage_clear(world: &mut World) {
-    // Use manual resource access because we need mutable access to multiple resources
-    // Separate checks to manage borrows correctly
-    let mut should_clear = false;
-    if let Some(stage) = world.get_resource::<CurrentStage>() {
-        if stage.waiting_for_clear {
-            // Create the query *after* checking the flag
-            let mut enemy_query = world.query_filtered::<Entity, With<Enemy>>();
-            if enemy_query.iter(world).next().is_none() {
-                should_clear = true;
-            }
-        }
+pub fn check_stage_clear(
+    enemy_query: Query<(), With<Enemy>>,
+    mut stage: ResMut<CurrentStage>,
+    mut formation_state: ResMut<FormationState>,
+    mut spawn_timer: ResMut<EnemySpawnTimer>,
+) {
+    if !stage.waiting_for_clear || !enemy_query.is_empty() {
+        return;
     }
 
-    if should_clear {
-        // Get mutable resources only when needed
-        if let Some(mut stage) = world.get_resource_mut::<CurrentStage>() {
-            stage.number += 1;
-            stage.waiting_for_clear = false;
-            println!("Stage cleared! Starting Stage {}...", stage.number);
-        }
-        if let Some(mut formation_state) = world.get_resource_mut::<FormationState>() {
-            formation_state.next_slot_index = 0;
-            formation_state.total_spawned_this_stage = 0;
-            formation_state.formation_complete = false; // Reset flag for new stage
-        }
-        if let Some(mut spawn_timer) = world.get_resource_mut::<EnemySpawnTimer>() {
-            spawn_timer.timer.reset();
-        }
-    }
-}
\ No newline at end of file
+    stage.number += 1;
+    stage.waiting_for_clear = false;
+    *formation_state = FormationState::default();
+    spawn_timer.timer.reset();
+    info!("Starting Stage {}", stage.number);
+}
diff --git a/src/starfield.rs b/src/starfield.rs
index e3ed5d5..2a3e976 100644
--- a/src/starfield.rs
+++ b/src/starfield.rs
@@ -2,27 +2,29 @@ use bevy::prelude::*;
 
 use crate::components::Star;
 use crate::constants::{
-    STAR_COUNT, STAR_MAX_SIZE, STAR_MAX_SPEED, STAR_MIN_SIZE, STAR_MIN_SPEED,
-    STAR_Z_DEPTH, WINDOW_HEIGHT, WINDOW_WIDTH,
+    STAR_COUNT, STAR_MAX_SIZE, STAR_MAX_SPEED, STAR_MIN_SIZE, STAR_MIN_SPEED, STAR_Z_DEPTH,
+    WINDOW_HEIGHT, WINDOW_WIDTH,
 };
 
+const PARALLAX_FACTOR: f32 = 0.01;
+
 pub fn spawn_starfield(commands: &mut Commands) {
     for _ in 0..STAR_COUNT {
-        let size = fastrand::f32() * (STAR_MAX_SIZE - STAR_MIN_SIZE) + STAR_MIN_SIZE;
-        let speed = fastrand::f32() * (STAR_MAX_SPEED - STAR_MIN_SPEED) + STAR_MIN_SPEED;
-        let brightness = fastrand::f32() * 0.5 + 0.5; // 0.5 to 1.0
+        let size = lerp_random(STAR_MIN_SIZE, STAR_MAX_SIZE);
+        let speed = lerp_random(STAR_MIN_SPEED, STAR_MAX_SPEED);
+        let brightness = 0.5 + fastrand::f32() * 0.5;
 
         commands.spawn((
             Sprite {
                 color: Color::srgb(brightness, brightness, brightness),
-                custom_size: Some(Vec2::new(size, size)),
+                custom_size: Some(Vec2::splat(size)),
                 ..default()
             },
-            Transform::from_translation(Vec3::new(
-                fastrand::f32() * WINDOW_WIDTH - WINDOW_WIDTH / 2.0,
-                fastrand::f32() * WINDOW_HEIGHT - WINDOW_HEIGHT / 2.0,
+            Transform::from_xyz(
+                (fastrand::f32() - 0.5) * WINDOW_WIDTH,
+                (fastrand::f32() - 0.5) * WINDOW_HEIGHT,
                 STAR_Z_DEPTH,
-            )),
+            ),
             Star { speed },
         ));
     }
@@ -30,16 +32,19 @@ pub fn spawn_starfield(commands: &mut Commands) {
 
 pub fn scroll_starfield(mut star_query: Query<(&mut Transform, &Star)>, time: Res<Time>) {
     let dt = time.delta_secs();
-    let half_height = WINDOW_HEIGHT / 2.0;
-    let half_width = WINDOW_WIDTH / 2.0;
+    let half_h = WINDOW_HEIGHT / 2.0;
 
     for (mut transform, star) in star_query.iter_mut() {
-        let parallax = -transform.translation.y * 0.01;
+        let parallax = -transform.translation.y * PARALLAX_FACTOR;
         transform.translation.y -= (star.speed + parallax) * dt;
 
-        if transform.translation.y < -half_height {
-            transform.translation.y = half_height;
-            transform.translation.x = fastrand::f32() * WINDOW_WIDTH - half_width;
+        if transform.translation.y < -half_h {
+            transform.translation.y = half_h;
+            transform.translation.x = (fastrand::f32() - 0.5) * WINDOW_WIDTH;
         }
     }
 }
+
+fn lerp_random(min: f32, max: f32) -> f32 {
+    min + fastrand::f32() * (max - min)
+}
diff --git a/src/systems.rs b/src/systems.rs
index df49618..a3a80f0 100644
--- a/src/systems.rs
+++ b/src/systems.rs
@@ -1,19 +1,20 @@
 use bevy::prelude::*;
+use std::time::Duration;
 
 use crate::components::{Explosion, Invincible, Player};
 use crate::constants::{EXPLOSION_BASE_SIZE, EXPLOSION_COLOR, EXPLOSION_DURATION, EXPLOSION_MAX_SIZE};
-use crate::resources::{CurrentStage, PlayerLives, Score};
 use crate::player::spawn_player_ship;
+use crate::resources::{CurrentStage, PlayerLives, Score};
 use crate::starfield::spawn_starfield;
 
-// --- Setup ---
 pub fn setup(mut commands: Commands) {
     commands.spawn(Camera2d);
     spawn_starfield(&mut commands);
     spawn_player_ship(&mut commands);
 }
 
-// --- Run Conditions ---
+// --- Run conditions ---
+
 pub fn player_exists(query: Query<&Player>) -> bool {
     !query.is_empty()
 }
@@ -22,30 +23,30 @@ pub fn player_vulnerable(query: Query<&Player, Without<Invincible>>) -> bool {
     !query.is_empty()
 }
 
-pub fn should_respawn_player(lives: Res<PlayerLives>, player_query: Query<&Player>) -> bool {
-    player_query.is_empty() && lives.count > 0
+pub fn should_respawn_player(lives: Res<PlayerLives>, query: Query<&Player>) -> bool {
+    query.is_empty() && lives.count > 0
 }
 
-// --- General Systems ---
+// --- HUD ---
 
-// Update Window Title with Lives, Score, and Stage
 pub fn update_window_title(
     lives: Res<PlayerLives>,
     score: Res<Score>,
     stage: Res<CurrentStage>,
     mut windows: Query<&mut Window>,
 ) {
-    if lives.is_changed() || score.is_changed() || stage.is_changed() {
-        if let Ok(mut window) = windows.single_mut() {
-            window.title = format!(
-                "Galaga :: Stage: {} Lives: {} Score: {}",
-                stage.number, lives.count, score.value
-            );
-        }
+    if !(lives.is_changed() || score.is_changed() || stage.is_changed()) {
+        return;
+    }
+    if let Ok(mut window) = windows.single_mut() {
+        window.title = format!(
+            "Galaga :: Stage: {} Lives: {} Score: {}",
+            stage.number, lives.count, score.value
+        );
     }
 }
 
-// --- Explosion Systems ---
+// --- Explosions ---
 
 pub fn spawn_explosion(commands: &mut Commands, position: Vec3) {
     commands.spawn((
@@ -56,7 +57,7 @@ pub fn spawn_explosion(commands: &mut Commands, position: Vec3) {
         },
         Transform::from_translation(position),
         Explosion {
-            timer: Timer::new(std::time::Duration::from_secs_f32(EXPLOSION_DURATION), TimerMode::Once),
+            timer: Timer::new(Duration::from_secs_f32(EXPLOSION_DURATION), TimerMode::Once),
         },
     ));
 }
@@ -66,19 +67,14 @@ pub fn animate_explosion(
     time: Res<Time>,
     mut query: Query<(Entity, &mut Explosion, &mut Sprite)>,
 ) {
+    let base = EXPLOSION_COLOR.to_srgba();
     for (entity, mut explosion, mut sprite) in query.iter_mut() {
         explosion.timer.tick(time.delta());
+        let progress = (explosion.timer.elapsed_secs() / EXPLOSION_DURATION).min(1.0);
 
-        let progress = explosion.timer.elapsed_secs() / EXPLOSION_DURATION;
-        let clamped_progress = progress.min(1.0);
-
-        let scale_x = EXPLOSION_BASE_SIZE.x + (EXPLOSION_MAX_SIZE.x - EXPLOSION_BASE_SIZE.x) * clamped_progress;
-        let scale_y = EXPLOSION_BASE_SIZE.y + (EXPLOSION_MAX_SIZE.y - EXPLOSION_BASE_SIZE.y) * clamped_progress;
-        sprite.custom_size = Some(Vec2::new(scale_x, scale_y));
-
-        let alpha = 1.0 - clamped_progress;
-        let base = EXPLOSION_COLOR.to_srgba();
-        sprite.color = Color::srgba(base.red, base.green, base.blue, alpha);
+        let size = EXPLOSION_BASE_SIZE.lerp(EXPLOSION_MAX_SIZE, progress);
+        sprite.custom_size = Some(size);
+        sprite.color = Color::srgba(base.red, base.green, base.blue, 1.0 - progress);
 
         if explosion.timer.is_finished() {
             commands.entity(entity).despawn();