.mcp.json

@@ -1,3 +0,0 @@
-{
-  "mcpServers": {}
-}

Cargo.toml

@@ -4,5 +4,5 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.18"
+bevy = "0.13"
 fastrand = "2.0.1"

README.md

@@ -34,28 +34,3 @@ nix develop --command bash -c "cargo build"
 2.  Clone the repository.
 3.  Navigate to the project directory.
 4.  Run the game using the command: `nix develop --command bash -c "cargo run"`
-
-## Headless Screenshots
-
-The flake exposes a `take-screenshots` app that launches a binary inside an
-Xvfb display backed by lavapipe (software Vulkan), waits, and captures one or
-more PNG screenshots. Useful for smoke-testing rendering without a real GPU.
-
-```
-nix run .#take-screenshots -- EXE NUM DELAY_START PAUSE_INBETWEEN [OUTPUT_DIR]
-```
-
-*   `EXE` — path to the executable to launch
-*   `NUM` — number of screenshots to take
-*   `DELAY_START` — seconds to wait after launch before the first shot
-*   `PAUSE_INBETWEEN` — seconds between consecutive shots
-*   `OUTPUT_DIR` — where to write `shot-NNN.png` files (default: current directory)
-
-Example, capturing three frames of the game one second apart after a six-second
-warm-up (Bevy + software Vulkan needs roughly that long to render its first
-frame):
-
-```
-cargo build
-nix run .#take-screenshots -- ./target/debug/bglga 3 6 1 ./shots
-```

TODO.md

@@ -29,12 +29,9 @@
     *   [x] GAL-22: Periodically trigger random enemies to start an attack dive.
     *   [x] GAL-23: Enemies fire bullets during their dives.
     *   [x] GAL-24: Enemies are despawned when they fly off-screen after an attack.
-*   [ ] **GAL-25: Enemy Variety**
+*   [x] **GAL-25: Enemy Variety**
     *   [x] GAL-26: `EnemyType` enum (`Grunt`, `Boss`).
-    *   [ ] GAL-27: Different behaviors, points, and colors based on type.
+    *   [x] GAL-27: Different behaviors, points, and colors based on type.
-        *   [x] Colors differ (Grunt red, Boss purple) — `enemy.rs:80-83`
-        *   [x] Behaviors differ (Boss has `CaptureBeam`, distinct SwoopDive) — `enemy.rs:254-318`
-        *   [ ] Points: Boss currently awards same 100 points as Grunt — see `bullet.rs:48-51` (`// Same points as Grunt for now`). Boss should award more.
 
 **3. Advanced Galaga Mechanics**
 
@@ -43,8 +40,7 @@
     *   [x] GAL-30: Implement the tractor beam attack logic (`boss_capture_attack` system).
     *   [x] GAL-31: Player has a `Captured` component when hit by the beam.
     *   [x] GAL-32: Boss has a `ReturningWithCaptive` state to go back to the formation.
-    *   [x] GAL-33: Improve the tractor beam visual effect (currently a simple rectangle).
+    *   [ ] GAL-33: Improve the tractor beam visual effect (currently a simple rectangle).
-        *   Completed on branch gal-33-improve-tractor-beam-visual, commit 52b0919 — 2-layer glow beam with pulse animation, 8 unit tests
 *   [ ] **GAL-34: Dual Fighter (Rescuing Captured Ship)**
     *   [ ] GAL-35: Allow the player to shoot a Boss that is holding a captured ship.
     *   [ ] GAL-36: Implement the logic to free the captured ship upon shooting the Boss.
@@ -58,9 +54,7 @@
 
 *   [ ] **GAL-42: Visuals**
     *   [ ] GAL-43: Replace placeholder geometric shapes with actual sprites.
-    *   [x] GAL-44: Add explosion animations/effects.
+    *   [ ] GAL-44: Add explosion animations/effects.
-        *   **Branch:** `gal-44-add-explosion-effects`
-        *   **Comment:** 2026-05-06 — Implementation complete with commit `2ff561e`
     *   [x] GAL-45: Implement a scrolling starfield background.
 *   [ ] **GAL-46: Audio**
     *   [ ] GAL-47: Integrate `bevy_audio`.

flake.nix

@@ -26,102 +26,9 @@
           libxi
           libxkbcommon
           libxcb
-          wayland
           vulkan-loader
           glfw
         ];
-
-        takeScreenshots = pkgs.writeShellApplication {
-          name = "take-screenshots";
-          runtimeInputs = with pkgs; [
-            xorg-server
-            imagemagick
-            coreutils
-          ];
-          text = ''
-            set -euo pipefail
-
-            if [ "$#" -lt 4 ]; then
-              cat >&2 <<'USAGE'
-            Usage: take-screenshots EXE NUM DELAY_START PAUSE_INBETWEEN [OUTPUT_DIR]
-
-              EXE              path to executable to launch
-              NUM              number of screenshots to take
-              DELAY_START      seconds to wait after launching EXE before first shot
-              PAUSE_INBETWEEN  seconds between consecutive shots
-              OUTPUT_DIR       output directory (default: current directory)
-            USAGE
-              exit 1
-            fi
-
-            EXE=$1
-            NUM=$2
-            DELAY_START=$3
-            PAUSE=$4
-            OUTDIR=''${5:-.}
-
-            mkdir -p "$OUTDIR"
-
-            # Locate lavapipe (software Vulkan) ICD; needed because Xvfb has no GPU.
-            LVP_ICD=
-            for c in \
-              "${pkgs.mesa}/share/vulkan/icd.d/lvp_icd.x86_64.json" \
-              /run/opengl-driver/share/vulkan/icd.d/lvp_icd.x86_64.json
-            do
-              if [ -f "$c" ]; then LVP_ICD=$c; break; fi
-            done
-            if [ -z "$LVP_ICD" ]; then
-              echo "take-screenshots: could not locate lavapipe Vulkan ICD" >&2
-              exit 1
-            fi
-
-            # Pick a free X display.
-            DISPLAY_NUM=99
-            while [ -e "/tmp/.X$DISPLAY_NUM-lock" ] || [ -e "/tmp/.X11-unix/X$DISPLAY_NUM" ]; do
-              DISPLAY_NUM=$((DISPLAY_NUM + 1))
-            done
-
-            Xvfb ":$DISPLAY_NUM" -screen 0 800x900x24 \
-              +extension GLX +extension RANDR +render -ac &
-            XVFB_PID=$!
-
-            GAME_PID=
-            cleanup() {
-              if [ -n "$GAME_PID" ]; then
-                kill "$GAME_PID" 2>/dev/null || true
-                wait "$GAME_PID" 2>/dev/null || true
-              fi
-              kill "$XVFB_PID" 2>/dev/null || true
-              wait "$XVFB_PID" 2>/dev/null || true
-              rm -f "/tmp/.X$DISPLAY_NUM-lock"
-            }
-            trap cleanup EXIT
-
-            sleep 0.5
-
-            export DISPLAY=":$DISPLAY_NUM"
-            export VK_ICD_FILENAMES=$LVP_ICD
-            export LD_LIBRARY_PATH="${pkgs.lib.makeLibraryPath runtimeLibs}''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
-
-            "$EXE" &
-            GAME_PID=$!
-
-            sleep "$DELAY_START"
-
-            for i in $(seq 1 "$NUM"); do
-              if ! kill -0 "$GAME_PID" 2>/dev/null; then
-                echo "take-screenshots: process exited before screenshot $i" >&2
-                exit 1
-              fi
-              out=$(printf "%s/shot-%03d.png" "$OUTDIR" "$i")
-              import -window root "$out"
-              echo "$out"
-              if [ "$i" -lt "$NUM" ]; then
-                sleep "$PAUSE"
-              fi
-            done
-          '';
-        };
       in
       {
         devShells.default = pkgs.mkShell {
@@ -142,11 +49,6 @@
 
           LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath runtimeLibs;
         };
-
-        apps.take-screenshots = {
-          type = "app";
-          program = "${takeScreenshots}/bin/take-screenshots";
-        };
       }
     );
 }

src/bullet.rs

@@ -1,17 +1,16 @@
 use bevy::prelude::*;
 
-use crate::components::{Bullet, Enemy, EnemyBullet, EnemyType, Invincible, Player};
+use crate::components::{Bullet, Enemy, EnemyBullet, EnemyType};
 use crate::constants::{
-    BULLET_ENEMY_COLLISION_THRESHOLD, BULLET_SIZE, BULLET_SPEED,
+    BULLET_ENEMY_COLLISION_THRESHOLD, BULLET_SIZE, BULLET_SPEED, ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD,
-    ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD, ENEMY_BULLET_SIZE, ENEMY_BULLET_SPEED, WINDOW_HEIGHT,
+    ENEMY_BULLET_SIZE, ENEMY_BULLET_SPEED, WINDOW_HEIGHT,
 };
-use crate::game_state::AppState;
-use crate::player::kill_player;
 use crate::resources::{PlayerLives, PlayerRespawnTimer, Score};
-use crate::systems::spawn_explosion;
+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
 
-const GRUNT_POINTS: u32 = 100;
+// --- Player Bullet Systems ---
-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>>,
@@ -19,7 +18,8 @@ pub fn move_bullets(
     mut commands: Commands,
 ) {
     for (entity, mut transform) in query.iter_mut() {
-        transform.translation.y += BULLET_SPEED * time.delta_secs();
+        transform.translation.y += BULLET_SPEED * time.delta_seconds();
+
         if transform.translation.y > WINDOW_HEIGHT / 2.0 + BULLET_SIZE.y {
             commands.entity(entity).despawn();
         }
@@ -29,65 +29,85 @@ 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)>,
+    enemy_query: Query<(Entity, &Transform, &Enemy), With<Enemy>>, // Fetch Enemy component too
-    mut score: ResMut<Score>,
+    mut score: ResMut<Score>,                                      // Add Score resource
 ) {
     for (bullet_entity, bullet_transform) in bullet_query.iter() {
-        let hit = enemy_query.iter().find(|(_, t, _)| {
+        for (enemy_entity, enemy_transform, enemy) in enemy_query.iter() {
-            bullet_transform.translation.distance(t.translation) < BULLET_ENEMY_COLLISION_THRESHOLD
+            // Get Enemy component
-        });
+            let distance = bullet_transform
+                .translation
+                .distance(enemy_transform.translation);
 
-        if let Some((enemy_entity, enemy_transform, enemy)) = hit {
+            if distance < BULLET_ENEMY_COLLISION_THRESHOLD {
-            commands.entity(bullet_entity).despawn();
+                commands.entity(bullet_entity).despawn();
-            spawn_explosion(&mut commands, enemy_transform.translation);
+                commands.entity(enemy_entity).despawn();
-            commands.entity(enemy_entity).despawn();
+                // Increment score based on enemy type
-            score.value += match enemy.enemy_type {
+                let points = match enemy.enemy_type {
-                EnemyType::Grunt => GRUNT_POINTS,
+                    EnemyType::Grunt => 100,
-                EnemyType::Boss => BOSS_POINTS,
+                    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
+            }
         }
     }
 }
 
+// --- Enemy Bullet Systems ---
+
 pub fn move_enemy_bullets(
     mut commands: Commands,
     time: Res<Time>,
     mut query: Query<(Entity, &mut Transform), With<EnemyBullet>>,
 ) {
     for (entity, mut transform) in query.iter_mut() {
-        transform.translation.y -= ENEMY_BULLET_SPEED * time.delta_secs();
+        transform.translation.y -= ENEMY_BULLET_SPEED * time.delta_seconds();
+
+        // 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>)>,
-    bullet_query: Query<(Entity, &Transform), With<EnemyBullet>>,
+    enemy_bullet_query: Query<(Entity, &Transform), With<EnemyBullet>>,
 ) {
-    let Ok((player_entity, player_transform)) = player_query.single() else {
+    if let Ok((player_entity, player_transform)) = player_query.get_single() {
-        return;
+        for (bullet_entity, bullet_transform) in enemy_bullet_query.iter() {
-    };
+            let distance = player_transform
-    let player_pos = player_transform.translation;
+                .translation
+                .distance(bullet_transform.translation);
 
-    let Some((bullet_entity, _)) = bullet_query.iter().find(|(_, t)| {
+            if distance < ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD {
-        player_pos.distance(t.translation) < ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD
+                println!("Player hit by enemy bullet!");
-    }) else {
+                commands.entity(bullet_entity).despawn(); // Despawn bullet
-        return;
-    };
 
-    commands.entity(bullet_entity).despawn();
+                lives.count = lives.count.saturating_sub(1);
-    kill_player(
+                println!("Lives remaining: {}", lives.count);
-        &mut commands,
+
-        &mut lives,
+                commands.entity(player_entity).despawn(); // Despawn player
-        &mut respawn_timer,
+
-        &mut next_state,
+                if lives.count > 0 {
-        player_entity,
+                    respawn_timer.timer.reset();
-        player_pos,
+                    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;
+            }
+        }
+    }
+}

src/components.rs

@@ -1,5 +1,6 @@
 use bevy::prelude::*;
 
+// --- Components ---
 #[derive(Component)]
 pub struct Player {
     pub speed: f32,
@@ -9,15 +10,15 @@ pub struct Player {
 #[derive(Component)]
 pub struct Bullet;
 
-#[derive(Component, Clone, Copy, PartialEq, Eq, Debug)]
+#[derive(Component, Clone, Copy, PartialEq, Eq, Debug)] // Added derive for common traits
 pub enum EnemyType {
     Grunt,
-    Boss,
+    Boss, // Added Boss type
 }
 
 #[derive(Component)]
 pub struct Enemy {
-    pub enemy_type: EnemyType,
+    pub enemy_type: EnemyType, // Add type field
     pub shoot_cooldown: Timer,
 }
 
@@ -26,57 +27,61 @@ pub struct Invincible {
     pub timer: Timer,
 }
 
-/// Marks a player held by a Boss's tractor beam.
+// New component to mark a player as captured by a Boss enemy
-#[derive(Component)]
+#[derive(Component, Clone)] // Added Clone derive
 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>,
+    pub target: Option<Entity>, // The entity being targeted (usually player)
-    pub timer: Timer,
+    pub timer: Timer,           // How long the beam lasts
-    pub width: f32,
+    pub width: f32,             // Visual width of the beam
-    pub active: bool,
+    pub active: bool,           // Whether the beam is currently active
 }
 
-#[derive(Component)]
-pub struct TractorBeamSprite;
-
 #[derive(Component)]
 pub struct FormationTarget {
     pub position: Vec3,
 }
 
-/// Stored on enemies once they reach formation, so attackers can return to it.
+// Component to store the original formation position for enemies that need to return
 #[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,
+    SwoopDive,      // Original pattern: dive towards center, then off screen
-    DirectDive,
+    DirectDive,     // Dive straight down
-    Kamikaze(Vec3),
+    Kamikaze(Vec3), // Dive towards a specific target location (e.g., player's last known position) - Needs target Vec3
-    CaptureBeam,
+    CaptureBeam, // New pattern: Boss dives and attempts to capture the player with a tractor beam
+                 // Add more patterns later (e.g., FigureEight, Looping)
 }
 
-#[derive(Component, Clone, PartialEq, Debug)]
+#[derive(Component, Clone, PartialEq, Debug)] // Added Debug derive
 pub enum EnemyState {
-    Entering,
+    Entering,                 // Flying onto the screen towards formation target
-    InFormation,
+    InFormation,              // Holding position in the formation
-    Attacking(AttackPattern),
+    Attacking(AttackPattern), // Diving towards the player using a specific pattern
-    ReturningWithCaptive,
+    ReturningWithCaptive,     // Boss returning to formation with captured player
 }
 
 #[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;
 
@@ -90,8 +95,3 @@ pub struct RestartMessage;
 pub struct Star {
     pub speed: f32,
 }
-
-#[derive(Component)]
-pub struct Explosion {
-    pub timer: Timer,
-}

src/constants.rs

@@ -1,62 +1,49 @@
 use bevy::math::Vec2;
 use bevy::prelude::*;
 
-// Window
+// --- Constants ---
 pub const WINDOW_WIDTH: f32 = 600.0;
 pub const WINDOW_HEIGHT: f32 = 800.0;
-
-// Player
 pub const PLAYER_SPEED: f32 = 300.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 ENEMY_SHOOT_INTERVAL: f32 = 1.5;
-
-// Bullets
 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 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
+// Formation constants
 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
-// Collision thresholds (mean of half-widths)
+pub const STARTING_LIVES: u32 = 3;
+pub const PLAYER_RESPAWN_DELAY: f32 = 2.0;
+pub const PLAYER_INVINCIBILITY_DURATION: f32 = 2.0;
+// Collision thresholds
 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
+// Tractor beam constants
 pub const TRACTOR_BEAM_WIDTH: f32 = 20.0;
 pub const TRACTOR_BEAM_DURATION: f32 = 3.0;
-pub const CAPTURE_DURATION: f32 = 10.0;
+pub const TRACTOR_BEAM_COLOR: Color = Color::rgba(0.5, 0.0, 0.8, 0.6);
-pub const BEAM_GLOW_WIDTH: f32 = 40.0;
+pub const CAPTURE_DURATION: f32 = 10.0; // How long the player stays captured
-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
+// Starfield constants
 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;
+pub const STAR_Z_DEPTH: f32 = -10.0; // Behind all game entities
-
-// 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);
-pub const EXPLOSION_COLOR: Color = Color::srgba(1.0, 0.6, 0.1, 1.0);

src/game_state.rs

@@ -1,8 +1,8 @@
+use crate::components::{Bullet, Enemy, GameOverUI, RestartMessage, StartButton, StartMenuUI};
+use crate::resources::RestartPressed;
 use bevy::prelude::*;
 
-use crate::components::{Bullet, Enemy, EnemyBullet, GameOverUI, RestartMessage, StartButton, StartMenuUI};
+// --- Game States ---
-use crate::resources::RestartPressed;
-
 #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
 pub enum AppState {
     #[default]
@@ -11,159 +11,207 @@ 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"),
+        TextBundle::from_section(
-        TextFont {
+            "GAME OVER",
-            font_size: 100.0,
+            TextStyle {
-            ..default()
+                font_size: 100.0,
-        },
+                color: Color::WHITE,
-        TextColor(Color::WHITE),
+                ..default()
-        Node {
+            },
+        )
+        .with_style(Style {
             position_type: PositionType::Absolute,
             align_self: AlignSelf::Center,
             justify_self: JustifySelf::Center,
             top: Val::Percent(40.0),
             ..default()
-        },
+        }),
         GameOverUI,
     ));
     commands.spawn((
-        Text::new("Press R to Restart"),
+        TextBundle::from_section(
-        TextFont {
+            "Press R to Restart",
-            font_size: 32.0,
+            TextStyle {
-            ..default()
+                font_size: 32.0,
-        },
+                color: Color::WHITE,
-        TextColor(Color::WHITE),
+                ..default()
-        Node {
+            },
+        )
+        .with_style(Style {
             position_type: PositionType::Absolute,
             align_self: AlignSelf::Center,
             justify_self: JustifySelf::Center,
             top: Val::Percent(55.0),
             ..default()
-        },
+        }),
         RestartMessage,
     ));
 }
 
 pub fn cleanup_game_over_ui(
     mut commands: Commands,
-    query: Query<Entity, Or<(With<GameOverUI>, With<RestartMessage>)>>,
+    query: Query<Entity, With<GameOverUI>>,
+    restart_query: Query<Entity, With<RestartMessage>>,
 ) {
-    for entity in &query {
+    println!("Exiting GameOver state. Cleaning up UI.");
-        commands.entity(entity).despawn();
+    for entity in query.iter() {
+        commands.entity(entity).despawn_recursive();
+    }
+    for entity in restart_query.iter() {
+        commands.entity(entity).despawn_recursive();
     }
 }
 
-// --- Cleanup on leaving Playing ---
+// --- Cleanup ---
 
+// Cleanup system when exiting the Playing state
 pub fn cleanup_game_entities(
     mut commands: Commands,
-    query: Query<Entity, Or<(With<Bullet>, With<EnemyBullet>, With<Enemy>)>>,
+    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>>,
+    // Optionally despawn player too, or handle separately if needed for restart
+    // player_query: Query<Entity, With<Player>>,
 ) {
-    for entity in &query {
+    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() {
+        commands.entity(entity).despawn();
+    }
+    // for entity in player_query.iter() {
+    //     commands.entity(entity).despawn();
+    // }
 }
 
 // --- Start Menu UI ---
 
 pub fn setup_start_menu_ui(mut commands: Commands) {
+    println!("Entering StartMenu state. Setting up UI.");
+
+    // Root UI container
     commands
         .spawn((
-            Node {
+            NodeBundle {
-                width: Val::Percent(100.0),
+                style: Style {
-                height: Val::Percent(100.0),
+                    width: Val::Percent(100.0),
-                align_items: AlignItems::Center,
+                    height: Val::Percent(100.0),
-                justify_content: JustifyContent::Center,
+                    align_items: AlignItems::Center,
-                flex_direction: FlexDirection::Column,
+                    justify_content: JustifyContent::Center,
+                    flex_direction: FlexDirection::Column,
+                    ..default()
+                },
                 ..default()
             },
             StartMenuUI,
         ))
         .with_children(|parent| {
-            parent.spawn((
+            // Title
-                Text::new("BGLGA"),
+            parent.spawn(
-                TextFont {
+                TextBundle::from_section(
-                    font_size: 120.0,
+                    "BGLGA",
-                    ..default()
+                    TextStyle {
-                },
+                        font_size: 120.0,
-                TextColor(Color::WHITE),
+                        color: Color::WHITE,
-                Node {
+                        ..default()
-                    margin: UiRect::bottom(Val::Px(50.0)),
+                    },
-                    ..default()
+                )
-                },
+                .with_style(Style {
-            ));
+                    margin: UiRect::bottom(Val::Px(50.0)),
-            parent
+                    ..default()
-                .spawn((
+                }),
-                    Button,
+            );
-                    Node {
+
-                        width: Val::Px(250.0),
+            // Start Game Button
-                        height: Val::Px(80.0),
+            parent
-                        border: UiRect::all(Val::Px(2.0)),
+                .spawn((
-                        justify_content: JustifyContent::Center,
+                    ButtonBundle {
-                        align_items: AlignItems::Center,
+                        style: Style {
+                            width: Val::Px(250.0),
+                            height: Val::Px(80.0),
+                            border: UiRect::all(Val::Px(2.0)),
+                            justify_content: JustifyContent::Center,
+                            align_items: AlignItems::Center,
+                            ..default()
+                        },
+                        border_color: BorderColor(Color::WHITE),
+                        background_color: BackgroundColor(Color::rgb(0.1, 0.1, 0.5)),
                         ..default()
                     },
-                    BorderColor::all(Color::WHITE),
-                    BackgroundColor(BUTTON_IDLE),
                     StartButton,
                 ))
                 .with_children(|parent| {
-                    parent.spawn((
+                    parent.spawn(TextBundle::from_section(
-                        Text::new("Start Game"),
+                        "Start Game",
-                        TextFont {
+                        TextStyle {
                             font_size: 40.0,
+                            color: Color::WHITE,
                             ..default()
                         },
-                        TextColor(Color::WHITE),
                     ));
                 });
         });
 }
 
 pub fn cleanup_start_menu_ui(mut commands: Commands, query: Query<Entity, With<StartMenuUI>>) {
-    for entity in &query {
+    println!("Exiting StartMenu state. Cleaning up UI.");
-        commands.entity(entity).despawn();
+    for entity in query.iter() {
+        commands.entity(entity).despawn_recursive();
     }
 }
 
 pub fn start_menu_button_system(
-    mut interactions: Query<
+    mut interaction_query: Query<
         (&Interaction, &mut BackgroundColor),
         (Changed<Interaction>, With<StartButton>),
     >,
-    mut next_state: ResMut<NextState<AppState>>,
+    mut app_state: ResMut<NextState<AppState>>,
 ) {
-    for (interaction, mut bg) in &mut interactions {
+    for (interaction, mut color) in &mut interaction_query {
         match *interaction {
-            Interaction::Pressed => next_state.set(AppState::Playing),
+            Interaction::Pressed => {
-            Interaction::Hovered => bg.0 = BUTTON_HOVER,
+                println!("Start button pressed! Transitioning to Playing state.");
-            Interaction::None => bg.0 = BUTTON_IDLE,
+                app_state.set(AppState::Playing);
+            }
+            Interaction::Hovered => {
+                color.0 = Color::rgb(0.2, 0.2, 0.7);
+            }
+            Interaction::None => {
+                color.0 = Color::rgb(0.1, 0.1, 0.5);
+            }
         }
     }
 }
 
 pub fn handle_restart_input(
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut restart: ResMut<RestartPressed>,
+    mut restart_resource: ResMut<RestartPressed>,
 ) {
-    if keyboard.just_pressed(KeyCode::KeyR) {
+    if keyboard_input.just_pressed(KeyCode::KeyR) {
-        restart.pressed = true;
+        restart_resource.pressed = true;
     }
 }
 
 pub fn restart_game_system(
-    mut next_state: ResMut<NextState<AppState>>,
+    mut app_state: ResMut<NextState<AppState>>,
-    mut restart: ResMut<RestartPressed>,
+    mut restart_resource: ResMut<RestartPressed>,
 ) {
-    if restart.pressed {
+    if restart_resource.pressed {
-        restart.pressed = false;
+        println!("Restart requested. Transitioning to Playing state.");
-        next_state.set(AppState::Playing);
+        restart_resource.pressed = false;
+        app_state.set(AppState::Playing);
     }
 }

src/lib.rs

@@ -1,132 +0,0 @@
-#![allow(clippy::type_complexity)]
-
-use bevy::prelude::*;
-use std::time::Duration;
-
-pub mod bullet;
-pub mod components;
-pub mod constants;
-pub mod enemy;
-pub mod game_state;
-pub mod player;
-pub mod resources;
-pub mod stage;
-pub mod starfield;
-pub mod systems;
-
-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 starfield::scroll_starfield;
-use systems::{
-    animate_explosion, player_exists, player_vulnerable, setup, should_respawn_player,
-    update_window_title,
-};
-
-pub fn run() {
-    App::new()
-        .insert_resource(ClearColor(Color::srgb(0.0, 0.0, 0.1)))
-        .add_plugins(DefaultPlugins.set(WindowPlugin {
-            primary_window: Some(Window {
-                title: "BGLGA".into(),
-                resolution: (WINDOW_WIDTH as u32, WINDOW_HEIGHT as u32).into(),
-                resizable: false,
-                ..default()
-            }),
-            ..default()
-        }))
-        .init_state::<AppState>()
-        .insert_resource(EnemySpawnTimer {
-            timer: Timer::new(Duration::from_secs_f32(1.0), TimerMode::Once),
-        })
-        .insert_resource(PlayerLives {
-            count: STARTING_LIVES,
-        })
-        .insert_resource(PlayerRespawnTimer {
-            timer: Timer::new(
-                Duration::from_secs_f32(PLAYER_RESPAWN_DELAY),
-                TimerMode::Once,
-            ),
-        })
-        .insert_resource(AttackDiveTimer {
-            timer: Timer::new(Duration::from_secs_f32(3.0), TimerMode::Once),
-        })
-        .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,
-            (
-                update_window_title,
-                spawn_enemies,
-                move_player.run_if(player_exists),
-                player_shoot.run_if(player_exists),
-                check_player_enemy_collisions.run_if(player_vulnerable),
-                respawn_player.run_if(should_respawn_player),
-                manage_invincibility,
-                handle_captured_player,
-                move_bullets,
-                check_bullet_collisions,
-                move_enemy_bullets,
-                check_enemy_bullet_player_collisions.run_if(player_vulnerable),
-                move_enemies,
-                enemy_shoot,
-                boss_capture_attack,
-                update_tractor_beam_visual.run_if(any_with_component::<TractorBeam>),
-            )
-                .run_if(in_state(AppState::Playing)),
-        )
-        .add_systems(
-            Update,
-            (
-                check_formation_complete,
-                trigger_attack_dives.run_if(is_formation_complete),
-                check_stage_clear,
-            )
-                .chain()
-                .run_if(in_state(AppState::Playing)),
-        )
-        // 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)),
-        )
-        // Game over.
-        .add_systems(OnEnter(AppState::GameOver), setup_game_over_ui)
-        .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();
-}

src/main.rs

@@ -1,3 +1,132 @@
+use bevy::prelude::*;
+use std::time::Duration;
+
+pub mod components;
+pub mod constants;
+pub mod resources;
+pub mod game_state;
+pub mod player;
+pub mod enemy;
+pub mod bullet;
+pub mod stage;
+pub mod systems;
+pub mod starfield;
+
+use constants::{PLAYER_RESPAWN_DELAY, STARTING_LIVES, WINDOW_HEIGHT, WINDOW_WIDTH};
+use resources::{ // Added StageConfigurations
+    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,
+};
+use bullet::{
+    check_bullet_collisions, check_enemy_bullet_player_collisions, move_bullets,
+    move_enemy_bullets,
+};
+use stage::check_stage_clear;
+use systems::{player_exists, player_vulnerable, setup, should_respawn_player, update_window_title};
+use starfield::scroll_starfield;
+
 fn main() {
-    bglga::run();
+    App::new()
+        .insert_resource(ClearColor(Color::rgb(0.0, 0.0, 0.1)))
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "BGLGA".into(),
+                resolution: (WINDOW_WIDTH, WINDOW_HEIGHT).into(),
+                resizable: false,
+                ..default()
+            }),
+            ..default()
+        }))
+        // Add states
+        .init_state::<AppState>() // Changed from add_state to init_state
+        // Initialize game resources
+        .insert_resource(EnemySpawnTimer {
+            timer: Timer::new(Duration::from_secs_f32(1.0), TimerMode::Once),
+        })
+        .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()) // Use default stages for now
+        .insert_resource(RestartPressed::default())
+        // Add startup systems
+        .add_systems(Startup, setup)
+        // Core game systems
+        .add_systems(
+            Update,
+            (
+                update_window_title,
+                // Enemy and player systems
+                spawn_enemies,
+                move_player.run_if(player_exists),
+                player_shoot.run_if(player_exists),
+                check_player_enemy_collisions.run_if(player_vulnerable),
+                respawn_player.run_if(should_respawn_player),
+                manage_invincibility,
+                handle_captured_player, // New system for handling captured player
+                // Bullet systems
+                move_bullets,
+                check_bullet_collisions,
+                move_enemy_bullets,
+                check_enemy_bullet_player_collisions.run_if(player_vulnerable),
+                // Enemy systems
+                move_enemies,
+                enemy_shoot, // Consider run_if attacking state? (Handled internally for now)
+                boss_capture_attack, // New system for boss tractor beam
+            )
+                .run_if(in_state(AppState::Playing)),
+        )
+        // Formation/Attack/Stage systems (some need specific ordering or run conditions)
+        .add_systems(
+            Update,
+            (
+                check_formation_complete,
+                trigger_attack_dives.run_if(is_formation_complete), // Run only when formation is complete
+                check_stage_clear, // Uses world access, run separately
+            )
+                .chain() // Ensure these run in order if needed, check_formation first
+                .run_if(in_state(AppState::Playing)),
+        )
+        // Starfield runs in all states
+        .add_systems(Update, scroll_starfield)
+        // UI and state management systems
+        .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(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)
+        .run();
 }

src/player.rs

@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+use bevy::ecs::system::ParamSet;
 use std::time::Duration;
 
 use crate::components::{Bullet, Captured, Enemy, Invincible, Player};
@@ -8,28 +9,28 @@ use crate::constants::{
 };
 use crate::game_state::AppState;
 use crate::resources::{PlayerLives, PlayerRespawnTimer};
-use crate::systems::spawn_explosion;
-
-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;
 
+// Helper to spawn player (used in setup and respawn)
 pub fn spawn_player_ship(commands: &mut Commands) {
     commands.spawn((
-        Sprite {
+        SpriteBundle {
-            color: Color::srgb(0.0, 0.5, 1.0),
+            sprite: Sprite {
-            custom_size: Some(PLAYER_SIZE),
+                color: Color::rgb(0.0, 0.5, 1.0),
+                custom_size: Some(PLAYER_SIZE),
+                ..default()
+            },
+            transform: Transform::from_translation(Vec3::new(
+                0.0,
+                -WINDOW_HEIGHT / 2.0 + PLAYER_SIZE.y / 2.0 + 20.0,
+                0.0,
+            )),
             ..default()
         },
-        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(
+            shoot_cooldown: Timer::new(Duration::from_secs_f32(0.3), TimerMode::Once),
-                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),
@@ -37,194 +38,251 @@ pub fn spawn_player_ship(commands: &mut Commands) {
             ),
         },
     ));
+    println!("Player spawned!");
 }
 
 pub fn move_player(
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&mut Transform, &Player), Without<Captured>>,
+    mut query: Query<(&mut Transform, &Player), Without<Captured>>, // Don't move captured players with controls
     time: Res<Time>,
 ) {
-    let Ok((mut transform, player)) = query.single_mut() else {
+    // Using get_single_mut handles the case where player might not exist yet (or was just destroyed)
-        return;
+    if let Ok((mut transform, player)) = query.get_single_mut() {
-    };
+        let mut direction = 0.0;
 
-    let mut direction = 0.0;
+        if keyboard_input.pressed(KeyCode::KeyA) || keyboard_input.pressed(KeyCode::ArrowLeft) {
-    if keyboard.pressed(KeyCode::KeyA) || keyboard.pressed(KeyCode::ArrowLeft) {
+            direction -= 1.0;
-        direction -= 1.0;
+        }
-    }
-    if keyboard.pressed(KeyCode::KeyD) || keyboard.pressed(KeyCode::ArrowRight) {
-        direction += 1.0;
-    }
 
-    transform.translation.x += direction * player.speed * time.delta_secs();
+        if keyboard_input.pressed(KeyCode::KeyD) || keyboard_input.pressed(KeyCode::ArrowRight) {
-    let half_width = PLAYER_SIZE.x / 2.0;
+            direction += 1.0;
-    transform.translation.x = transform
+        }
-        .translation
+
-        .x
+        transform.translation.x += direction * player.speed * time.delta_seconds();
-        .clamp(-WINDOW_WIDTH / 2.0 + half_width, WINDOW_WIDTH / 2.0 - half_width);
+        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,
+        );
+    }
 }
 
+// New system to handle captured player movement
 pub fn handle_captured_player(
     mut commands: Commands,
     time: Res<Time>,
-    mut player_query: Query<(Entity, &mut Transform, &mut Captured), With<Player>>,
+    mut set: ParamSet<(
-    boss_query: Query<&Transform, (With<Enemy>, Without<Player>)>,
+        Query<(Entity, &mut Transform, &mut Captured)>,
+        Query<&Transform, (With<Enemy>, Without<Player>)>,
+    )>,
     mut lives: ResMut<PlayerLives>,
     mut respawn_timer: ResMut<PlayerRespawnTimer>,
     mut next_state: ResMut<NextState<AppState>>,
 ) {
-    for (player_entity, mut transform, mut captured) in player_query.iter_mut() {
+    // First, collect data about captured players and their bosses
-        captured.timer.tick(time.delta());
+    let mut captured_data = Vec::new();
-
+    
-        let Ok(boss_transform) = boss_query.get(captured.boss_entity) else {
+    // Get player data
-            // Boss was despawned mid-capture: release and penalize.
+    for (entity, transform, captured) in set.p0().iter() {
-            commands.entity(player_entity).remove::<Captured>();
+        captured_data.push((entity, transform.translation, captured.boss_entity, captured.timer.clone()));
-            kill_player(
+    }
-                &mut commands,
+    
-                &mut lives,
+    // Process each captured player
-                &mut respawn_timer,
+    for (player_entity, _player_pos, boss_entity, mut timer) in captured_data {
-                &mut next_state,
+        // Check if the boss exists and get its position
-                player_entity,
+        let boss_pos = set.p1().get(boss_entity).map(|t| t.translation).ok();
-                transform.translation,
+        
-            );
+        // Tick the timer
-            continue;
+        timer.tick(time.delta());
-        };
+        
-
+        // Update the player
-        let target = boss_transform.translation - Vec3::Y * CAPTURE_OFFSET_BELOW_BOSS;
+        if let Ok((entity, mut transform, mut captured)) = set.p0().get_mut(player_entity) {
-        transform.translation = transform.translation.lerp(target, CAPTURE_FOLLOW_LERP);
+            // Update the actual timer
-
+            captured.timer.tick(time.delta());
-        if captured.timer.is_finished() {
+            
-            commands.entity(player_entity).remove::<Captured>();
+            match boss_pos {
-            kill_player(
+                Some(boss_pos) => {
-                &mut commands,
+                    // Boss exists, update player position
-                &mut lives,
+                    let target_pos = boss_pos - Vec3::new(0.0, PLAYER_SIZE.y + 10.0, 0.0);
-                &mut respawn_timer,
+                    transform.translation = transform.translation.lerp(target_pos, 0.2);
-                &mut next_state,
+                }
-                player_entity,
+                None => {
-                transform.translation,
+                    // 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,
+                    );
+                    continue; // Skip the rest of processing for this player
+                }
+            }
+            
+            // If capture duration expires, player escapes but loses a life
+            if captured.timer.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,
+                );
+            }
         }
     }
 }
 
-/// Despawn the player at `position`, decrement lives, and either start the respawn
+// Helper function for player life loss and respawn logic
-/// timer or transition to GameOver. Does not handle collateral entities (the caller
+fn lose_life_and_respawn(
-/// despawns enemies/bullets/etc. as needed).
-pub(crate) fn kill_player(
     commands: &mut Commands,
-    lives: &mut PlayerLives,
+    lives: &mut ResMut<PlayerLives>,
-    respawn_timer: &mut PlayerRespawnTimer,
+    respawn_timer: &mut ResMut<PlayerRespawnTimer>,
-    next_state: &mut NextState<AppState>,
+    next_state: &mut ResMut<NextState<AppState>>,
     player_entity: Entity,
-    position: Vec3,
 ) {
+    // Lose a life
     lives.count = lives.count.saturating_sub(1);
-    spawn_explosion(commands, position);
+    println!("Lives remaining: {}", lives.count);
+
+    // Destroy player
     commands.entity(player_entity).despawn();
 
     if lives.count > 0 {
         respawn_timer.timer.reset();
         respawn_timer.timer.unpause();
+        println!("Respawn timer started.");
     } else {
-        info!("GAME OVER");
+        println!("GAME OVER!");
         next_state.set(AppState::GameOver);
     }
 }
 
 pub fn player_shoot(
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&Transform, &mut Player), Without<Captured>>,
+    mut query: Query<(&Transform, &mut Player), Without<Captured>>, // Only non-captured players can shoot
     mut commands: Commands,
     time: Res<Time>,
 ) {
-    let Ok((transform, mut player)) = query.single_mut() else {
+    if let Ok((player_transform, mut player)) = query.get_single_mut() {
-        return;
+        player.shoot_cooldown.tick(time.delta());
-    };
-    player.shoot_cooldown.tick(time.delta());
 
-    let fire = keyboard.just_pressed(KeyCode::Space) || keyboard.just_pressed(KeyCode::ArrowUp);
+        if (keyboard_input.just_pressed(KeyCode::Space)
-    if !fire || !player.shoot_cooldown.is_finished() {
+            || keyboard_input.just_pressed(KeyCode::ArrowUp))
-        return;
+            && player.shoot_cooldown.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((
+                SpriteBundle {
+                    sprite: Sprite {
+                        color: Color::rgb(1.0, 1.0, 1.0),
+                        custom_size: Some(BULLET_SIZE),
+                        ..default()
+                    },
+                    transform: Transform::from_translation(bullet_start_pos),
+                    ..default()
+                },
+                Bullet,
+            ));
+        }
     }
-    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>>,
+    mut next_state: ResMut<NextState<AppState>>, // Resource to change state
+    // Query player without Invincible component - relies on run_if condition too
     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>>,
 ) {
-    let Ok((player_entity, player_transform)) = player_query.single() else {
+    // This system only runs if player exists and is not invincible, due to run_if
-        return;
+    if let Ok((player_entity, player_transform)) = player_query.get_single() {
-    };
+        for (enemy_entity, enemy_transform) in enemy_query.iter() {
-    let player_pos = player_transform.translation;
+            let distance = player_transform
+                .translation
+                .distance(enemy_transform.translation);
 
-    let Some((enemy_entity, enemy_transform)) = enemy_query
+            if distance < PLAYER_ENEMY_COLLISION_THRESHOLD {
-        .iter()
+                println!("Player hit by enemy!");
-        .find(|(_, t)| player_pos.distance(t.translation) < PLAYER_ENEMY_COLLISION_THRESHOLD)
+                commands.entity(enemy_entity).despawn(); // Despawn enemy
-    else {
-        return;
-    };
 
-    spawn_explosion(&mut commands, enemy_transform.translation);
+                lives.count = lives.count.saturating_sub(1); // Decrement lives safely
-    commands.entity(enemy_entity).despawn();
+                println!("Lives remaining: {}", lives.count);
-    kill_player(
+
-        &mut commands,
+                commands.entity(player_entity).despawn(); // Despawn player
-        &mut lives,
+
-        &mut respawn_timer,
+                if lives.count > 0 {
-        &mut next_state,
+                    // Start the respawn timer
-        player_entity,
+                    respawn_timer.timer.reset();
-        player_pos,
+                    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;
+            }
+        }
+    }
 }
 
+// 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();
+        respawn_timer.timer.pause(); // Pause timer until next death
     }
 }
 
+// New System: Manage Invincibility
 pub fn manage_invincibility(
     mut commands: Commands,
     time: Res<Time>,
-    mut query: Query<(Entity, &mut Invincible, &mut Visibility), With<Player>>,
+    mut query: Query<(Entity, &mut Invincible, Option<&mut Visibility>), With<Player>>,
 ) {
     for (entity, mut invincible, mut visibility) in query.iter_mut() {
         invincible.timer.tick(time.delta());
 
-        if invincible.timer.is_finished() {
+        // Blinking effect (optional)
-            commands.entity(entity).remove::<Invincible>();
+        if let Some(ref mut vis) = visibility {
-            *visibility = Visibility::Visible;
+            // Blink roughly 5 times per second
-        } else {
+            let elapsed_secs = invincible.timer.elapsed_secs();
-            // Blink at INVINCIBILITY_BLINK_HZ / 2 (one full cycle = 2 floor steps).
+            **vis = if (elapsed_secs * 10.0).floor() % 2.0 == 0.0 {
-            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.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;
+            }
+        }
     }
 }

src/resources.rs

@@ -1,11 +1,6 @@
 use bevy::prelude::*;
 
-use crate::components::AttackPattern;
+// --- Resources ---
-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,
@@ -21,57 +16,59 @@ pub struct PlayerRespawnTimer {
     pub timer: Timer,
 }
 
+// New struct to define formation positions
 #[derive(Clone, Debug)]
 pub struct FormationLayout {
-    pub name: String,
+    pub name: String, // Optional name for debugging/identification
     pub positions: Vec<Vec3>,
 }
 
+// Default implementation for easy initialization
 impl Default for FormationLayout {
     fn default() -> Self {
-        let positions = (0..FORMATION_ENEMY_COUNT)
+        // Default to the original grid formation for now
-            .map(|i| {
+        let mut positions = Vec::with_capacity(crate::constants::FORMATION_ENEMY_COUNT);
-                let row = i / FORMATION_COLS;
+        for i in 0..crate::constants::FORMATION_ENEMY_COUNT {
-                let col = i % FORMATION_COLS;
+            let row = i / crate::constants::FORMATION_COLS;
-                let x = (col as f32 - (FORMATION_COLS as f32 - 1.0) / 2.0) * FORMATION_X_SPACING;
+            let col = i % crate::constants::FORMATION_COLS;
-                let y = FORMATION_BASE_Y - row as f32 * FORMATION_Y_SPACING;
+            let target_x = (col as f32 - (crate::constants::FORMATION_COLS as f32 - 1.0) / 2.0)
-                Vec3::new(x, y, 0.0)
+                * crate::constants::FORMATION_X_SPACING;
-            })
+            let target_y = crate::constants::FORMATION_BASE_Y
-            .collect();
+                - (row as f32 * crate::constants::FORMATION_Y_SPACING);
-        Self {
+            positions.push(Vec3::new(target_x, target_y, 0.0));
+        }
+        FormationLayout {
             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,
+    pub enemy_count: usize, // Allow overriding enemy count per stage
-    pub attack_patterns: Vec<AttackPattern>,
+    pub attack_patterns: Vec<crate::components::AttackPattern>, // Possible patterns for this stage
-    pub attack_dive_interval: f32,
+    pub attack_dive_interval: f32, // Time between attack dives for this stage
-    pub enemy_speed_multiplier: f32,
+    pub enemy_speed_multiplier: f32, // Speed multiplier for this stage
-    pub enemy_shoot_interval: f32,
+    pub enemy_shoot_interval: f32, // Shoot interval for this stage
 }
 
+// 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(),
+            formation_layout: FormationLayout::default(), // Use the default grid
             enemy_count: FORMATION_ENEMY_COUNT,
             attack_patterns: vec![AttackPattern::SwoopDive],
             attack_dive_interval: 3.0,
@@ -79,36 +76,41 @@ impl Default for StageConfigurations {
             enemy_shoot_interval: ENEMY_SHOOT_INTERVAL,
         };
 
-        let stage2_layout = circle_formation(16, WINDOW_WIDTH / 4.0, FORMATION_BASE_Y - 50.0);
+        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 = StageConfig {
             formation_layout: stage2_layout,
             enemy_count: 16,
-            attack_patterns: vec![AttackPattern::SwoopDive, AttackPattern::DirectDive],
+            attack_patterns: vec![AttackPattern::SwoopDive, AttackPattern::DirectDive], // Add direct dive
-            attack_dive_interval: 2.5,
+            attack_dive_interval: 2.5,   // Faster dives
-            enemy_speed_multiplier: 1.2,
+            enemy_speed_multiplier: 1.2, // Faster enemies
-            enemy_shoot_interval: ENEMY_SHOOT_INTERVAL * 0.8,
+            enemy_shoot_interval: ENEMY_SHOOT_INTERVAL * 0.8, // Faster shooting
         };
 
-        Self {
+        // Add more stages here...
-            stages: vec![stage1, stage2],
+
+        StageConfigurations {
+            stages: vec![stage1, stage2], // Add more stages as needed
         }
     }
 }
-
+#[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,
 }
@@ -116,23 +118,14 @@ pub struct Score {
 #[derive(Resource)]
 pub struct CurrentStage {
     pub number: u32,
-    pub waiting_for_clear: bool,
+    pub waiting_for_clear: bool, // Flag to check if we should check for stage clear
 }
 
-impl Default for CurrentStage {
+#[derive(Resource)]
-    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,
+    pub formation_complete: bool, // Flag to indicate if all enemies are in position
 }
 
 #[derive(Resource)]

src/stage.rs

@@ -3,19 +3,35 @@ use bevy::prelude::*;
 use crate::components::Enemy;
 use crate::resources::{CurrentStage, EnemySpawnTimer, FormationState};
 
-pub fn check_stage_clear(
+// Helper to access world directly in check_stage_clear
-    enemy_query: Query<(), With<Enemy>>,
+pub fn check_stage_clear(world: &mut World) {
-    mut stage: ResMut<CurrentStage>,
+    // Use manual resource access because we need mutable access to multiple resources
-    mut formation_state: ResMut<FormationState>,
+    // Separate checks to manage borrows correctly
-    mut spawn_timer: ResMut<EnemySpawnTimer>,
+    let mut should_clear = false;
-) {
+    if let Some(stage) = world.get_resource::<CurrentStage>() {
-    if !stage.waiting_for_clear || !enemy_query.is_empty() {
+        if stage.waiting_for_clear {
-        return;
+            // 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;
+            }
+        }
     }
 
-    stage.number += 1;
+    if should_clear {
-    stage.waiting_for_clear = false;
+        // Get mutable resources only when needed
-    *formation_state = FormationState::default();
+        if let Some(mut stage) = world.get_resource_mut::<CurrentStage>() {
-    spawn_timer.timer.reset();
+            stage.number += 1;
-    info!("Starting Stage {}", stage.number);
+            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();
+        }
+    }
+}

src/starfield.rs

@@ -2,49 +2,47 @@ 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,
+    STAR_COUNT, STAR_MAX_SIZE, STAR_MAX_SPEED, STAR_MIN_SIZE, STAR_MIN_SPEED,
-    WINDOW_HEIGHT, WINDOW_WIDTH,
+    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 = lerp_random(STAR_MIN_SIZE, STAR_MAX_SIZE);
+        let size = fastrand::f32() * (STAR_MAX_SIZE - STAR_MIN_SIZE) + STAR_MIN_SIZE;
-        let speed = lerp_random(STAR_MIN_SPEED, STAR_MAX_SPEED);
+        let speed = fastrand::f32() * (STAR_MAX_SPEED - STAR_MIN_SPEED) + STAR_MIN_SPEED;
-        let brightness = 0.5 + fastrand::f32() * 0.5;
+        let brightness = fastrand::f32() * 0.5 + 0.5; // 0.5 to 1.0
 
         commands.spawn((
-            Sprite {
+            SpriteBundle {
-                color: Color::srgb(brightness, brightness, brightness),
+                sprite: Sprite {
-                custom_size: Some(Vec2::splat(size)),
+                    color: Color::rgb(brightness, brightness, brightness),
+                    custom_size: Some(Vec2::new(size, size)),
+                    ..default()
+                },
+                transform: Transform::from_translation(Vec3::new(
+                    fastrand::f32() * WINDOW_WIDTH - WINDOW_WIDTH / 2.0,
+                    fastrand::f32() * WINDOW_HEIGHT - WINDOW_HEIGHT / 2.0,
+                    STAR_Z_DEPTH,
+                )),
                 ..default()
             },
-            Transform::from_xyz(
-                (fastrand::f32() - 0.5) * WINDOW_WIDTH,
-                (fastrand::f32() - 0.5) * WINDOW_HEIGHT,
-                STAR_Z_DEPTH,
-            ),
             Star { speed },
         ));
     }
 }
 
 pub fn scroll_starfield(mut star_query: Query<(&mut Transform, &Star)>, time: Res<Time>) {
-    let dt = time.delta_secs();
+    let dt = time.delta_seconds();
-    let half_h = WINDOW_HEIGHT / 2.0;
+    let half_height = WINDOW_HEIGHT / 2.0;
+    let half_width = WINDOW_WIDTH / 2.0;
 
     for (mut transform, star) in star_query.iter_mut() {
-        let parallax = -transform.translation.y * PARALLAX_FACTOR;
+        let parallax = -transform.translation.y * 0.01;
         transform.translation.y -= (star.speed + parallax) * dt;
 
-        if transform.translation.y < -half_h {
+        if transform.translation.y < -half_height {
-            transform.translation.y = half_h;
+            transform.translation.y = half_height;
-            transform.translation.x = (fastrand::f32() - 0.5) * WINDOW_WIDTH;
+            transform.translation.x = fastrand::f32() * WINDOW_WIDTH - half_width;
         }
     }
 }
-
-fn lerp_random(min: f32, max: f32) -> f32 {
-    min + fastrand::f32() * (max - min)
-}

src/systems.rs

@@ -1,20 +1,18 @@
 use bevy::prelude::*;
-use std::time::Duration;
 
-use crate::components::{Explosion, Invincible, Player};
+use crate::components::{Invincible, Player};
-use crate::constants::{EXPLOSION_BASE_SIZE, EXPLOSION_COLOR, EXPLOSION_DURATION, EXPLOSION_MAX_SIZE};
-use crate::player::spawn_player_ship;
 use crate::resources::{CurrentStage, PlayerLives, Score};
+use crate::player::spawn_player_ship;
 use crate::starfield::spawn_starfield;
 
+// --- Setup ---
 pub fn setup(mut commands: Commands) {
-    commands.spawn(Camera2d);
+    commands.spawn(Camera2dBundle::default());
     spawn_starfield(&mut commands);
     spawn_player_ship(&mut commands);
 }
 
-// --- Run conditions ---
+// --- Run Conditions ---
-
 pub fn player_exists(query: Query<&Player>) -> bool {
     !query.is_empty()
 }
@@ -23,61 +21,27 @@ pub fn player_vulnerable(query: Query<&Player, Without<Invincible>>) -> bool {
     !query.is_empty()
 }
 
-pub fn should_respawn_player(lives: Res<PlayerLives>, query: Query<&Player>) -> bool {
+pub fn should_respawn_player(lives: Res<PlayerLives>, player_query: Query<&Player>) -> bool {
-    query.is_empty() && lives.count > 0
+    player_query.is_empty() && lives.count > 0
 }
 
-// --- HUD ---
+// Moved is_formation_complete to enemy.rs as it's closely related to enemy logic
 
+// --- General Systems ---
+
+// Update Window Title with Lives, Score, and Stage
 pub fn update_window_title(
     lives: Res<PlayerLives>,
     score: Res<Score>,
-    stage: Res<CurrentStage>,
+    stage: Res<CurrentStage>, // Add CurrentStage resource
     mut windows: Query<&mut Window>,
 ) {
-    if !(lives.is_changed() || score.is_changed() || stage.is_changed()) {
+    // Update if lives, score, or stage changed
-        return;
+    if lives.is_changed() || score.is_changed() || stage.is_changed() {
-    }
+        let mut window = windows.single_mut();
-    if let Ok(mut window) = windows.single_mut() {
         window.title = format!(
             "Galaga :: Stage: {} Lives: {} Score: {}",
             stage.number, lives.count, score.value
         );
     }
-}
+}
-
-// --- Explosions ---
-
-pub fn spawn_explosion(commands: &mut Commands, position: Vec3) {
-    commands.spawn((
-        Sprite {
-            color: EXPLOSION_COLOR,
-            custom_size: Some(EXPLOSION_BASE_SIZE),
-            ..default()
-        },
-        Transform::from_translation(position),
-        Explosion {
-            timer: Timer::new(Duration::from_secs_f32(EXPLOSION_DURATION), TimerMode::Once),
-        },
-    ));
-}
-
-pub fn animate_explosion(
-    mut commands: Commands,
-    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 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();
-        }
-    }
-}